@woosh/meep-engine 3.23.0 → 3.25.0

package/src/shade/renderer/animation/ShadeAnimationChannel.d.ts

@@ -12,7 +12,7 @@
  */
 /**
  * One binding inside a {@link ShadeAnimationClip}: a single target
- * Node3D, the property of that node being animated, and the
+ * node, the property of that node being animated, and the
  * per-component curves driving each scalar slot.
  *
  * Curve slots are property-specific and align with the GPU track's
@@ -30,8 +30,8 @@
  * still a valid unit quaternion after normalise.
  *
  * Pure CPU data. Knows nothing about the GPU; consumed by
- * {@link GPUAnimationManager#register_clip}, which resolves the
- * target to a transforms-table row and uploads the curves.
+ * {@link GPUAnimationManager#register_clip}, which binds the target
+ * entity's row and uploads the curves.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
@@ -39,25 +39,26 @@
 export class ShadeAnimationChannel {
     /**
      * @param {{
-     *     target: Node3D,
+     *     target: number,
      *     property: number,
      *     curves: ChannelCurves,
      * }} args
      * @returns {ShadeAnimationChannel}
      */
     static from({ target, property, curves }: {
-        target: Node3D;
+        target: number;
         property: number;
         curves: ChannelCurves;
     }): ShadeAnimationChannel;
     /**
-     * Scene-graph node whose property this channel animates. Resolved
-     * to its `transforms` table row at registration time via the
-     * scene context's `id_mapping`.
+     * What this channel animates: an index into the bundle's nodes in a loader's bundle, a node
+     * index in a compiled prefab, an entity in a prefab instance — which is the form
+     * {@link GPUAnimationManager#register_clip} takes, the entity's row being `entity + 1`.
+     * `null` until {@link from} names it.
      *
-     * @type {Node3D}
+     * @type {number|null}
      */
-    target: Node3D;
+    target: number | null;
     /**
      * Which property of {@link target} is animated. One of
      * {@link Node3DProperty}. The GPU clip binding stores this as
@@ -90,14 +91,15 @@ export class ShadeAnimationChannel {
     /**
      * Structural clone. Target is shared with the original; callers
      * who clone a clip for a new character instance should overwrite
-     * `clone.target` with the new joint Node3D.
+     * `clone.target` with the new target.
      *
      * @returns {ShadeAnimationChannel}
      */
     clone(): ShadeAnimationChannel;
     /**
      * Evaluate this channel's curves at time `t` and write the
-     * result into {@link target}'s `transform_local`.
+     * result into `transform` — the local transform of whatever
+     * {@link target} names, which the caller resolves.
      *
      * - Translation / Scale: per-axis: an absent slot leaves the
      *   axis untouched, so partial-axis channels are non-destructive
@@ -108,14 +110,15 @@ export class ShadeAnimationChannel {
      *   scalar curves drifts off the unit 4-sphere; the GPU apply
      *   shader does the same normalise.
      *
-     * Mutates `target`. Callers that need to preserve the bind
+     * Mutates `transform`. Callers that need to preserve the bind
      * pose are responsible for snapshotting before calling and
-     * restoring after — or pass a {@link Node3D#clone}d target so
-     * the original is untouched.
+     * restoring after — or pass a copy, so the original is
+     * untouched.
      *
      * @param {number} t
+     * @param {Transform64} transform
      */
-    apply(t: number): void;
+    apply(t: number, transform: Transform64): void;
     /**
      * Number of currently-live curves on this channel — slots
      * defined as a non-undefined value. After {@link optimize} this
@@ -134,10 +137,10 @@ export class ShadeAnimationChannel {
      * authored rest value for that component already sits at the
      * identity: an absent slot leaves the rest value in place,
      * while a present constant-identity curve overwrites it. So
-     * every drop below is gated on the target's `transform_local`
-     * rest component matching the identity value (within
-     * {@link IDENTITY_EPSILON}). When the rest transform isn't
-     * available the channel is kept — conservative.
+     * every drop below is gated on the target's rest transform —
+     * `rest`, the node's own local — having that component at the
+     * identity value (within {@link IDENTITY_EPSILON}). When no rest
+     * transform is given the channel is kept — conservative.
      *
      * Per-property semantics:
      *  - **Translation** (identity = `(0, 0, 0)`): each axis whose
@@ -170,12 +173,13 @@ export class ShadeAnimationChannel {
      * identity AND both tangents within tolerance of zero (cubic
      * Hermite between such keyframes provably stays at the value).
      *
+     * @param {Transform64} [rest] the target's rest transform; without one nothing is dropped
      * @returns {number} count of per-axis curve slots null'd out
      *     (Translation/Scale: 0..3; Rotation: 0 or 4 — all-or-
      *     nothing). Use {@link curve_count} after the call to
      *     decide whether the channel is now empty.
      */
-    optimize(): number;
+    optimize(rest?: Transform64): number;
     /**
      * @readonly
      * @type {boolean}
@@ -184,7 +188,7 @@ export class ShadeAnimationChannel {
     #private;
 }
 export type AnimationCurve = import("../../../engine/animation/curve/AnimationCurve.js").AnimationCurve;
-export type Node3D = import("../scene/Node3D.js").Node3D;
+export type Transform64 = import("../../../engine/ecs/transform/Transform64.js").Transform64;
 /**
  * Per-component curves keyed by the GPU track's `(x, y, z, w)`
  * channels. Slots omitted (or set to `undefined`) leave that

package/src/shade/renderer/animation/ShadeAnimationChannel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShadeAnimationChannel.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/ShadeAnimationChannel.js"],"names":[],"mappings":"AAmEA;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IA6BI;;;;;;;OAOG;IACH,0CAPW;QACV,MAAY,EAAE,MAAM,CAAC;QACrB,QAAc,EAAE,MAAM,CAAC;QACvB,MAAY,EAAE,aAAa,CAAC;KACzB,GACS,qBAAqB,CAsBjC;IAvDD;;;;;;OAMG;IACH,QAFU,MAAM,CAEF;IAEd;;;;;;;OAOG;IACH,UAFU,MAAM,CAEH;IAEb;;;;;OAKG;IACH,QAFU,aAAa,CAEX;IAgCZ;;;;;;;;;;;OAWG;IACH,YAFW,qBAAqB,QAa/B;IAED;;;;;;OAMG;IACH,SAFa,qBAAqB,CAMjC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,SAFW,MAAM,QA4ChB;IAED;;;;;;;;;OASG;IACH,0BAQC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+CG;IACH,YALa,MAAM,CAmElB;IAiBL;;;OAGG;IACH,kCAFU,OAAO,CAEsC;;CANtD;6BA/YY,OAAO,mDAAmD,EAAE,cAAc;qBAC1E,OAAO,oBAAoB,EAAE,MAAM;;;;;;;;QA4DlC,cAAc;QACd,cAAc;QACd,cAAc;QACd,cAAc"}
+{"version":3,"file":"ShadeAnimationChannel.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/ShadeAnimationChannel.js"],"names":[],"mappings":"AAmEA;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IA8BI;;;;;;;OAOG;IACH,0CAPW;QACV,MAAY,EAAE,MAAM,CAAC;QACrB,QAAc,EAAE,MAAM,CAAC;QACvB,MAAY,EAAE,aAAa,CAAC;KACzB,GACS,qBAAqB,CAsBjC;IAxDD;;;;;;;OAOG;IACH,QAFU,MAAM,GAAC,IAAI,CAEP;IAEd;;;;;;;OAOG;IACH,UAFU,MAAM,CAEH;IAEb;;;;;OAKG;IACH,QAFU,aAAa,CAEX;IAgCZ;;;;;;;;;;;OAWG;IACH,YAFW,qBAAqB,QAa/B;IAED;;;;;;OAMG;IACH,SAFa,qBAAqB,CAMjC;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,SAHW,MAAM,aACN,WAAW,QA8CrB;IAED;;;;;;;;;OASG;IACH,0BAQC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgDG;IACH,gBANW,WAAW,GACT,MAAM,CAkElB;IAiBL;;;OAGG;IACH,kCAFU,OAAO,CAEsC;;CANtD;6BApZY,OAAO,mDAAmD,EAAE,cAAc;0BAC1E,OAAO,8CAA8C,EAAE,WAAW;;;;;;;;QA4DjE,cAAc;QACd,cAAc;QACd,cAAc;QACd,cAAc"}

package/src/shade/renderer/animation/ShadeAnimationChannel.js

@@ -12,7 +12,7 @@ import { Node3DProperty } from "../object_property/Node3DProperty.js";
 
 /**
  * @typedef {import("../../../engine/animation/curve/AnimationCurve.js").AnimationCurve} AnimationCurve
- * @typedef {import("../scene/Node3D.js").Node3D} Node3D
+ * @typedef {import("../../../engine/ecs/transform/Transform64.js").Transform64} Transform64
  */
 
 /**
@@ -80,7 +80,7 @@ function is_curve_constant(curve, expected_value) {
 
 /**
  * One binding inside a {@link ShadeAnimationClip}: a single target
- * Node3D, the property of that node being animated, and the
+ * node, the property of that node being animated, and the
  * per-component curves driving each scalar slot.
  *
  * Curve slots are property-specific and align with the GPU track's
@@ -98,8 +98,8 @@ function is_curve_constant(curve, expected_value) {
  * still a valid unit quaternion after normalise.
  *
  * Pure CPU data. Knows nothing about the GPU; consumed by
- * {@link GPUAnimationManager#register_clip}, which resolves the
- * target to a transforms-table row and uploads the curves.
+ * {@link GPUAnimationManager#register_clip}, which binds the target
+ * entity's row and uploads the curves.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
@@ -107,11 +107,12 @@ function is_curve_constant(curve, expected_value) {
 export class ShadeAnimationChannel {
 
     /**
-     * Scene-graph node whose property this channel animates. Resolved
-     * to its `transforms` table row at registration time via the
-     * scene context's `id_mapping`.
+     * What this channel animates: an index into the bundle's nodes in a loader's bundle, a node
+     * index in a compiled prefab, an entity in a prefab instance — which is the form
+     * {@link GPUAnimationManager#register_clip} takes, the entity's row being `entity + 1`.
+     * `null` until {@link from} names it.
      *
-     * @type {Node3D}
+     * @type {number|null}
      */
     target = null;
 
@@ -135,14 +136,14 @@ export class ShadeAnimationChannel {
 
     /**
      * @param {{
-     *     target: Node3D,
+     *     target: number,
      *     property: number,
      *     curves: ChannelCurves,
      * }} args
      * @returns {ShadeAnimationChannel}
      */
     static from({ target, property, curves }) {
-        assert.defined(target, 'target');
+        assert.isNonNegativeInteger(target, 'target');
         assert.isNumber(property, 'property');
         assert.defined(curves, 'curves');
 
@@ -191,7 +192,7 @@ export class ShadeAnimationChannel {
     /**
      * Structural clone. Target is shared with the original; callers
      * who clone a clip for a new character instance should overwrite
-     * `clone.target` with the new joint Node3D.
+     * `clone.target` with the new target.
      *
      * @returns {ShadeAnimationChannel}
      */
@@ -203,7 +204,8 @@ export class ShadeAnimationChannel {
 
     /**
      * Evaluate this channel's curves at time `t` and write the
-     * result into {@link target}'s `transform_local`.
+     * result into `transform` — the local transform of whatever
+     * {@link target} names, which the caller resolves.
      *
      * - Translation / Scale: per-axis: an absent slot leaves the
      *   axis untouched, so partial-axis channels are non-destructive
@@ -214,16 +216,19 @@ export class ShadeAnimationChannel {
      *   scalar curves drifts off the unit 4-sphere; the GPU apply
      *   shader does the same normalise.
      *
-     * Mutates `target`. Callers that need to preserve the bind
+     * Mutates `transform`. Callers that need to preserve the bind
      * pose are responsible for snapshotting before calling and
-     * restoring after — or pass a {@link Node3D#clone}d target so
-     * the original is untouched.
+     * restoring after — or pass a copy, so the original is
+     * untouched.
      *
      * @param {number} t
+     * @param {Transform64} transform
      */
-    apply(t) {
+    apply(t, transform) {
+        assert.defined(transform, 'transform');
+
         const curves = this.curves;
-        const tl = this.target.transform_local;
+        const tl = transform;
 
         switch (this.property) {
             case Node3DProperty.Translation: {
@@ -292,10 +297,10 @@ export class ShadeAnimationChannel {
      * authored rest value for that component already sits at the
      * identity: an absent slot leaves the rest value in place,
      * while a present constant-identity curve overwrites it. So
-     * every drop below is gated on the target's `transform_local`
-     * rest component matching the identity value (within
-     * {@link IDENTITY_EPSILON}). When the rest transform isn't
-     * available the channel is kept — conservative.
+     * every drop below is gated on the target's rest transform —
+     * `rest`, the node's own local — having that component at the
+     * identity value (within {@link IDENTITY_EPSILON}). When no rest
+     * transform is given the channel is kept — conservative.
      *
      * Per-property semantics:
      *  - **Translation** (identity = `(0, 0, 0)`): each axis whose
@@ -328,14 +333,14 @@ export class ShadeAnimationChannel {
      * identity AND both tangents within tolerance of zero (cubic
      * Hermite between such keyframes provably stays at the value).
      *
+     * @param {Transform64} [rest] the target's rest transform; without one nothing is dropped
      * @returns {number} count of per-axis curve slots null'd out
      *     (Translation/Scale: 0..3; Rotation: 0 or 4 — all-or-
      *     nothing). Use {@link curve_count} after the call to
      *     decide whether the channel is now empty.
      */
-    optimize() {
+    optimize(rest) {
         const curves = this.curves;
-        const rest = this.target !== null ? this.target.transform_local : undefined;
         let removed = 0;
 
         switch (this.property) {

package/src/shade/renderer/animation/ShadeAnimationClip.d.ts

@@ -1,10 +1,13 @@
+/**
+ * @typedef {import("../../../engine/ecs/transform/Transform64.js").Transform64} Transform64
+ */
 /**
  * @typedef {import("./ShadeAnimationChannel.js").ShadeAnimationChannel} ShadeAnimationChannel
  */
 /**
  * A bundle of {@link ShadeAnimationChannel}s sharing one playback
  * clock — the GPU-driven equivalent of an animation "clip". Each
- * channel targets a Node3D + property; together they describe a
+ * channel targets a node + property; together they describe a
  * coordinated motion (e.g. "wave" might rotate the shoulder, elbow,
  * and wrist joints in lockstep).
  *
@@ -70,7 +73,7 @@ export class ShadeAnimationClip {
      *
      * Retargeting after cloning is the caller's job: walk
      * `clone.channels` and replace each channel's `target` with the
-     * matching new Node3D. See the dancer prototype for the typical
+     * matching new target. See the dancer prototype for the typical
      * pattern (`Map<old_joint, new_joint>` plus a per-channel
      * lookup).
      *
@@ -85,8 +88,8 @@ export class ShadeAnimationClip {
      */
     clone(): ShadeAnimationClip;
     /**
-     * Apply every channel's evaluated value at time `t` to its
-     * target Node3D's `transform_local`. Thin orchestrator over
+     * Apply every channel's evaluated value at time `t` to the
+     * transform `transform_of` answers for its target. Thin orchestrator over
      * {@link ShadeAnimationChannel#apply} — same mutation
      * semantics: callers preserving the bind pose must snapshot
      * before calling and restore after.
@@ -98,8 +101,9 @@ export class ShadeAnimationClip {
      * computation).
      *
      * @param {number} t
+     * @param {function(number): Transform64} transform_of the local transform of a target
      */
-    apply(t: number): void;
+    apply(t: number, transform_of: (arg0: number) => Transform64): void;
     /**
      * Strip identity channels and identity per-axis curves from
      * the clip — applying it post-optimize is observationally
@@ -119,13 +123,17 @@ export class ShadeAnimationClip {
      * `clip.channels.length` and the sum of `channel.curve_count`
      * across channels themselves; the method intentionally
      * doesn't return them — single source of truth.
+     *
+     * @param {function(number): (Transform64|undefined)} [rest_of] the rest transform of a
+     *        target — a bundle's node local; without it nothing is dropped
      */
-    optimize(): void;
+    optimize(rest_of?: (arg0: number) => (Transform64 | undefined)): void;
     /**
      * @readonly
      * @type {boolean}
      */
     readonly isShadeAnimationClip: boolean;
 }
+export type Transform64 = import("../../../engine/ecs/transform/Transform64.js").Transform64;
 export type ShadeAnimationChannel = import("./ShadeAnimationChannel.js").ShadeAnimationChannel;
 //# sourceMappingURL=ShadeAnimationClip.d.ts.map

package/src/shade/renderer/animation/ShadeAnimationClip.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShadeAnimationClip.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/ShadeAnimationClip.js"],"names":[],"mappings":"AAEA;;GAEG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACH;IA+DI;;;OAGG;IACH,gCAHW;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,qBAAqB,EAAE,CAAA;KAAE,GAClD,kBAAkB,CAU9B;IAzED;;;;OAIG;IACH,MAFU,MAAM,CAEN;IAEV;;;;;;OAMG;IACH,UAFU,qBAAqB,EAAE,CAEnB;IAEd;;;;;OAKG;IACH,yBAWC;IAED;;;;;OAKG;IACH,uBAWC;IAED;;OAEG;IACH,uBAEC;IAgBD;;;;;;;;;;;;;;OAcG;IACH,YAFW,kBAAkB,QAY5B;IAED;;;;;OAKG;IACH,SAFa,kBAAkB,CAM9B;IAED;;;;;;;;;;;;;;OAcG;IACH,SAFW,MAAM,QAQhB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,iBAWC;IAGL;;;OAGG;IACH,+BAFU,OAAO,CAEgC;CANhD;oCAjMY,OAAO,4BAA4B,EAAE,qBAAqB"}
+{"version":3,"file":"ShadeAnimationClip.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/ShadeAnimationClip.js"],"names":[],"mappings":"AAEA;;GAEG;AAEH;;GAEG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACH;IA+DI;;;OAGG;IACH,gCAHW;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,qBAAqB,EAAE,CAAA;KAAE,GAClD,kBAAkB,CAU9B;IAzED;;;;OAIG;IACH,MAFU,MAAM,CAEN;IAEV;;;;;;OAMG;IACH,UAFU,qBAAqB,EAAE,CAEnB;IAEd;;;;;OAKG;IACH,yBAWC;IAED;;;;;OAKG;IACH,uBAWC;IAED;;OAEG;IACH,uBAEC;IAgBD;;;;;;;;;;;;;;OAcG;IACH,YAFW,kBAAkB,QAY5B;IAED;;;;;OAKG;IACH,SAFa,kBAAkB,CAM9B;IAED;;;;;;;;;;;;;;;OAeG;IACH,SAHW,MAAM,uBACG,MAAM,KAAG,WAAW,QAYvC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,0BAHoB,MAAM,KAAG,CAAC,WAAW,GAAC,SAAS,CAAC,QAcnD;IAGL;;;OAGG;IACH,+BAFU,OAAO,CAEgC;CANhD;0BA7MY,OAAO,8CAA8C,EAAE,WAAW;oCAIlE,OAAO,4BAA4B,EAAE,qBAAqB"}

package/src/shade/renderer/animation/ShadeAnimationClip.js

@@ -1,5 +1,9 @@
 import { assert } from "../../../core/assert.js";
 
+/**
+ * @typedef {import("../../../engine/ecs/transform/Transform64.js").Transform64} Transform64
+ */
+
 /**
  * @typedef {import("./ShadeAnimationChannel.js").ShadeAnimationChannel} ShadeAnimationChannel
  */
@@ -7,7 +11,7 @@ import { assert } from "../../../core/assert.js";
 /**
  * A bundle of {@link ShadeAnimationChannel}s sharing one playback
  * clock — the GPU-driven equivalent of an animation "clip". Each
- * channel targets a Node3D + property; together they describe a
+ * channel targets a node + property; together they describe a
  * coordinated motion (e.g. "wave" might rotate the shoulder, elbow,
  * and wrist joints in lockstep).
  *
@@ -109,7 +113,7 @@ export class ShadeAnimationClip {
      *
      * Retargeting after cloning is the caller's job: walk
      * `clone.channels` and replace each channel's `target` with the
-     * matching new Node3D. See the dancer prototype for the typical
+     * matching new target. See the dancer prototype for the typical
      * pattern (`Map<old_joint, new_joint>` plus a per-channel
      * lookup).
      *
@@ -140,8 +144,8 @@ export class ShadeAnimationClip {
     }
 
     /**
-     * Apply every channel's evaluated value at time `t` to its
-     * target Node3D's `transform_local`. Thin orchestrator over
+     * Apply every channel's evaluated value at time `t` to the
+     * transform `transform_of` answers for its target. Thin orchestrator over
      * {@link ShadeAnimationChannel#apply} — same mutation
      * semantics: callers preserving the bind pose must snapshot
      * before calling and restore after.
@@ -153,12 +157,17 @@ export class ShadeAnimationClip {
      * computation).
      *
      * @param {number} t
+     * @param {function(number): Transform64} transform_of the local transform of a target
      */
-    apply(t) {
+    apply(t, transform_of) {
+        assert.isFunction(transform_of, 'transform_of');
+
         const channels = this.channels;
         const count = channels.length;
         for (let i = 0; i < count; i++) {
-            channels[i].apply(t);
+            const channel = channels[i];
+
+            channel.apply(t, transform_of(channel.target));
         }
     }
 
@@ -181,13 +190,16 @@ export class ShadeAnimationClip {
      * `clip.channels.length` and the sum of `channel.curve_count`
      * across channels themselves; the method intentionally
      * doesn't return them — single source of truth.
+     *
+     * @param {function(number): (Transform64|undefined)} [rest_of] the rest transform of a
+     *        target — a bundle's node local; without it nothing is dropped
      */
-    optimize() {
+    optimize(rest_of) {
         const original = this.channels;
         const kept = [];
         for (let i = 0; i < original.length; i++) {
             const ch = original[i];
-            ch.optimize();
+            ch.optimize(rest_of === undefined ? undefined : rest_of(ch.target));
             if (ch.curve_count > 0) {
                 kept.push(ch);
             }

package/src/shade/renderer/animation/Skin.d.ts

@@ -1,6 +1,4 @@
 /**
- * @typedef {import("../scene/Node3D.js").Node3D} Node3D
- * @typedef {import("../scene/SkinnedMesh.js").SkinnedMesh} SkinnedMesh
  */
 /**
  * CPU-side description of a skin: the joint nodes that drive
@@ -32,17 +30,17 @@ export class Skin {
      *
      * @param {{
      *     name?: string,
-     *     joints: Node3D[],
+     *     joints: number[],
      *     inverse_bind_matrices: Float32Array,
-     *     meshes?: SkinnedMesh[],
+     *     meshes?: number[],
      * }} args
      * @returns {Skin}
      */
     static from({ name, joints, inverse_bind_matrices, meshes }: {
         name?: string;
-        joints: Node3D[];
+        joints: number[];
         inverse_bind_matrices: Float32Array;
-        meshes?: SkinnedMesh[];
+        meshes?: number[];
     }): Skin;
     /**
      * Human-readable name. Optional; empty by default.
@@ -51,20 +49,24 @@ export class Skin {
      */
     name: string;
     /**
-     * Ordered joint nodes. Position in this array matches the joint
+     * Ordered joints. Position in this array matches the joint
      * index used in per-vertex `joints` attributes (the `vec4<u16>`
      * mapped to {@link StandardAttributes.SkinningJoints}). Joint
      * indices in vertex data are interpreted against this list.
      *
-     * @type {Node3D[]}
+     * What a joint *is* depends on where the skin lives: an index into the bundle's nodes in a
+     * loader's bundle, a node index in a compiled prefab, an entity in a prefab instance — which
+     * is the form {@link GPUAnimationManager#register_skin} takes.
+     *
+     * @type {number[]}
      */
-    joints: Node3D[];
+    joints: number[];
     /**
      * Joint-count × 16 column-major matrices, flat. Joint `j`'s
      * inverse-bind matrix occupies elements `[j*16, j*16+16)`. The
      * matrix transforms a vertex from mesh space into the joint's
      * bind-pose local space; combined with the joint's current
-     * `node.global` at runtime, it produces the per-frame skinning
+     * world matrix at runtime, it produces the per-frame skinning
      * matrix the shader applies.
      *
      * Column-major to match the WGSL `mat4x4<f32>` convention the
@@ -75,15 +77,15 @@ export class Skin {
      */
     inverse_bind_matrices: Float32Array;
     /**
-     * Meshes that deform against this skin. Populated by the loader
-     * (or by hand if you're constructing a skin programmatically).
-     * Used by {@link GPUAnimationManager#register_skin} to register
-     * each mesh's skinning binding and point it back at this skin —
-     * register_skin does not walk the scene graph looking for users.
+     * Meshes that deform against this skin, in the same form as {@link joints}: node indices in
+     * a bundle or a prefab, entities in an instance. Populated by the loader (or by
+     * hand if you're constructing a skin programmatically). Used by
+     * {@link GPUAnimationManager#register_skin} to register each mesh entity's skinning binding —
+     * register_skin does not walk anything looking for users.
      *
-     * @type {SkinnedMesh[]}
+     * @type {number[]}
      */
-    meshes: SkinnedMesh[];
+    meshes: number[];
     /**
      * Copy `other`'s shape into `this`. Joint and mesh arrays are
      * shallow-copied; `inverse_bind_matrices` is shared (it's
@@ -111,6 +113,4 @@ export class Skin {
      */
     readonly isSkin: boolean;
 }
-export type Node3D = import("../scene/Node3D.js").Node3D;
-export type SkinnedMesh = import("../scene/SkinnedMesh.js").SkinnedMesh;
 //# sourceMappingURL=Skin.d.ts.map

package/src/shade/renderer/animation/Skin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Skin.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/Skin.js"],"names":[],"mappings":"AAEA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IA8CI;;;;;;;;;;;OAWG;IACH,6DARW;QACV,IAAU,CAAC,EAAE,MAAM,CAAC;QACpB,MAAY,EAAE,MAAM,EAAE,CAAC;QACvB,qBAA2B,EAAE,YAAY,CAAC;QAC1C,MAAY,CAAC,EAAE,WAAW,EAAE,CAAC;KAC1B,GACS,IAAI,CAiBhB;IAvED;;;;OAIG;IACH,MAFU,MAAM,CAEN;IAEV;;;;;;;OAOG;IACH,QAFU,MAAM,EAAE,CAEN;IAEZ;;;;;;;;;;;;;OAaG;IACH,uBAFU,YAAY,CAEsB;IAE5C;;;;;;;;OAQG;IACH,QAFU,WAAW,EAAE,CAEX;IA+BZ;;;;;;;;;;OAUG;IACH,YAFW,IAAI,QASd;IAED;;;;;;;OAOG;IACH,SAFa,IAAI,CAMhB;IAGL;;;OAGG;IACH,iBAFU,OAAO,CAEI;CANpB;qBAvIY,OAAO,oBAAoB,EAAE,MAAM;0BACnC,OAAO,yBAAyB,EAAE,WAAW"}
+{"version":3,"file":"Skin.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/Skin.js"],"names":[],"mappings":"AAEA;GACG;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAkDI;;;;;;;;;;;OAWG;IACH,6DARW;QACV,IAAU,CAAC,EAAE,MAAM,CAAC;QACpB,MAAY,EAAE,MAAM,EAAE,CAAC;QACvB,qBAA2B,EAAE,YAAY,CAAC;QAC1C,MAAY,CAAC,EAAE,MAAM,EAAE,CAAC;KACrB,GACS,IAAI,CAiBhB;IA3ED;;;;OAIG;IACH,MAFU,MAAM,CAEN;IAEV;;;;;;;;;;;OAWG;IACH,QAFU,MAAM,EAAE,CAEN;IAEZ;;;;;;;;;;;;;OAaG;IACH,uBAFU,YAAY,CAEsB;IAE5C;;;;;;;;OAQG;IACH,QAFU,MAAM,EAAE,CAEN;IA+BZ;;;;;;;;;;OAUG;IACH,YAFW,IAAI,QASd;IAED;;;;;;;OAOG;IACH,SAFa,IAAI,CAMhB;IAGL;;;OAGG;IACH,iBAFU,OAAO,CAEI;CANpB"}

package/src/shade/renderer/animation/Skin.js

@@ -1,8 +1,6 @@
 import { assert } from "../../../core/assert.js";
 
 /**
- * @typedef {import("../scene/Node3D.js").Node3D} Node3D
- * @typedef {import("../scene/SkinnedMesh.js").SkinnedMesh} SkinnedMesh
  */
 
 /**
@@ -38,12 +36,16 @@ export class Skin {
     name = "";
 
     /**
-     * Ordered joint nodes. Position in this array matches the joint
+     * Ordered joints. Position in this array matches the joint
      * index used in per-vertex `joints` attributes (the `vec4<u16>`
      * mapped to {@link StandardAttributes.SkinningJoints}). Joint
      * indices in vertex data are interpreted against this list.
      *
-     * @type {Node3D[]}
+     * What a joint *is* depends on where the skin lives: an index into the bundle's nodes in a
+     * loader's bundle, a node index in a compiled prefab, an entity in a prefab instance — which
+     * is the form {@link GPUAnimationManager#register_skin} takes.
+     *
+     * @type {number[]}
      */
     joints = [];
 
@@ -52,7 +54,7 @@ export class Skin {
      * inverse-bind matrix occupies elements `[j*16, j*16+16)`. The
      * matrix transforms a vertex from mesh space into the joint's
      * bind-pose local space; combined with the joint's current
-     * `node.global` at runtime, it produces the per-frame skinning
+     * world matrix at runtime, it produces the per-frame skinning
      * matrix the shader applies.
      *
      * Column-major to match the WGSL `mat4x4<f32>` convention the
@@ -64,13 +66,13 @@ export class Skin {
     inverse_bind_matrices = new Float32Array(0);
 
     /**
-     * Meshes that deform against this skin. Populated by the loader
-     * (or by hand if you're constructing a skin programmatically).
-     * Used by {@link GPUAnimationManager#register_skin} to register
-     * each mesh's skinning binding and point it back at this skin —
-     * register_skin does not walk the scene graph looking for users.
+     * Meshes that deform against this skin, in the same form as {@link joints}: node indices in
+     * a bundle or a prefab, entities in an instance. Populated by the loader (or by
+     * hand if you're constructing a skin programmatically). Used by
+     * {@link GPUAnimationManager#register_skin} to register each mesh entity's skinning binding —
+     * register_skin does not walk anything looking for users.
      *
-     * @type {SkinnedMesh[]}
+     * @type {number[]}
      */
     meshes = [];
 
@@ -80,9 +82,9 @@ export class Skin {
      *
      * @param {{
      *     name?: string,
-     *     joints: Node3D[],
+     *     joints: number[],
      *     inverse_bind_matrices: Float32Array,
-     *     meshes?: SkinnedMesh[],
+     *     meshes?: number[],
      * }} args
      * @returns {Skin}
      */

package/src/shade/renderer/animation/pose/pose_evaluate_local.d.ts

@@ -17,14 +17,15 @@
  * the thing to fix. `pose_evaluator_lockstep.spec.js` fails when the WGSL moves, so that the pair
  * cannot drift silently.
  *
- * The node's own `transform_local` supplies the rest pose. That is sound because the CPU never
- * writes a GPU-authoritative row (`TransformAuthority`), so what the node holds is what was
- * authored, and undirty axes on the GPU hold the same value for the same reason.
+ * `rest` supplies the rest pose: the node's or the entity's authored local offset. That is sound
+ * because the CPU never writes a GPU-authoritative row, so what the authored offset holds is what
+ * the row started from, and undirty axes on the GPU hold the same value for the same reason.
  *
  * @param {Transform64} result written with the evaluated local TRS; its matrix is left stale
- * @param {Node3D} node
+ * @param {Node3D|number} target what the channels name — a node, or an entity
+ * @param {Transform64} rest the target's authored local pose
  * @param {PosePlayback[]} playbacks
  * @returns {Transform64} `result`
  */
-export function pose_evaluate_local(result: Transform64, node: Node3D, playbacks: PosePlayback[]): Transform64;
+export function pose_evaluate_local(result: Transform64, target: Node3D | number, rest: Transform64, playbacks: PosePlayback[]): Transform64;
 //# sourceMappingURL=pose_evaluate_local.d.ts.map

package/src/shade/renderer/animation/pose/pose_evaluate_local.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pose_evaluate_local.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/pose/pose_evaluate_local.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,kFAHW,cAAc,eAsIxB"}
+{"version":3,"file":"pose_evaluate_local.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/pose/pose_evaluate_local.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,iEALW,SAAO,MAAM,gCAEb,cAAc,eAqIxB"}