@woosh/meep-engine 3.43.0 → 3.45.0

package/src/engine/graphics3/pose/query_entity_node_world_pose.js

@@ -1,75 +1,80 @@
-import { assert } from "../../../core/assert.js";
-import { PosePlayback } from "../../../shade/renderer/animation/pose/PosePlayback.js";
-import { t64_evaluate_world } from "../../ecs/transform/t64_evaluate_world.js";
-import { MeshSystem } from "../MeshSystem.js";
-import { collect_entity_playbacks } from "./collect_entity_playbacks.js";
-
-/**
- * The clip set handed to the evaluator, rebuilt per call from the systems' own entries. Nothing in
- * here outlives the call — the query is on a per-frame path and allocates nothing.
- *
- * @type {PosePlayback[]}
- */
-const PLAYBACKS = [];
-
-/**
- * Where a named part of an entity's model is, in world space.
- *
- * This is the question gameplay asks of an animated model and the only sanctioned way to ask it:
- * where does this projectile leave from, where does that effect anchor, where does the floating UI
- * hang. **The answer is computed, never read back** — GPU readback is a frame late and asynchronous,
- * so an outcome that depended on it would depend on frame pacing, and determinism and replay would
- * go with it: no GPU readback on a gameplay-affecting path.
- *
- * The named node is an entity of the model's instance, and the pose is {@link t64_evaluate_world}
- * over its attachment chain and the clips the animation systems are driving: a pure function of
- * (hierarchy, clip set, time, weights), off the same clock the renderer is written from, which is
- * what keeps a socket on the mesh that is drawn — whether or not the GPU owns the joint's row.
- *
- * The result carries both its matrix and its components.
- *
- * @param {Transform64} result
- * @param {EntityManager} entity_manager
- * @param {number} entity
- * @param {string} node_name name the asset gave the node — a bone, a socket's bone, an effector
- * @returns {boolean} `false` when there is no such node to answer about: no mesh system is
- * registered, the model has not loaded yet, the entity has none, or the name is not in it. None of
- * the four is an error
- */
-export function query_entity_node_world_pose(result, entity_manager, entity, node_name) {
-    assert.defined(result, 'result');
-    assert.defined(entity_manager, 'entity_manager');
-    assert.isNonNegativeInteger(entity, 'entity');
-    assert.isString(node_name, 'node_name');
-
-    const meshes = entity_manager.getSystem(MeshSystem);
-
-    if (meshes === null) {
-        // nothing draws models here, so nothing holds one to answer about
-        return false;
-    }
-
-    const instance = meshes.instance_of(entity);
-
-    if (instance === null) {
-        return false;
-    }
-
-    const target = instance.entity_of(node_name);
-
-    if (target === -1) {
-        return false;
-    }
-
-    const playbacks = PLAYBACKS;
-
-    playbacks.length = 0;
-
-    collect_entity_playbacks(playbacks, entity_manager, entity);
-
-    t64_evaluate_world(result, entity_manager.dataset, target, playbacks);
-
-    playbacks.length = 0;
-
-    return true;
-}
+import { assert } from "../../../core/assert.js";
+import { PosePlayback } from "../../../shade/renderer/animation/pose/PosePlayback.js";
+import { t64_evaluate_world } from "../../ecs/transform/t64_evaluate_world.js";
+import { MeshSystem } from "../MeshSystem.js";
+import { collect_entity_playbacks } from "./collect_entity_playbacks.js";
+
+/**
+ * The clip set handed to the evaluator, rebuilt per call from the systems' own entries. Nothing in
+ * here outlives the call — the query is on a per-frame path and allocates nothing.
+ *
+ * @type {PosePlayback[]}
+ */
+const PLAYBACKS = [];
+
+/**
+ * Where a named part of an entity's model is, in world space.
+ *
+ * This is the question gameplay asks of an animated model and the only sanctioned way to ask it:
+ * where does this projectile leave from, where does that effect anchor, where does the floating UI
+ * hang. **The answer is computed, never read back** — GPU readback is a frame late and asynchronous,
+ * so an outcome that depended on it would depend on frame pacing, and determinism and replay would
+ * go with it: no GPU readback on a gameplay-affecting path.
+ *
+ * The named node is an entity of the model's instance, and the pose is {@link t64_evaluate_world}
+ * over its attachment chain and the clips the animation systems are driving: a pure function of
+ * (hierarchy, clip set, time, weights), off the same clock the renderer is written from, which is
+ * what keeps a socket on the mesh that is drawn — whether or not the GPU owns the joint's row.
+ *
+ * **A name is only how a loaded model is asked.** For a joint the caller already holds — one of a
+ * rig built in code — there is nothing to look up: {@link collect_entity_playbacks} for the entity
+ * playing its clips, then {@link t64_evaluate_world} for the joint, which is all this does once the
+ * name is resolved.
+ *
+ * The result carries both its matrix and its components.
+ *
+ * @param {Transform64} result
+ * @param {EntityManager} entity_manager
+ * @param {number} entity
+ * @param {string} node_name name the asset gave the node — a bone, a socket's bone, an effector
+ * @returns {boolean} `false` when there is no such node to answer about: no mesh system is
+ * registered, the model has not loaded yet, the entity has none, or the name is not in it. None of
+ * the four is an error
+ */
+export function query_entity_node_world_pose(result, entity_manager, entity, node_name) {
+    assert.defined(result, 'result');
+    assert.defined(entity_manager, 'entity_manager');
+    assert.isNonNegativeInteger(entity, 'entity');
+    assert.isString(node_name, 'node_name');
+
+    const meshes = entity_manager.getSystem(MeshSystem);
+
+    if (meshes === null) {
+        // nothing draws models here, so nothing holds one to answer about
+        return false;
+    }
+
+    const instance = meshes.instance_of(entity);
+
+    if (instance === null) {
+        return false;
+    }
+
+    const target = instance.entity_of(node_name);
+
+    if (target === -1) {
+        return false;
+    }
+
+    const playbacks = PLAYBACKS;
+
+    playbacks.length = 0;
+
+    collect_entity_playbacks(playbacks, entity_manager, entity);
+
+    t64_evaluate_world(result, entity_manager.dataset, target, playbacks);
+
+    playbacks.length = 0;
+
+    return true;
+}

package/src/engine/graphics3/prefab/PrefabInstance.d.ts

@@ -1,20 +1,15 @@
 /**
  * @typedef {import("./Prefab.js").Prefab} Prefab
- * @typedef {import("../../../shade/renderer/animation/Skin.js").Skin} Skin
- * @typedef {import("../../../shade/renderer/animation/ShadeAnimationClip.js").ShadeAnimationClip} ShadeAnimationClip
  */
 /**
- * One placement of a {@link Prefab}: the entities its nodes became, and the model's skins and
- * clips re-addressed to them.
+ * One placement of a {@link Prefab}: the entities its nodes became.
  *
  * `entities[i]` is the entity of node `i`; `entities[0]` is the root, the entity that placed the
  * model and was there before. Everything read-only about the model — geometry, materials,
  * inverse-bind matrices, curves — is the prefab's and shared; what is per-instance is the
- * addressing, which is why the skins and clips here are new objects over the same data.
- *
- * Handed out by `MeshSystem.instance_of` rather than copied, because a driver has to know *which*
- * instance it is bound to: a model swap builds a new one, and the object's identity is the only
- * signal that says so.
+ * addressing. Nothing the model needs in order to work is only here: a skin is a `MeshSkin` on each
+ * mesh entity it deforms, and the clips, re-addressed to this placement's entities, are an
+ * `AnimationClips` on the root — which is where a rig built in code puts both too.
  */
 export class PrefabInstance {
     /**
@@ -40,19 +35,6 @@ export class PrefabInstance {
      * @type {Int32Array}
      */
     mesh_entities: Int32Array;
-    /**
-     * The model's skins, with `joints` and `meshes` as entities of this instance.
-     *
-     * @type {Skin[]}
-     */
-    skins: Skin[];
-    /**
-     * The model's clips, with every channel targeting an entity of this instance. Their names and
-     * durations are the model's; a driver resolves a clip by name to its index here.
-     *
-     * @type {ShadeAnimationClip[]}
-     */
-    clips: ShadeAnimationClip[];
     /**
      * The entity of the node the asset calls `name` — a bone, a socket's bone, an effector.
      *
@@ -67,6 +49,4 @@ export class PrefabInstance {
     readonly isPrefabInstance: boolean;
 }
 export type Prefab = import("./Prefab.js").Prefab;
-export type Skin = import("../../../shade/renderer/animation/Skin.js").Skin;
-export type ShadeAnimationClip = import("../../../shade/renderer/animation/ShadeAnimationClip.js").ShadeAnimationClip;
 //# sourceMappingURL=PrefabInstance.d.ts.map

package/src/engine/graphics3/prefab/PrefabInstance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PrefabInstance.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/prefab/PrefabInstance.js"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;;;GAYG;AACH;IACI;;OAEG;IACH,QAFU,MAAM,CAEF;IAEd;;;;OAIG;IACH,MAFU,MAAM,CAEN;IAEV;;;;OAIG;IACH,UAFU,UAAU,CAES;IAE7B;;;;;OAKG;IACH,eAFU,UAAU,CAEc;IAElC;;;;OAIG;IACH,OAFU,IAAI,EAAE,CAEL;IAEX;;;;;OAKG;IACH,OAFU,kBAAkB,EAAE,CAEnB;IAEX;;;;;OAKG;IACH,gBAHW,MAAM,GACJ,MAAM,CAMlB;IAGL;;;OAGG;IACH,2BAFU,OAAO,CAEwB;CANxC;qBAxEY,OAAO,aAAa,EAAE,MAAM;mBAC5B,OAAO,2CAA2C,EAAE,IAAI;iCACxD,OAAO,yDAAyD,EAAE,kBAAkB"}
+{"version":3,"file":"PrefabInstance.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/prefab/PrefabInstance.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;GASG;AACH;IACI;;OAEG;IACH,QAFU,MAAM,CAEF;IAEd;;;;OAIG;IACH,MAFU,MAAM,CAEN;IAEV;;;;OAIG;IACH,UAFU,UAAU,CAES;IAE7B;;;;;OAKG;IACH,eAFU,UAAU,CAEc;IAElC;;;;;OAKG;IACH,gBAHW,MAAM,GACJ,MAAM,CAMlB;IAGL;;;OAGG;IACH,2BAFU,OAAO,CAEwB;CANxC;qBApDY,OAAO,aAAa,EAAE,MAAM"}

package/src/engine/graphics3/prefab/PrefabInstance.js

@@ -1,80 +1,60 @@
-/**
- * @typedef {import("./Prefab.js").Prefab} Prefab
- * @typedef {import("../../../shade/renderer/animation/Skin.js").Skin} Skin
- * @typedef {import("../../../shade/renderer/animation/ShadeAnimationClip.js").ShadeAnimationClip} ShadeAnimationClip
- */
-
-/**
- * One placement of a {@link Prefab}: the entities its nodes became, and the model's skins and
- * clips re-addressed to them.
- *
- * `entities[i]` is the entity of node `i`; `entities[0]` is the root, the entity that placed the
- * model and was there before. Everything read-only about the model — geometry, materials,
- * inverse-bind matrices, curves — is the prefab's and shared; what is per-instance is the
- * addressing, which is why the skins and clips here are new objects over the same data.
- *
- * Handed out by `MeshSystem.instance_of` rather than copied, because a driver has to know *which*
- * instance it is bound to: a model swap builds a new one, and the object's identity is the only
- * signal that says so.
- */
-export class PrefabInstance {
-    /**
-     * @type {Prefab}
-     */
-    prefab = null;
-
-    /**
-     * The entity that placed the model. Node 0 of the prefab.
-     *
-     * @type {number}
-     */
-    root = -1;
-
-    /**
-     * The entity of each node of the prefab, by node index.
-     *
-     * @type {Int32Array}
-     */
-    entities = new Int32Array(0);
-
-    /**
-     * The entities that draw — one per primitive of the prefab, in the prefab's primitive order.
-     * Each holds the `meshes` row of the same index as its `transforms` row.
-     *
-     * @type {Int32Array}
-     */
-    mesh_entities = new Int32Array(0);
-
-    /**
-     * The model's skins, with `joints` and `meshes` as entities of this instance.
-     *
-     * @type {Skin[]}
-     */
-    skins = [];
-
-    /**
-     * The model's clips, with every channel targeting an entity of this instance. Their names and
-     * durations are the model's; a driver resolves a clip by name to its index here.
-     *
-     * @type {ShadeAnimationClip[]}
-     */
-    clips = [];
-
-    /**
-     * The entity of the node the asset calls `name` — a bone, a socket's bone, an effector.
-     *
-     * @param {string} name
-     * @returns {number} the entity, or -1 when the model has no such node
-     */
-    entity_of(name) {
-        const index = this.prefab.index_of(name);
-
-        return index === -1 ? -1 : this.entities[index];
-    }
-}
-
-/**
- * @readonly
- * @type {boolean}
- */
-PrefabInstance.prototype.isPrefabInstance = true;
+/**
+ * @typedef {import("./Prefab.js").Prefab} Prefab
+ */
+
+/**
+ * One placement of a {@link Prefab}: the entities its nodes became.
+ *
+ * `entities[i]` is the entity of node `i`; `entities[0]` is the root, the entity that placed the
+ * model and was there before. Everything read-only about the model — geometry, materials,
+ * inverse-bind matrices, curves — is the prefab's and shared; what is per-instance is the
+ * addressing. Nothing the model needs in order to work is only here: a skin is a `MeshSkin` on each
+ * mesh entity it deforms, and the clips, re-addressed to this placement's entities, are an
+ * `AnimationClips` on the root — which is where a rig built in code puts both too.
+ */
+export class PrefabInstance {
+    /**
+     * @type {Prefab}
+     */
+    prefab = null;
+
+    /**
+     * The entity that placed the model. Node 0 of the prefab.
+     *
+     * @type {number}
+     */
+    root = -1;
+
+    /**
+     * The entity of each node of the prefab, by node index.
+     *
+     * @type {Int32Array}
+     */
+    entities = new Int32Array(0);
+
+    /**
+     * The entities that draw — one per primitive of the prefab, in the prefab's primitive order.
+     * Each holds the `meshes` row of the same index as its `transforms` row.
+     *
+     * @type {Int32Array}
+     */
+    mesh_entities = new Int32Array(0);
+
+    /**
+     * The entity of the node the asset calls `name` — a bone, a socket's bone, an effector.
+     *
+     * @param {string} name
+     * @returns {number} the entity, or -1 when the model has no such node
+     */
+    entity_of(name) {
+        const index = this.prefab.index_of(name);
+
+        return index === -1 ? -1 : this.entities[index];
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+PrefabInstance.prototype.isPrefabInstance = true;

package/src/engine/graphics3/prefab/prefab_instantiate.d.ts

@@ -4,8 +4,9 @@
  * **What a model is in an ECS.** Each node of the prefab becomes an entity: named, attached to
  * its parent's entity by a `TransformAttachment` carrying the node's rest pose, holding a world
  * `Transform64` composed from the root's, drawing through a `ShadedGeometry` where the node
- * carries geometry, and declaring `GPUStateAuthority` — with a zero flags word — where a clip or a
- * skin may later hand the node to the GPU, so that the hand-over is a bit write and never a
+ * carries geometry — and deforming through a `MeshSkin` naming the joints' entities where the
+ * geometry is skinned — and declaring `GPUStateAuthority` — with a zero flags word — where a clip
+ * or a skin may later hand the node to the GPU, so that the hand-over is a bit write and never a
  * component add. Node 0 is `root` itself, the caller's entity, whose `Transform64` is the
  * placement.
  *
@@ -19,6 +20,12 @@
  * transient to serialization: a save holds the model's placement, not sixty joints of derived
  * state.
  *
+ * **The model's clips go on the root, last.** An {@link AnimationClips} holding them, every
+ * channel re-addressed to this placement's entities, is added once every entity it keys exists —
+ * empty when the model has none, so that whatever plays on the root is still driven. The root
+ * must not carry one already: it is one placement's clips, and a second placement would replace
+ * them under whoever is playing them.
+ *
  * @param {Prefab} prefab
  * @param {EntityComponentDataset} dataset
  * @param {number} root an entity carrying a `Transform64`
@@ -31,11 +38,17 @@ export function prefab_instantiate(prefab: Prefab, dataset: EntityComponentDatas
     transient?: boolean;
 }): PrefabInstance;
 /**
- * Remove every entity an instance spawned. The root is the caller's and stays.
+ * Remove every entity an instance spawned, and its clips from the root. The root is the caller's
+ * and stays.
  *
  * Children before parents, so that no parent's removal has to reach down and detach a child
  * that is about to go anyway.
  *
+ * **The clips go after the entities they key.** Whatever was playing them gives back what it
+ * holds for each target when they go, and a target that has already left is one there is nothing
+ * left to give back for. They go only if the root still carries them: the root's own removal takes
+ * its components one by one, and may have taken them already.
+ *
  * @param {EntityComponentDataset} dataset
  * @param {PrefabInstance} instance
  */

package/src/engine/graphics3/prefab/prefab_instantiate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prefab_instantiate.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/prefab/prefab_instantiate.js"],"names":[],"mappings":"AAsCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,2CARW,MAAM,WACN,sBAAsB,QACtB,MAAM;IAEY,SAAS,GAA3B,OAAO;IAEL,cAAc,CAgJ1B;AAED;;;;;;;;GAQG;AACH,iDAHW,sBAAsB,YACtB,cAAc,QAWxB;qBApNY,OAAO,aAAa,EAAE,MAAM;qCAC5B,OAAO,qCAAqC,EAAE,sBAAsB;+BAJlD,qBAAqB"}
+{"version":3,"file":"prefab_instantiate.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/prefab/prefab_instantiate.js"],"names":[],"mappings":"AAyCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,2CARW,MAAM,WACN,sBAAsB,QACtB,MAAM;IAEY,SAAS,GAA3B,OAAO;IAEL,cAAc,CA+J1B;AAED;;;;;;;;;;;;;;GAcG;AACH,iDAHW,sBAAsB,YACtB,cAAc,QAiBxB;qBAxPY,OAAO,aAAa,EAAE,MAAM;qCAC5B,OAAO,qCAAqC,EAAE,sBAAsB;+BAJlD,qBAAqB"}

package/src/engine/graphics3/prefab/prefab_instantiate.js

@@ -2,7 +2,6 @@ import { assert } from "../../../core/assert.js";
 import { m4_multiply } from "../../../core/geom/3d/mat4/m4_multiply.js";
 import { ShadeAnimationChannel } from "../../../shade/renderer/animation/ShadeAnimationChannel.js";
 import { ShadeAnimationClip } from "../../../shade/renderer/animation/ShadeAnimationClip.js";
-import { Skin } from "../../../shade/renderer/animation/Skin.js";
 import { SerializationMetadata } from "../../ecs/components/SerializationMetadata.js";
 import { GPUStateAuthority } from "../../ecs/gpu/GPUStateAuthority.js";
 import { Name } from "../../ecs/name/Name.js";
@@ -10,8 +9,10 @@ import { ParentEntity } from "../../ecs/parent/ParentEntity.js";
 import { TransformAttachment } from "../../ecs/transform-attachment/TransformAttachment.js";
 import { Transform64 } from "../../ecs/transform/Transform64.js";
 import { DrawMode } from "../../graphics/ecs/mesh-v2/DrawMode.js";
+import { MeshSkin } from "../../graphics/ecs/mesh-v2/MeshSkin.js";
 import { ShadedGeometry } from "../../graphics/ecs/mesh-v2/ShadedGeometry.js";
 import { ShadedGeometryFlags } from "../../graphics/ecs/mesh-v2/ShadedGeometryFlags.js";
+import { AnimationClips } from "../animation/AnimationClips.js";
 import { PrefabInstance } from "./PrefabInstance.js";
 
 /**
@@ -31,9 +32,11 @@ const COMPONENT_TYPES = [
     TransformAttachment,
     Name,
     ShadedGeometry,
+    MeshSkin,
     GPUStateAuthority,
     ParentEntity,
     SerializationMetadata,
+    AnimationClips,
 ];
 
 /**
@@ -42,8 +45,9 @@ const COMPONENT_TYPES = [
  * **What a model is in an ECS.** Each node of the prefab becomes an entity: named, attached to
  * its parent's entity by a `TransformAttachment` carrying the node's rest pose, holding a world
  * `Transform64` composed from the root's, drawing through a `ShadedGeometry` where the node
- * carries geometry, and declaring `GPUStateAuthority` — with a zero flags word — where a clip or a
- * skin may later hand the node to the GPU, so that the hand-over is a bit write and never a
+ * carries geometry — and deforming through a `MeshSkin` naming the joints' entities where the
+ * geometry is skinned — and declaring `GPUStateAuthority` — with a zero flags word — where a clip
+ * or a skin may later hand the node to the GPU, so that the hand-over is a bit write and never a
  * component add. Node 0 is `root` itself, the caller's entity, whose `Transform64` is the
  * placement.
  *
@@ -57,6 +61,12 @@ const COMPONENT_TYPES = [
  * transient to serialization: a save holds the model's placement, not sixty joints of derived
  * state.
  *
+ * **The model's clips go on the root, last.** An {@link AnimationClips} holding them, every
+ * channel re-addressed to this placement's entities, is added once every entity it keys exists —
+ * empty when the model has none, so that whatever plays on the root is still driven. The root
+ * must not carry one already: it is one placement's clips, and a second placement would replace
+ * them under whoever is playing them.
+ *
  * @param {Prefab} prefab
  * @param {EntityComponentDataset} dataset
  * @param {number} root an entity carrying a `Transform64`
@@ -81,13 +91,19 @@ export function prefab_instantiate(prefab, dataset, root, { transient = true } =
     const ATTACHMENT = dataset.computeComponentTypeIndex(TransformAttachment);
     const NAME = dataset.computeComponentTypeIndex(Name);
     const GEOMETRY = dataset.computeComponentTypeIndex(ShadedGeometry);
+    const SKIN = dataset.computeComponentTypeIndex(MeshSkin);
     const AUTHORITY = dataset.computeComponentTypeIndex(GPUStateAuthority);
     const PARENT = dataset.computeComponentTypeIndex(ParentEntity);
     const METADATA = dataset.computeComponentTypeIndex(SerializationMetadata);
+    const CLIPS = dataset.computeComponentTypeIndex(AnimationClips);
 
     const root_transform = dataset.getComponent(root, Transform64);
 
     assert.defined(root_transform, `root entity ${root} carries no Transform64 to place the model by`);
+    assert.equal(
+        dataset.getComponentByIndex(root, CLIPS), undefined,
+        `root entity ${root} already carries AnimationClips; one root holds one placement`
+    );
 
     const node_count = prefab.node_count;
 
@@ -129,6 +145,10 @@ export function prefab_instantiate(prefab, dataset, root, { transient = true } =
     // immutable while attached, and sixty copies of one number are sixty allocations for nothing.
     const owner = ParentEntity.from(root);
 
+    // Each skin's joints as this instance's entities, once: the meshes a skin deforms share the
+    // array, as they share the prefab's inverse binds.
+    const skin_joints = prefab.skins.map(skin => Int32Array.from(skin.joints, joint => entities[joint]));
+
     for (let i = 1; i < node_count; i++) {
         const entity = entities[i];
 
@@ -158,6 +178,13 @@ export function prefab_instantiate(prefab, dataset, root, { transient = true } =
             }
 
             dataset.addComponentToEntityByIndex(entity, GEOMETRY, geometry);
+
+            if (primitive.skin !== -1) {
+                dataset.addComponentToEntityByIndex(entity, SKIN, MeshSkin.from(
+                    skin_joints[primitive.skin],
+                    prefab.skins[primitive.skin].inverse_bind_matrices
+                ));
+            }
         }
 
         const attachment = new TransformAttachment();
@@ -190,14 +217,8 @@ export function prefab_instantiate(prefab, dataset, root, { transient = true } =
     instance.entities = entities;
     instance.mesh_entities = Int32Array.from(prefab.primitives, primitive => entities[primitive.node]);
 
-    instance.skins = prefab.skins.map(skin => Skin.from({
-        name: skin.name,
-        joints: Array.from(skin.joints, joint => entities[joint]),
-        inverse_bind_matrices: skin.inverse_bind_matrices,
-        meshes: Array.from(skin.meshes, mesh => entities[mesh]),
-    }));
-
-    instance.clips = prefab.clips.map(clip => ShadeAnimationClip.from({
+    // Per placement: the curves are the prefab's, and only the addressing is this instance's.
+    const clips = prefab.clips.map(clip => ShadeAnimationClip.from({
         name: clip.name,
         channels: clip.channels.map(channel => ShadeAnimationChannel.from({
             target: entities[channel.target],
@@ -206,15 +227,25 @@ export function prefab_instantiate(prefab, dataset, root, { transient = true } =
         })),
     }));
 
+    // Last: whatever plays these links when they arrive, and every entity they key is complete by
+    // then.
+    dataset.addComponentToEntityByIndex(root, CLIPS, AnimationClips.from(clips));
+
     return instance;
 }
 
 /**
- * Remove every entity an instance spawned. The root is the caller's and stays.
+ * Remove every entity an instance spawned, and its clips from the root. The root is the caller's
+ * and stays.
  *
  * Children before parents, so that no parent's removal has to reach down and detach a child
  * that is about to go anyway.
  *
+ * **The clips go after the entities they key.** Whatever was playing them gives back what it
+ * holds for each target when they go, and a target that has already left is one there is nothing
+ * left to give back for. They go only if the root still carries them: the root's own removal takes
+ * its components one by one, and may have taken them already.
+ *
  * @param {EntityComponentDataset} dataset
  * @param {PrefabInstance} instance
  */
@@ -227,4 +258,10 @@ export function prefab_instance_destroy(dataset, instance) {
     for (let i = entities.length - 1; i >= 1; i--) {
         dataset.removeEntity(entities[i]);
     }
+
+    const root = instance.root;
+
+    if (dataset.entityExists(root) && dataset.getComponent(root, AnimationClips) !== undefined) {
+        dataset.removeComponentFromEntity(root, AnimationClips);
+    }
 }