@woosh/meep-engine 3.42.0 → 3.44.0

package/src/shade/wgsl/emulator/WGSLJavaScriptCompiler.js

@@ -1491,7 +1491,8 @@ function emitVariableUpdatingStatement(c, node) {
             || isScalarUnsigned(lhs_compiled.type)
             || isScalarUnsigned(rhs_compiled.type)
         )) {
-            c.out.add(emitWriteStatement(lhs_compiled, `wgsl.${bitwise_helper}(${lhs_compiled.code}, ${rhs_compiled.code})`));
+            c.out.add(emitWriteStatement(lhs_compiled,
+                `wgsl.${shiftHelperFor(bitwise_helper, lhs_compiled.type)}(${lhs_compiled.code}, ${rhs_compiled.code})`));
             return;
         }
         c.out.add(`${lhs_compiled.code} ${op_text} ${rhs_compiled.code};`);
@@ -2155,14 +2156,15 @@ function compileBinaryExpression(c, node, op_type, mode) {
     // bit set was negative too. The helpers normalise with `>>> 0`, which is what WGSL u32 means.
     //
     // Deliberately not extended to i32: `bit_and` and friends return an unsigned result, and a
-    // signed operand is exactly the case raw JS already gets right.
+    // signed operand is exactly the case raw JS already gets right. A shift is the exception: WGSL
+    // makes its amount a u32 whatever it shifts, so an i32 shift lands here and takes the signed helper.
     const bitwise_helper = BITWISE_HELPER[op_text];
     if (bitwise_helper !== undefined) {
         if (isContainerType(left.type) || isContainerType(right.type)
             || isScalarBool(left.type) || isScalarBool(right.type)
             || isScalarUnsigned(left.type) || isScalarUnsigned(right.type)) {
             return {
-                code: `wgsl.${bitwise_helper}(${left.code}, ${right.code})`,
+                code: `wgsl.${shiftHelperFor(bitwise_helper, left.type)}(${left.code}, ${right.code})`,
                 type: inferRawBinaryResultType(left.type, right.type, op_text),
             };
         }
@@ -2193,6 +2195,12 @@ const BITWISE_HELPER = {
     '>>': 'shr',
 };
 
+/** The helper for a bitwise operator on a value of type `t`: a shift of an i32 (scalar or vector) keeps its sign. */
+function shiftHelperFor(helper, t) {
+    if ((helper === 'shl' || helper === 'shr') && isIntegerType(t) && integerScalarName(t) === 'i32') { return `${helper}_i32`; }
+    return helper;
+}
+
 /** Map WGSL comparison operators to language-core element-wise helper names. */
 const COMPARISON_HELPER = {
     '==': 'eq',

package/src/shade/wgsl/emulator/WGSLLanguageCore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":";IAs/CA;;;;;;;;;;;;;;OAcG;IACH,+DAmDC"}
+{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":";IAy/CA;;;;;;;;;;;;;;OAcG;IACH,+DAmDC"}

package/src/shade/wgsl/emulator/WGSLLanguageCore.js

@@ -586,6 +586,9 @@ export const WGSLLanguageCore = {
     bit_xor: (a, b) => binop(a, b, (x, y) => typeof x === 'boolean' ? x !== y : (x ^ y) >>> 0),
     shl:     (a, b) => binop(a, b, (x, y) => (x << y) >>> 0),
     shr:     (a, b) => binop(a, b, (x, y) => x >>> y),
+    // The same on an i32, whose shift amount WGSL still makes a u32: `>>` sign-extends, and both stay signed.
+    shl_i32: (a, b) => binop(a, b, (x, y) => (x << y) | 0),
+    shr_i32: (a, b) => binop(a, b, (x, y) => x >> y),
 
     neg: (a) => unop(a, x => -x),
     not: (a) => unop(a, x => (~x) >>> 0),

package/src/shade/wgsl/validate_wgsl_source.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validate_wgsl_source.d.ts","sourceRoot":"","sources":["../../../../src/shade/wgsl/validate_wgsl_source.js"],"names":[],"mappings":"AAuKA;;;;;;GAMG;AACH,6CAJW,MAAM,UACN,OAAO,iBAAiB,EAAE,UAAU,GAClC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,CA6M7D"}
+{"version":3,"file":"validate_wgsl_source.d.ts","sourceRoot":"","sources":["../../../../src/shade/wgsl/validate_wgsl_source.js"],"names":[],"mappings":"AAqMA;;;;;;GAMG;AACH,6CAJW,MAAM,UACN,OAAO,iBAAiB,EAAE,UAAU,GAClC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,CAsP7D"}

package/src/shade/wgsl/validate_wgsl_source.js

@@ -12,6 +12,8 @@ import { WGSLLanguageCore } from "./emulator/WGSLLanguageCore.js";
  *  - immutable-assignment: assigning to a `let`/`const` local or a function parameter
  *    (all immutable in WGSL); only `var` is mutable.
  *  - swizzle-store: assigning to a multi-component swizzle (`v.xy = …`), which WGSL forbids.
+ *    A struct may name a member `xy`, and then the store is legal; where one does, only a base
+ *    declared as a vector is flagged.
  *  - foreign-token: HLSL/GLSL constructs that are not WGSL (`float3`, `int2`, `#if`,
  *    `imageAtomicMax`, `lerp(`, `rsqrt(`, …) — unambiguous, lexical.
  *  - reserved-keyword: an identifier that is a WGSL reserved word (`target`, `filter`,
@@ -87,13 +89,16 @@ const WGSL_BUILTIN_NAMES = new Set([
 
 const SWIZZLE_COMPONENTS = /^[xyzwrgba]+$/;
 const LHS_SWIZZLE_TAIL = /\.([xyzwrgba]{2,})\s*$/;
+const VECTOR_TYPE_NAME = /^vec[234][fhiu]?$/;
 
-// Unambiguous non-WGSL tokens. Each entry is a regex and a human label.
+// Unambiguous non-WGSL tokens. Each entry is a regex and a human label. The bare scalar names
+// (`float`, `int`, `half`, `fixed`) are neither keywords nor reserved words in WGSL, so they are
+// legal identifiers (`let half = n / 2u;`) and only their vector forms are matched.
 const FOREIGN_TOKENS = [
     [/\bfloat[1-4]x[1-4]\b/, 'HLSL matrix type (use matNxM<f32>)'],
     [/\bfloat[2-4]\b/, 'HLSL vector type (use vecN<f32>)'],
     [/\b(?:int|uint)[2-4]\b/, 'HLSL integer vector type (use vecN<i32|u32>)'],
-    [/\b(?:half|fixed)[2-4]?\b/, 'HLSL scalar/vector type'],
+    [/\b(?:half|fixed)[2-4]\b/, 'HLSL vector type (use vecN<f16>)'],
     [/#\s*(?:if|ifdef|ifndef|endif|else|elif|define|pragma)\b/, 'C-preprocessor directive'],
     [/\bimageAtomic(?:Max|Min|Add|And|Or|Xor|Exchange)\b/, 'GLSL image atomic (use atomic* on a storage binding)'],
     [/\bimageStore\b/, 'GLSL imageStore (use textureStore)'],
@@ -153,6 +158,31 @@ function firstIdentToken(node) {
     return null;
 }
 
+/**
+ * Whether a `type_specifier` or `call_phrase` names a vector type (`vec3<f32>`, `vec4f`, …).
+ * @param {Node} node
+ */
+function namesVector(node) {
+    const ident = node.namedChildren.find(c => c.type === 'template_elaborated_ident')
+        ?.namedChildren.find(c => c.type === 'ident');
+    return ident !== undefined && VECTOR_TYPE_NAME.test(ident.text.trim());
+}
+
+/**
+ * Whether a declaration can be seen to be a vector without inferring types: its type annotation
+ * names one, or, unannotated, its whole initializer is a vector constructor (`vec3<f32>(0.0)`).
+ * @param {Node|undefined} type_specifier
+ * @param {Node|undefined} initializer
+ */
+function declaresVector(type_specifier, initializer) {
+    if (type_specifier !== undefined) return namesVector(type_specifier);
+    if (initializer === undefined) return false;
+
+    let node = initializer;
+    while (node.namedChildren.length === 1) node = node.namedChildren[0];
+    return node.type === 'call_phrase' && namesVector(node);
+}
+
 /**
  * Strip line comments and block comments and string-free WGSL has no strings, so a coarse
  * comment strip is enough to keep the lexical foreign-token scan from firing inside a
@@ -181,6 +211,8 @@ export function validate_wgsl_source(source, parser) {
     // ── collect the symbol table (user functions + structs) ──
     const declared_functions = new Set();
     const declared_structs = new Set();
+    /** Every struct member name; one shaped like a swizzle makes `x.xy = …` legal on that struct. */
+    const declared_members = new Set();
 
     for (const fn of descendantsOfType(root, 'function_decl')) {
         const header = fn.namedChildren.find(c => c.type === 'function_header');
@@ -191,6 +223,11 @@ export function validate_wgsl_source(source, parser) {
     for (const s of descendantsOfType(root, 'struct_decl')) {
         const ident = s.namedChildren.find(c => c.type === 'ident');
         if (ident !== undefined) declared_structs.add(ident.text.trim());
+
+        for (const member of descendantsOfType(s, 'struct_member')) {
+            const name = member.namedChildren.find(c => c.type === 'member_ident');
+            if (name !== undefined) declared_members.add(name.text.trim());
+        }
     }
 
     const core_builtins = new Set(Object.keys(WGSLLanguageCore));
@@ -209,6 +246,21 @@ export function validate_wgsl_source(source, parser) {
         /** Everything a const-expression may NOT read: parameters, `var`, `let`. @type {Set<string>} */
         const runtime = new Set();
 
+        // Scopes are flat here, so a name is a vector only if every declaration of it says so.
+        /** Names every declaration of which is seen to be a vector. @type {Set<string>} */
+        const vectors = new Set();
+        /** Names declared at least once as anything else. @type {Set<string>} */
+        const not_vectors = new Set();
+
+        const declare_vector = (name, is_vector) => {
+            if (is_vector && !not_vectors.has(name)) {
+                vectors.add(name);
+            } else {
+                vectors.delete(name);
+                not_vectors.add(name);
+            }
+        };
+
         // Value parameters are immutable; POINTER parameters are not — writing through a
         // pointer (`*p = …`, `p.x = …`, `memory[i] = …`) is the legal, common case in this
         // codebase, so excluding them is what keeps this rule free of false positives.
@@ -223,6 +275,7 @@ export function validate_wgsl_source(source, parser) {
                     if (!is_pointer) immutable.add(id.text.trim());
 
                     runtime.add(id.text.trim());
+                    declare_vector(id.text.trim(), declaresVector(type, undefined));
                 }
             }
         }
@@ -237,6 +290,11 @@ export function validate_wgsl_source(source, parser) {
             const name = opt !== undefined && opt !== null ? firstIdentToken(opt) : null;
             if (name === null) continue;
 
+            declare_vector(name, declaresVector(
+                opt.namedChildren.find(c => c.type === 'type_specifier'),
+                decl.namedChildren.find(c => c.type === 'expression'),
+            ));
+
             if (is_var) {
                 mutable.add(name);
                 immutable.delete(name);
@@ -269,8 +327,21 @@ export function validate_wgsl_source(source, parser) {
             if (lhs === undefined) return;
 
             // swizzle-store
+            //
+            // `.xy` is an l-value only as a struct member, so with no struct declaring one the
+            // store is illegal whatever the base is. With one, the base has to be seen to be a
+            // vector: a parameter or local declared as one and stored to directly (`v.xy`).
             const tail = lhs.text.match(LHS_SWIZZLE_TAIL);
-            if (tail !== null && SWIZZLE_COMPONENTS.test(tail[1])) {
+            const core = lhs.namedChildren.find(c => c.type === 'core_lhs_expression');
+            const access = lhs.namedChildren.find(c => c.type === 'component_or_swizzle_specifier');
+            const base = core?.namedChildren.find(c => c.type === 'ident');
+            const on_vector = base !== undefined
+                && access !== undefined
+                && access.namedChildren.length === 1
+                && access.namedChildren[0].type === 'member_ident'
+                && vectors.has(base.text.trim());
+
+            if (tail !== null && SWIZZLE_COMPONENTS.test(tail[1]) && (!declared_members.has(tail[1]) || on_vector)) {
                 diagnostics.push({
                     rule: 'swizzle-store',
                     message: `assignment to multi-component swizzle '.${tail[1]}' is not an l-value in WGSL`,

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

@@ -1,114 +0,0 @@
-/**
- * Hand one entity's instance to the GPU: its skins become deformations.
- *
- * **Registration is eventually consistent by design**, which is what makes this callable the moment
- * an instance exists rather than at some later moment when the scene is known to be built. An id is
- * allocated and returned synchronously, while the skin's meshes are bound to it only once every
- * joint has a row in the scene. Until then the skin is inert rather than wrong: its meshes draw
- * undeformed.
- *
- * The instance's entities therefore do **not** have to hold their rows yet.
- *
- * @param {GPUSceneContext} context the scene's GPU state, which owns the manager and is what the
- * registration is stamped with so it can be given back to the right one
- * @param {PrefabInstance} instance its skins name joint and mesh entities
- * @returns {InstanceAnimationRegistration}
- */
-export function register_instance_animation(context: GPUSceneContext, instance: PrefabInstance): InstanceAnimationRegistration;
-/**
- * Give back everything {@link register_instance_animation} took out, for a manager that is still
- * the one that issued it.
- *
- * **A destroyed manager must not be handed its own ids back.** A renderer restart takes the GPU
- * scene context with it, and the ids it issued mean nothing to the context that replaces it — so
- * the caller forgets them rather than returning them. This is only for the ordinary case: an entity
- * that leaves while the renderer it registered with is still running, and the registration's own
- * {@link InstanceAnimationRegistration#context} is how a caller tells the two apart.
- *
- * @param {InstanceAnimationRegistration} registration
- */
-export function unregister_instance_animation(registration: InstanceAnimationRegistration): void;
-/**
- * Make some of an instance's clips playable — the ones a driver actually plays, and no others.
- *
- * **Registering a clip is not free of consequence, which is why this takes a set.** The pose
- * accumulator marks a joint dirty for every bound clip that writes to it, whatever its weight, so a
- * bound clip at weight zero resolves the joints only it drives to zero rather than leaving them at
- * rest. A driver therefore registers what it can play and re-registers when that changes; a clip no
- * driver claims is never bound and so moves nothing.
- *
- * Each index is registered once however many times it is named. Two states of one graph can play
- * the same clip of the model, and two registrations of one clip are two rows the accumulator would
- * add together.
- *
- * @param {GPUSceneContext} context
- * @param {PrefabInstance} instance its clips target entities
- * @param {ArrayLike<number>} slots indices into `instance.clips`; duplicates are ignored
- * @returns {InstanceClipRegistration}
- */
-export function register_instance_clips(context: GPUSceneContext, instance: PrefabInstance, slots: ArrayLike<number>): InstanceClipRegistration;
-/**
- * Give back everything {@link register_instance_clips} took out, for a manager that is still the one
- * that issued it — see {@link unregister_instance_animation} for why that qualification matters.
- *
- * @param {InstanceClipRegistration} registration
- */
-export function unregister_instance_clips(registration: InstanceClipRegistration): void;
-/**
- * What the animation manager handed back for one {@link PrefabInstance}'s **skins**.
- *
- * Positional: `skins[i]` is the id of the instance's `skins[i]`.
- *
- * **Clips are not here, and that is D37.** A skin belongs to the model — it is how the mesh
- * deforms, and every placement of the model needs it whatever is playing — so the system that
- * places the model registers it. A clip belongs to whatever plays it, and a clip nothing plays must
- * not be registered at all: the pose accumulator marks a joint dirty for any *bound* clip, weight
- * and all, so a joint driven only by clips at weight zero resolves to zero rather than to its rest
- * pose. A model carrying clips and no animation component used to render the sum of every one of
- * them. See {@link register_instance_clips}.
- */
-export class InstanceAnimationRegistration {
-    /**
-     * The GPU scene context these ids were issued by.
-     *
-     * Carried rather than inferred, because **an id may only be handed back to the manager that
-     * issued it** and there is no other way to be sure. A renderer restart builds a new context, and
-     * a holder comparing this against what `scene_context` answers now knows in one `===` whether
-     * giving the ids back is returning them or corrupting a stranger's table — without depending on
-     * when anything last ran.
-     *
-     * @type {GPUSceneContext}
-     */
-    context: GPUSceneContext;
-    /**
-     * @type {number[]}
-     */
-    skins: number[];
-}
-/**
- * The id a clip has when nobody registered it.
- * @type {number}
- */
-export const CLIP_NOT_REGISTERED: number;
-/**
- * Which of an instance's clips a driver has playable, by the instance's own clip index.
- *
- * `ids[i]` is the manager's id for `instance.clips[i]`, or {@link CLIP_NOT_REGISTERED} where this
- * driver does not play that clip. Indexed by the instance rather than packed, because that is how
- * both drivers already address a clip — the graph resolves a name to a model slot, the clip list
- * does the same — and a packed array would want a second table to say what each entry was.
- */
-export class InstanceClipRegistration {
-    /**
-     * The GPU scene context these ids were issued by. See
-     * {@link InstanceAnimationRegistration#context} — same reasoning, same `===` check.
-     *
-     * @type {GPUSceneContext|null}
-     */
-    context: GPUSceneContext | null;
-    /**
-     * @type {Int32Array}
-     */
-    ids: Int32Array;
-}
-//# sourceMappingURL=register_instance_animation.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"register_instance_animation.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/register_instance_animation.js"],"names":[],"mappings":"AAmCA;;;;;;;;;;;;;;;GAeG;AACH,iGAFa,6BAA6B,CAmBzC;AAED;;;;;;;;;;;GAWG;AACH,4DAFW,6BAA6B,QAevC;AA+BD;;;;;;;;;;;;;;;;;GAiBG;AACH,mGAHW,UAAU,MAAM,CAAC,GACf,wBAAwB,CA+BpC;AAED;;;;;GAKG;AACH,wDAFW,wBAAwB,QAqBlC;AAtMD;;;;;;;;;;;;GAYG;AACH;IACI;;;;;;;;;;OAUG;IACH,yBAAe;IAEf;;OAEG;IACH,OAFU,MAAM,EAAE,CAEP;CACd;AAgED;;;GAGG;AACH,kCAFU,MAAM,CAEsB;AAEtC;;;;;;;GAOG;AACH;IACI;;;;;OAKG;IACH,SAFU,kBAAgB,IAAI,CAEf;IAEf;;OAEG;IACH,KAFU,UAAU,CAEI;CAC3B"}

package/src/engine/graphics3/register_instance_animation.js

@@ -1,201 +0,0 @@
-import { assert } from "../../core/assert.js";
-
-/**
- * What the animation manager handed back for one {@link PrefabInstance}'s **skins**.
- *
- * Positional: `skins[i]` is the id of the instance's `skins[i]`.
- *
- * **Clips are not here, and that is D37.** A skin belongs to the model — it is how the mesh
- * deforms, and every placement of the model needs it whatever is playing — so the system that
- * places the model registers it. A clip belongs to whatever plays it, and a clip nothing plays must
- * not be registered at all: the pose accumulator marks a joint dirty for any *bound* clip, weight
- * and all, so a joint driven only by clips at weight zero resolves to zero rather than to its rest
- * pose. A model carrying clips and no animation component used to render the sum of every one of
- * them. See {@link register_instance_clips}.
- */
-export class InstanceAnimationRegistration {
-    /**
-     * The GPU scene context these ids were issued by.
-     *
-     * Carried rather than inferred, because **an id may only be handed back to the manager that
-     * issued it** and there is no other way to be sure. A renderer restart builds a new context, and
-     * a holder comparing this against what `scene_context` answers now knows in one `===` whether
-     * giving the ids back is returning them or corrupting a stranger's table — without depending on
-     * when anything last ran.
-     *
-     * @type {GPUSceneContext}
-     */
-    context = null;
-
-    /**
-     * @type {number[]}
-     */
-    skins = [];
-}
-
-/**
- * Hand one entity's instance to the GPU: its skins become deformations.
- *
- * **Registration is eventually consistent by design**, which is what makes this callable the moment
- * an instance exists rather than at some later moment when the scene is known to be built. An id is
- * allocated and returned synchronously, while the skin's meshes are bound to it only once every
- * joint has a row in the scene. Until then the skin is inert rather than wrong: its meshes draw
- * undeformed.
- *
- * The instance's entities therefore do **not** have to hold their rows yet.
- *
- * @param {GPUSceneContext} context the scene's GPU state, which owns the manager and is what the
- * registration is stamped with so it can be given back to the right one
- * @param {PrefabInstance} instance its skins name joint and mesh entities
- * @returns {InstanceAnimationRegistration}
- */
-export function register_instance_animation(context, instance) {
-    assert.defined(context, 'context');
-    assert.defined(instance, 'instance');
-
-    const manager = context.animation_manager;
-
-    const r = new InstanceAnimationRegistration();
-
-    r.context = context;
-
-    const skins = instance.skins;
-
-    for (let i = 0; i < skins.length; i++) {
-        r.skins.push(manager.register_skin(skins[i]));
-    }
-
-    return r;
-}
-
-/**
- * Give back everything {@link register_instance_animation} took out, for a manager that is still
- * the one that issued it.
- *
- * **A destroyed manager must not be handed its own ids back.** A renderer restart takes the GPU
- * scene context with it, and the ids it issued mean nothing to the context that replaces it — so
- * the caller forgets them rather than returning them. This is only for the ordinary case: an entity
- * that leaves while the renderer it registered with is still running, and the registration's own
- * {@link InstanceAnimationRegistration#context} is how a caller tells the two apart.
- *
- * @param {InstanceAnimationRegistration} registration
- */
-export function unregister_instance_animation(registration) {
-    assert.defined(registration, 'registration');
-    assert.defined(registration.context, 'registration.context');
-
-    const manager = registration.context.animation_manager;
-
-    const skins = registration.skins;
-
-    for (let i = 0; i < skins.length; i++) {
-        manager.unregister_skin(skins[i]);
-    }
-
-    skins.length = 0;
-}
-
-/**
- * The id a clip has when nobody registered it.
- * @type {number}
- */
-export const CLIP_NOT_REGISTERED = -1;
-
-/**
- * Which of an instance's clips a driver has playable, by the instance's own clip index.
- *
- * `ids[i]` is the manager's id for `instance.clips[i]`, or {@link CLIP_NOT_REGISTERED} where this
- * driver does not play that clip. Indexed by the instance rather than packed, because that is how
- * both drivers already address a clip — the graph resolves a name to a model slot, the clip list
- * does the same — and a packed array would want a second table to say what each entry was.
- */
-export class InstanceClipRegistration {
-    /**
-     * The GPU scene context these ids were issued by. See
-     * {@link InstanceAnimationRegistration#context} — same reasoning, same `===` check.
-     *
-     * @type {GPUSceneContext|null}
-     */
-    context = null;
-
-    /**
-     * @type {Int32Array}
-     */
-    ids = new Int32Array(0);
-}
-
-/**
- * Make some of an instance's clips playable — the ones a driver actually plays, and no others.
- *
- * **Registering a clip is not free of consequence, which is why this takes a set.** The pose
- * accumulator marks a joint dirty for every bound clip that writes to it, whatever its weight, so a
- * bound clip at weight zero resolves the joints only it drives to zero rather than leaving them at
- * rest. A driver therefore registers what it can play and re-registers when that changes; a clip no
- * driver claims is never bound and so moves nothing.
- *
- * Each index is registered once however many times it is named. Two states of one graph can play
- * the same clip of the model, and two registrations of one clip are two rows the accumulator would
- * add together.
- *
- * @param {GPUSceneContext} context
- * @param {PrefabInstance} instance its clips target entities
- * @param {ArrayLike<number>} slots indices into `instance.clips`; duplicates are ignored
- * @returns {InstanceClipRegistration}
- */
-export function register_instance_clips(context, instance, slots) {
-    assert.defined(context, 'context');
-    assert.defined(instance, 'instance');
-    assert.defined(slots, 'slots');
-
-    const manager = context.animation_manager;
-
-    const clips = instance.clips;
-
-    const r = new InstanceClipRegistration();
-
-    r.context = context;
-    r.ids = new Int32Array(clips.length).fill(CLIP_NOT_REGISTERED);
-
-    for (let i = 0; i < slots.length; i++) {
-        const slot = slots[i];
-
-        assert.isNonNegativeInteger(slot, 'slot');
-        assert.lessThan(slot, clips.length, 'slot');
-
-        if (r.ids[slot] !== CLIP_NOT_REGISTERED) {
-            // named twice by one driver, which is one clip either way
-            continue;
-        }
-
-        r.ids[slot] = manager.register_clip(clips[slot]);
-    }
-
-    return r;
-}
-
-/**
- * Give back everything {@link register_instance_clips} took out, for a manager that is still the one
- * that issued it — see {@link unregister_instance_animation} for why that qualification matters.
- *
- * @param {InstanceClipRegistration} registration
- */
-export function unregister_instance_clips(registration) {
-    assert.defined(registration, 'registration');
-    assert.defined(registration.context, 'registration.context');
-
-    const manager = registration.context.animation_manager;
-
-    const ids = registration.ids;
-
-    for (let i = 0; i < ids.length; i++) {
-        const id = ids[i];
-
-        if (id === CLIP_NOT_REGISTERED) {
-            continue;
-        }
-
-        manager.unregister_clip(id);
-    }
-
-    ids.fill(CLIP_NOT_REGISTERED);
-}