@woosh/meep-engine 3.43.0 → 3.45.0

package/src/engine/graphics/geometry/geometry_construct_triangle_normal_area_weighted.d.ts

@@ -17,6 +17,8 @@
  * to synthesise some arbitrary unit vector and hand it over as though it were a
  * measurement.
  *
+ * An indexed form of {@link tri3_compute_normal_area_weighted_array}, which holds the arithmetic.
+ *
  * Single-face callers — a raycast normal, a plane side test — want
  * {@link geometry_construct_triangle_normal} instead.
  *

package/src/engine/graphics/geometry/geometry_construct_triangle_normal_area_weighted.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometry_construct_triangle_normal_area_weighted.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/geometry/geometry_construct_triangle_normal_area_weighted.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,sEARW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,aACN,MAAM,EAAE,GAAC,YAAY,GACnB,IAAI,CAwBhB"}
+{"version":3,"file":"geometry_construct_triangle_normal_area_weighted.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/geometry/geometry_construct_triangle_normal_area_weighted.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,sEARW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,aACN,MAAM,EAAE,GAAC,YAAY,GACnB,IAAI,CAShB"}

package/src/engine/graphics/geometry/geometry_construct_triangle_normal_area_weighted.js

@@ -1,3 +1,5 @@
+import { tri3_compute_normal_area_weighted_array } from "../../../core/geom/3d/triangle/tri3_compute_normal_area_weighted_array.js";
+
 /**
  * The face normal of an indexed triangle, NOT normalised — the raw
  * `(c - b) × (a - b)`, whose magnitude is twice the triangle's area.
@@ -17,6 +19,8 @@
  * to synthesise some arbitrary unit vector and hand it over as though it were a
  * measurement.
  *
+ * An indexed form of {@link tri3_compute_normal_area_weighted_array}, which holds the arithmetic.
+ *
  * Single-face callers — a raycast normal, a plane side test — want
  * {@link geometry_construct_triangle_normal} instead.
  *
@@ -29,25 +33,10 @@
  * @returns {void}
  */
 export function geometry_construct_triangle_normal_area_weighted(out, out_offset, a, b, c, positions) {
-
-    const a_address = a * 3;
-    const b_address = b * 3;
-    const c_address = c * 3;
-
-    const bx = positions[b_address];
-    const by = positions[b_address + 1];
-    const bz = positions[b_address + 2];
-
-    const cb_x = positions[c_address] - bx;
-    const cb_y = positions[c_address + 1] - by;
-    const cb_z = positions[c_address + 2] - bz;
-
-    const ab_x = positions[a_address] - bx;
-    const ab_y = positions[a_address + 1] - by;
-    const ab_z = positions[a_address + 2] - bz;
-
-    // the same winding `tri3_compute_normal` uses, so the direction agrees
-    out[out_offset] = cb_y * ab_z - cb_z * ab_y;
-    out[out_offset + 1] = cb_z * ab_x - cb_x * ab_z;
-    out[out_offset + 2] = cb_x * ab_y - cb_y * ab_x;
+    tri3_compute_normal_area_weighted_array(
+        out, out_offset,
+        positions, a * 3,
+        positions, b * 3,
+        positions, c * 3
+    );
 }

package/src/engine/graphics3/AnimationGraphSystem.d.ts

@@ -2,6 +2,14 @@
  * Drives every entity's {@link AnimationGraphController}: runs its clock, and tells the renderer
  * what its clips weigh and where they are playing.
  *
+ * **The clips are the entity's {@link AnimationClips}.** An entity is driven while it carries both
+ * components, whoever put them there — a model `MeshSystem` loaded, or a rig built in code. New
+ * clips are a new component, which this system sees as the entity leaving and coming back.
+ *
+ * **Every node the clips key holds a row here** ({@link hold_clip_targets}), from the graph being
+ * bound to the clips until they go. A clip binds only once all of them do, and a keyed node outside
+ * every skin with nothing drawn under it — a socket, say — is held by no other system.
+ *
  * **It is the CPU that plays the animation and the GPU that draws it.** Shade can advance a clip
  * itself, and this never asks it to — `AnimationClipFlags.Playing` is left clear and every audible
  * clip's time is written down each frame from the controller's own clock. That is I-4: the pose
@@ -10,33 +18,38 @@
  *
  * **Nothing here is culled.** The legacy system skipped entities smaller than 32 px², which let
  * camera framing decide whether a footstep effect or an ability release ever happened. The clock and
- * its notifications are gameplay and run for every entity whose model has arrived; what may be
+ * its notifications are gameplay and run for every entity whose clips have arrived; what may be
  * culled is drawing, and drawing is Shade's to cull.
  */
 export class AnimationGraphSystem extends System<any> {
     /**
      * @param {GraphicsEngine} graphics
-     * @param {MeshSystem} meshes
+     * @param {Scene} scene
      */
-    constructor(graphics: GraphicsEngine, meshes: MeshSystem);
-    dependencies: (typeof SGMesh | typeof AnimationGraphController)[];
+    constructor(graphics: GraphicsEngine, scene: Scene);
+    dependencies: (typeof AnimationGraphController | typeof AnimationClips)[];
     components_used: ResourceAccessSpecification<typeof AnimationGraphController>[];
     /**
+     * Only noted here: the graph is bound to the clips by the next {@link update}. A link can happen
+     * anywhere the components are added — inside a model's spawn, for one `MeshSystem` loads — and a
+     * graph naming a clip the entity has not got throws, which belongs in this system's tick and not
+     * in whoever added the component.
+     *
      * @param {AnimationGraphController} controller
-     * @param {SGMesh} model
+     * @param {AnimationClips} clips
      * @param {number} entity
      */
-    link(controller: AnimationGraphController, model: SGMesh, entity: number): void;
+    link(controller: AnimationGraphController, clips: AnimationClips, entity: number): void;
     /**
-     * What the entity's model is playing, in the form the CPU pose evaluator takes: one entry per
-     * clip **this graph names**, at the weight and the time the renderer has been given.
+     * What the entity is playing, in the form the CPU pose evaluator takes: one entry per clip
+     * **this graph names**, at the weight and the time the renderer has been given.
      *
      * **The clips the graph does not name are not here, because they are not registered** (D37).
      * The GPU's accumulator marks a joint dirty for every bound clip that writes to it, weight and
      * all — so a bound clip at weight zero resolves the joints only it drives to zero rather than
      * leaving them at rest. The answer is not to hand those clips to the evaluator so it can make
      * the same mistake; it is not to bind them. What the graph never names, nothing plays, and the
-     * joints it alone would have driven stay where the model rests.
+     * joints it alone would have driven stay where they rest.
      *
      * A clip the graph names but is not currently playing **is** here, at weight zero, because it is
      * bound and the accumulator does see it.
@@ -47,21 +60,23 @@ export class AnimationGraphSystem extends System<any> {
      * @param {PosePlayback[]} target appended to
      * @param {number} entity
      * @returns {boolean} whether this system is driving the entity — `false` for one with no
-     * {@link AnimationGraphController}, and for one whose model has not arrived
+     * {@link AnimationGraphController} or no {@link AnimationClips}, and for one whose clips arrived
+     * since the last update
      */
     write_pose_playbacks(target: PosePlayback[], entity: number): boolean;
     /**
      * @param {AnimationGraphController} controller
-     * @param {SGMesh} model
+     * @param {AnimationClips} clips
      * @param {number} entity
      */
-    unlink(controller: AnimationGraphController, model: SGMesh, entity: number): void;
+    unlink(controller: AnimationGraphController, clips: AnimationClips, entity: number): void;
+    startup(entityManager: any): Promise<void>;
     shutdown(entityManager: any): Promise<void>;
     #private;
 }
 import { System } from "../ecs/System.js";
-import { SGMesh } from "../graphics/ecs/mesh-v2/aggregate/SGMesh.js";
 import { AnimationGraphController } from "./animation/AnimationGraphController.js";
+import { AnimationClips } from "./animation/AnimationClips.js";
 import { ResourceAccessSpecification } from "../../core/model/ResourceAccessSpecification.js";
 import { PosePlayback } from "../../shade/renderer/animation/pose/PosePlayback.js";
 //# sourceMappingURL=AnimationGraphSystem.d.ts.map

package/src/engine/graphics3/AnimationGraphSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AnimationGraphSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/AnimationGraphSystem.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;GAcG;AACH;IAmBI;;;OAGG;IACH,0DAgBC;IAPG,kEAAsD;IAItD,gFAEC;IAGL;;;;OAIG;IACH,iBAJW,wBAAwB,SACxB,MAAM,UACN,MAAM,QAahB;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,6BALW,YAAY,EAAE,UACd,MAAM,GACJ,OAAO,CA+CnB;IAED;;;;OAIG;IACH,mBAJW,wBAAwB,SACxB,MAAM,UACN,MAAM,QAYhB;IAED,4CAQC;;CA4JJ;uBA5UsB,kBAAkB;uBAClB,6CAA6C;yCAC3B,yCAAyC;4CAJtC,iDAAiD;6BAChE,qDAAqD"}
+{"version":3,"file":"AnimationGraphSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/AnimationGraphSystem.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAyBI;;;OAGG;IACH,oDAgBC;IAPG,0EAA8D;IAI9D,gFAEC;IAGL;;;;;;;;;OASG;IACH,iBAJW,wBAAwB,SACxB,cAAc,UACd,MAAM,QAehB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,6BANW,YAAY,EAAE,UACd,MAAM,GACJ,OAAO,CAgDnB;IAED;;;;OAIG;IACH,mBAJW,wBAAwB,SACxB,cAAc,UACd,MAAM,QAkBhB;IAED,2CAaC;IAED,4CAWC;;CA2JJ;uBAvXsB,kBAAkB;yCAEA,yCAAyC;+BADnD,+BAA+B;4CAHlB,iDAAiD;6BAChE,qDAAqD"}

package/src/engine/graphics3/AnimationGraphSystem.js

@@ -3,18 +3,24 @@ import { ResourceAccessKind } from "../../core/model/ResourceAccessKind.js";
 import { ResourceAccessSpecification } from "../../core/model/ResourceAccessSpecification.js";
 import { PosePlayback } from "../../shade/renderer/animation/pose/PosePlayback.js";
 import { System } from "../ecs/System.js";
-import { SGMesh } from "../graphics/ecs/mesh-v2/aggregate/SGMesh.js";
+import { AnimationClips } from "./animation/AnimationClips.js";
 import { AnimationGraphController } from "./animation/AnimationGraphController.js";
 import { write_graph_playback } from "./animation/write_graph_playback.js";
-import {
-    register_instance_clips,
-    unregister_instance_clips
-} from "./register_instance_animation.js";
+import { hold_clip_targets, register_clips, release_clip_targets, unregister_clips } from "./register_clips.js";
+import { RowChains } from "./RowChains.js";
 
 /**
  * Drives every entity's {@link AnimationGraphController}: runs its clock, and tells the renderer
  * what its clips weigh and where they are playing.
  *
+ * **The clips are the entity's {@link AnimationClips}.** An entity is driven while it carries both
+ * components, whoever put them there — a model `MeshSystem` loaded, or a rig built in code. New
+ * clips are a new component, which this system sees as the entity leaving and coming back.
+ *
+ * **Every node the clips key holds a row here** ({@link hold_clip_targets}), from the graph being
+ * bound to the clips until they go. A clip binds only once all of them do, and a keyed node outside
+ * every skin with nothing drawn under it — a socket, say — is held by no other system.
+ *
  * **It is the CPU that plays the animation and the GPU that draws it.** Shade can advance a clip
  * itself, and this never asks it to — `AnimationClipFlags.Playing` is left clear and every audible
  * clip's time is written down each frame from the controller's own clock. That is I-4: the pose
@@ -23,7 +29,7 @@ import {
  *
  * **Nothing here is culled.** The legacy system skipped entities smaller than 32 px², which let
  * camera framing decide whether a footstep effect or an ability release ever happened. The clock and
- * its notifications are gameplay and run for every entity whose model has arrived; what may be
+ * its notifications are gameplay and run for every entity whose clips have arrived; what may be
  * culled is drawing, and drawing is Shade's to cull.
  */
 export class AnimationGraphSystem extends System {
@@ -33,32 +39,38 @@ export class AnimationGraphSystem extends System {
     #graphics;
 
     /**
-     * The system that owns the scene, the model instances, and the ids the animation manager issued
-     * for them.
+     * The scene whose GPU context issues the clip ids.
      *
-     * @type {MeshSystem}
+     * @type {Scene}
      */
-    #meshes;
+    #scene;
 
     /**
-     * @type {Map<number, {controller: AnimationGraphController, instance: PrefabInstance|null, clip_registration: InstanceClipRegistration|null, slots: Int32Array, played_slots: Int32Array, clip_ids: Int32Array, weights: Float32Array, poses: PosePlayback[]}>}
+     * @type {Map<number, {controller: AnimationGraphController, clips: ShadeAnimationClip[], bound: boolean, held: boolean, clip_registration: ClipRegistration|null, slots: Int32Array, played_slots: Int32Array, clip_ids: Int32Array, weights: Float32Array, poses: PosePlayback[]}>}
      */
     #entries = new Map();
 
+    /**
+     * The chains of the nodes the clips key. Null until the system has a dataset.
+     *
+     * @type {RowChains|null}
+     */
+    #chains = null;
+
     /**
      * @param {GraphicsEngine} graphics
-     * @param {MeshSystem} meshes
+     * @param {Scene} scene
      */
-    constructor(graphics, meshes) {
+    constructor(graphics, scene) {
         super();
 
         assert.defined(graphics, 'graphics');
-        assert.defined(meshes, 'meshes');
+        assert.equal(scene?.isScene, true, 'scene.isScene !== true');
 
         this.#graphics = graphics;
-        this.#meshes = meshes;
+        this.#scene = scene;
 
-        this.dependencies = [AnimationGraphController, SGMesh];
+        this.dependencies = [AnimationGraphController, AnimationClips];
 
         // this tick's clip times are this system's to set: whatever evaluates a pose from them
         // (exact queries, IK's base pose) reads AnimationGraphController and so runs after it
@@ -68,14 +80,21 @@ export class AnimationGraphSystem extends System {
     }
 
     /**
+     * Only noted here: the graph is bound to the clips by the next {@link update}. A link can happen
+     * anywhere the components are added — inside a model's spawn, for one `MeshSystem` loads — and a
+     * graph naming a clip the entity has not got throws, which belongs in this system's tick and not
+     * in whoever added the component.
+     *
      * @param {AnimationGraphController} controller
-     * @param {SGMesh} model
+     * @param {AnimationClips} clips
      * @param {number} entity
      */
-    link(controller, model, entity) {
+    link(controller, clips, entity) {
         this.#entries.set(entity, {
             controller,
-            instance: null,
+            clips: clips.clips,
+            bound: false,
+            held: false,
             clip_registration: null,
             slots: new Int32Array(0),
             played_slots: new Int32Array(0),
@@ -86,15 +105,15 @@ export class AnimationGraphSystem extends System {
     }
 
     /**
-     * What the entity's model is playing, in the form the CPU pose evaluator takes: one entry per
-     * clip **this graph names**, at the weight and the time the renderer has been given.
+     * What the entity is playing, in the form the CPU pose evaluator takes: one entry per clip
+     * **this graph names**, at the weight and the time the renderer has been given.
      *
      * **The clips the graph does not name are not here, because they are not registered** (D37).
      * The GPU's accumulator marks a joint dirty for every bound clip that writes to it, weight and
      * all — so a bound clip at weight zero resolves the joints only it drives to zero rather than
      * leaving them at rest. The answer is not to hand those clips to the evaluator so it can make
      * the same mistake; it is not to bind them. What the graph never names, nothing plays, and the
-     * joints it alone would have driven stay where the model rests.
+     * joints it alone would have driven stay where they rest.
      *
      * A clip the graph names but is not currently playing **is** here, at weight zero, because it is
      * bound and the accumulator does see it.
@@ -105,16 +124,17 @@ export class AnimationGraphSystem extends System {
      * @param {PosePlayback[]} target appended to
      * @param {number} entity
      * @returns {boolean} whether this system is driving the entity — `false` for one with no
-     * {@link AnimationGraphController}, and for one whose model has not arrived
+     * {@link AnimationGraphController} or no {@link AnimationClips}, and for one whose clips arrived
+     * since the last update
      */
     write_pose_playbacks(target, entity) {
         const entry = this.#entries.get(entity);
 
-        if (entry === undefined || entry.instance === null) {
+        if (entry === undefined || !entry.bound) {
             return false;
         }
 
-        const clips = entry.instance.clips;
+        const clips = entry.clips;
         const poses = entry.poses;
         const played = entry.played_slots;
 
@@ -136,7 +156,7 @@ export class AnimationGraphSystem extends System {
             const weight = weights[i];
 
             // assignment rather than accumulation, and it matters only where two of the graph's
-            // clips are one clip of the model: the renderer is written to in this order too, so the
+            // clips are one clip of the entity: the renderer is written to in this order too, so the
             // last of them is what it holds
             pose.weight = weight;
 
@@ -155,21 +175,42 @@ export class AnimationGraphSystem extends System {
 
     /**
      * @param {AnimationGraphController} controller
-     * @param {SGMesh} model
+     * @param {AnimationClips} clips
      * @param {number} entity
      */
-    unlink(controller, model, entity) {
+    unlink(controller, clips, entity) {
         controller.unlink();
 
         const entry = this.#entries.get(entity);
 
         if (entry !== undefined) {
             this.#release_clips(entry);
+
+            if (entry.held) {
+                release_clip_targets(this.#chains, entry.clips);
+
+                entry.held = false;
+            }
         }
 
         this.#entries.delete(entity);
     }
 
+    async startup(entityManager) {
+        // the scene's rows are this dataset's entities; the first system to place one says so
+        const dataset = entityManager.dataset;
+        const scene = this.#scene;
+
+        assert.ok(
+            scene.dataset === null || scene.dataset === undefined || scene.dataset === dataset,
+            'the scene is bound to another dataset'
+        );
+
+        scene.dataset = dataset;
+
+        this.#chains = new RowChains(dataset);
+    }
+
     async shutdown(entityManager) {
         for (const entry of this.#entries.values()) {
             entry.controller.unlink();
@@ -178,6 +219,9 @@ export class AnimationGraphSystem extends System {
         }
 
         this.#entries.clear();
+
+        this.#chains.destroy();
+        this.#chains = null;
     }
 
     /**
@@ -186,7 +230,7 @@ export class AnimationGraphSystem extends System {
      * **An id may only be handed back to the manager that issued it.** A renderer restart replaces
      * the GPU scene context and voids every id it gave out, so a registration stamped with a context
      * that is no longer current is forgotten rather than returned — returning it would corrupt a
-     * stranger's table. Same rule as {@link unregister_instance_animation}, same `===`.
+     * stranger's table. Same rule as {@link unregister_clips}, same `===`.
      *
      * @param {object} entry
      */
@@ -197,8 +241,8 @@ export class AnimationGraphSystem extends System {
             return;
         }
 
-        if (registration.context === this.#graphics.scene_context(this.#meshes.scene)) {
-            unregister_instance_clips(registration);
+        if (registration.context === this.#graphics.scene_context(this.#scene)) {
+            unregister_clips(registration);
         }
 
         entry.clip_registration = null;
@@ -210,22 +254,18 @@ export class AnimationGraphSystem extends System {
     update(time_delta_seconds) {
         const ecd = this.entityManager.dataset;
 
-        const context = this.#graphics.scene_context(this.#meshes.scene);
+        const context = this.#graphics.scene_context(this.#scene);
 
         // No device — before the first start, and again after a stop. The clocks still run: a unit
         // that fires an ability while the renderer is being replaced still fires it.
         const manager = context === null ? null : context.animation_manager;
 
-        for (const [entity, entry] of this.#entries) {
-            const instance = this.#meshes.instance_of(entity);
-
-            if (instance === null) {
-                // the model has not arrived, and its clips are what say how long they run
-                continue;
-            }
+        // a new context after a restart is acquired in whole; until there is one, holds are recorded
+        this.#chains.bind(context === null ? null : context.rows);
 
-            if (instance !== entry.instance) {
-                this.#bind_model(entry, entity, instance, ecd);
+        for (const [entity, entry] of this.#entries) {
+            if (!entry.bound) {
+                this.#bind_clips(entry, entity, ecd);
             }
 
             entry.controller.tick(time_delta_seconds);
@@ -240,7 +280,7 @@ export class AnimationGraphSystem extends System {
              noticed — in one comparison, without depending on when anything last ran.
             */
             if (entry.clip_registration === null || entry.clip_registration.context !== context) {
-                this.#bind_gpu(entry, instance, context);
+                this.#bind_gpu(entry, context);
             }
 
             write_graph_playback(manager, entry.controller, entry.clip_ids, entry.weights);
@@ -248,15 +288,16 @@ export class AnimationGraphSystem extends System {
     }
 
     /**
-     * Bind the graph to a model: work out which of the model's clips each of the graph's clips is,
-     * how long each of them runs, and start the graph on that.
+     * Bind the graph to the entity's clips: work out which of them each of the graph's clips is, how
+     * long each of them runs, and start the graph on that.
      *
      * @param {object} entry
      * @param {number} entity
-     * @param {PrefabInstance} instance
      * @param {EntityComponentDataset} ecd
      */
-    #bind_model(entry, entity, instance, ecd) {
+    #bind_clips(entry, entity, ecd) {
+        const clips = entry.clips;
+
         const clip_index = entry.controller.def.clipIndex;
         const clip_count = clip_index.length;
 
@@ -266,26 +307,25 @@ export class AnimationGraphSystem extends System {
         for (let i = 0; i < clip_count; i++) {
             const name = clip_index[i].name;
 
-            const slot = instance.clips.findIndex(clip => clip.name === name);
+            const slot = clips.findIndex(clip => clip.name === name);
 
             if (slot === -1) {
-                throw new Error(`Animation clip '${name}' is not in the model`);
+                throw new Error(`Animation clip '${name}' is not among the clips of entity ${entity}`);
             }
 
             slots[i] = slot;
-            durations[i] = instance.clips[slot].duration;
+            durations[i] = clips[slot].duration;
         }
 
         entry.controller.unlink();
         entry.controller.link(entity, ecd, durations);
 
-        entry.instance = instance;
         entry.slots = slots;
 
         /*
-         The distinct clips of the model this graph plays. Two states can name one clip — an idle a
-         hurt returns to, say — and it is one row on the GPU either way, so it is one entry here:
-         registered once, reported to the pose evaluator once.
+         The distinct clips this graph plays. Two states can name one clip — an idle a hurt returns
+         to, say — and it is one row on the GPU either way, so it is one entry here: registered once,
+         reported to the pose evaluator once.
         */
         const played = [];
 
@@ -299,28 +339,31 @@ export class AnimationGraphSystem extends System {
 
         entry.clip_ids = new Int32Array(clip_count);
         entry.weights = new Float32Array(clip_count).fill(-1);
-        entry.poses = instance.clips.map(() => new PosePlayback());
+        entry.poses = clips.map(() => new PosePlayback());
+
+        entry.bound = true;
+
+        // past the throw above, so a graph that cannot be bound holds nothing; and before anything
+        // registers, so the clips bind in the update that registers them
+        hold_clip_targets(this.#chains, clips);
 
-        // ids the manager issued for the model that was here before name clips this one does not
-        // have
-        this.#release_clips(entry);
+        entry.held = true;
     }
 
     /**
      * Make this graph's clips playable, and take up the ids that come back.
      *
      * **Only the clips the graph names are registered** (D37), so there is nothing to silence: a
-     * clip of the model no state plays is never bound, never marks a joint, and leaves the joints
-     * only it would have driven at rest. What this used to do instead — register everything and then
-     * write a zero weight over the surplus — kept them bound, and a bound clip at weight zero
-     * resolves its joints to zero rather than to the model's own pose.
+     * clip no state plays is never bound, never marks a joint, and leaves the joints only it would
+     * have driven at rest. What this used to do instead — register everything and then write a zero
+     * weight over the surplus — kept them bound, and a bound clip at weight zero resolves its joints
+     * to zero rather than to the rig's own pose.
      *
      * @param {object} entry
-     * @param {PrefabInstance} instance
      * @param {GPUSceneContext} context
      */
-    #bind_gpu(entry, instance, context) {
-        const registration = register_instance_clips(context, instance, entry.played_slots);
+    #bind_gpu(entry, context) {
+        const registration = register_clips(context, entry.clips, entry.played_slots);
 
         const slots = entry.slots;
         const clip_ids = entry.clip_ids;

package/src/engine/graphics3/AnimationSystem.d.ts

@@ -4,9 +4,17 @@
  *
  * The list path is what the game uses wherever there is no state machine — buildings, critters and
  * the strategy map's groups — and {@link ClipListPlayer} is what plays it. This is the ECS half:
- * which entity has which model, and when the ids the renderer issued for it stopped meaning
+ * which clips each entity has, and when the ids the renderer issued for them stopped meaning
  * anything.
  *
+ * **The clips are the entity's {@link AnimationClips}.** An entity is driven while it carries both
+ * components, whoever put them there — a model `MeshSystem` loaded, or a rig built in code. New
+ * clips are a new component, which this system sees as the entity leaving and coming back.
+ *
+ * **Every node the clips key holds a row here** ({@link hold_clip_targets}), from the clips being
+ * taken up until they go. A clip binds only once all of them do, and a keyed node outside every skin
+ * with nothing drawn under it is held by no other system.
+ *
  * **It is the CPU that plays the animation and the GPU that draws it.** Shade can advance a clip
  * itself, and this never asks it to — `AnimationClipFlags.Playing` is left clear and every audible
  * clip's time is written down each frame from the player's own clock. That is I-4: the pose
@@ -20,31 +28,31 @@
 export class AnimationSystem extends System<any> {
     /**
      * @param {GraphicsEngine} graphics
-     * @param {MeshSystem} meshes
+     * @param {Scene} scene
      */
-    constructor(graphics: GraphicsEngine, meshes: MeshSystem);
-    dependencies: (typeof SGMesh | typeof Animation)[];
+    constructor(graphics: GraphicsEngine, scene: Scene);
+    dependencies: (typeof Animation | typeof AnimationClips)[];
     components_used: ResourceAccessSpecification<typeof Animation>[];
     /**
      * What an entity is playing, and where each of them is.
      *
      * One entry per clip in the component's list, in the list's own order. Empty for an entity this
-     * system is not driving — one that has left, or one whose model has not arrived, which is the
-     * same wait the clip durations are on.
+     * system is not driving — one that has left, or one whose clips arrived since the last update.
      *
      * @param {number} entity
      * @returns {ClipPlayback[]}
      */
     playbacks_of(entity: number): ClipPlayback[];
     /**
-     * What the entity's model is playing, in the form the CPU pose evaluator takes: one entry per
-     * clip the model carries, at the weight and the time the renderer has been given.
+     * What the entity is playing, in the form the CPU pose evaluator takes: one entry per clip of its
+     * {@link AnimationClips} that the list names, at the weight and the time the renderer has been
+     * given.
      *
      * **Only the clips the list names are here, because they are the only ones registered** (D37).
      * The GPU's accumulator marks a joint dirty for every bound clip that writes to it, weight and
      * all — so a bound clip at weight zero resolves the joints only it drives to zero rather than
      * leaving them at rest. The answer is not to hand the surplus to the evaluator so it agrees with
-     * a mistake; it is not to bind them, and then a clip of the model nothing names moves nothing.
+     * a mistake; it is not to bind them, and then a clip nothing names moves nothing.
      *
      * The entries are this system's own and are rewritten by the next call, which is what keeps a
      * query on a per-frame path from allocating.
@@ -52,27 +60,33 @@ export class AnimationSystem extends System<any> {
      * @param {PosePlayback[]} target appended to
      * @param {number} entity
      * @returns {boolean} whether this system is driving the entity — `false` for one with no
-     * {@link Animation}, and for one whose model has not arrived
+     * {@link Animation} or no {@link AnimationClips}, and for one whose clips arrived since the last
+     * update
      */
     write_pose_playbacks(target: PosePlayback[], entity: number): boolean;
     /**
+     * Only noted here: the clips are taken up by the next {@link update}. A link can happen anywhere
+     * the components are added — inside a model's spawn, for one `MeshSystem` loads — and binding is
+     * this system's work, on its own tick.
+     *
      * @param {Animation} component
-     * @param {SGMesh} model
+     * @param {AnimationClips} clips
      * @param {number} entity
      */
-    link(component: Animation, model: SGMesh, entity: number): void;
+    link(component: Animation, clips: AnimationClips, entity: number): void;
     /**
      * @param {Animation} component
-     * @param {SGMesh} model
+     * @param {AnimationClips} clips
      * @param {number} entity
      */
-    unlink(component: Animation, model: SGMesh, entity: number): void;
+    unlink(component: Animation, clips: AnimationClips, entity: number): void;
+    startup(entityManager: any): Promise<void>;
     shutdown(entityManager: any): Promise<void>;
     #private;
 }
 import { System } from "../ecs/System.js";
-import { SGMesh } from "../graphics/ecs/mesh-v2/aggregate/SGMesh.js";
 import { Animation } from "../ecs/animation/Animation.js";
+import { AnimationClips } from "./animation/AnimationClips.js";
 import { ResourceAccessSpecification } from "../../core/model/ResourceAccessSpecification.js";
 import { PosePlayback } from "../../shade/renderer/animation/pose/PosePlayback.js";
 //# sourceMappingURL=AnimationSystem.d.ts.map

package/src/engine/graphics3/AnimationSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AnimationSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/AnimationSystem.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IAmBI;;;OAGG;IACH,0DAgBC;IAPG,mDAAuC;IAIvC,iEAEC;IAGL;;;;;;;;;OASG;IACH,qBAHW,MAAM,GACJ,cAAc,CAU1B;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,6BALW,YAAY,EAAE,UACd,MAAM,GACJ,OAAO,CAwCnB;IAED;;;;OAIG;IACH,gBAJW,SAAS,SACT,MAAM,UACN,MAAM,QAWhB;IAED;;;;OAIG;IACH,kBAJW,SAAS,SACT,MAAM,UACN,MAAM,QAUhB;IAED,4CAMC;;CAsKJ;uBAlWsB,kBAAkB;uBAClB,6CAA6C;0BAF1C,+BAA+B;4CAFb,iDAAiD;6BAChE,qDAAqD"}
+{"version":3,"file":"AnimationSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/AnimationSystem.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAyBI;;;OAGG;IACH,oDAgBC;IAPG,2DAA+C;IAI/C,iEAEC;IAGL;;;;;;;;OAQG;IACH,qBAHW,MAAM,GACJ,cAAc,CAU1B;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,6BANW,YAAY,EAAE,UACd,MAAM,GACJ,OAAO,CAyCnB;IAED;;;;;;;;OAQG;IACH,gBAJW,SAAS,SACT,cAAc,UACd,MAAM,QAahB;IAED;;;;OAIG;IACH,kBAJW,SAAS,SACT,cAAc,UACd,MAAM,QAgBhB;IAED,2CAaC;IAED,4CASC;;CA8KJ;uBArZsB,kBAAkB;0BADf,+BAA+B;+BAE1B,+BAA+B;4CAJlB,iDAAiD;6BAChE,qDAAqD"}