@woosh/meep-engine 3.23.0 → 3.25.0

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

@@ -1,74 +1,75 @@
-import { assert } from "../../../core/assert.js";
-import { PosePlayback } from "../../../shade/renderer/animation/pose/PosePlayback.js";
-import { pose_evaluate_world } from "../../../shade/renderer/animation/pose/pose_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 pose is {@link pose_evaluate_world} over the clips the animation systems are driving: a pure
- * function of (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.
- *
- * 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 node = instance.nodes.get(node_name);
-
-    if (node === undefined) {
-        return false;
-    }
-
-    const playbacks = PLAYBACKS;
-
-    playbacks.length = 0;
-
-    collect_entity_playbacks(playbacks, entity_manager, entity);
-
-    pose_evaluate_world(result, node, 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.
+ *
+ * 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/Prefab.d.ts

@@ -0,0 +1,130 @@
+/**
+ * @typedef {import("../../../shade/renderer/geometry/MeshletGeometry.js").MeshletGeometry} MeshletGeometry
+ * @typedef {import("../../../shade/renderer/material/ShadeMaterial.js").ShadeMaterial} ShadeMaterial
+ * @typedef {import("../../../shade/renderer/animation/Skin.js").Skin} Skin
+ * @typedef {import("../../../shade/renderer/animation/ShadeAnimationClip.js").ShadeAnimationClip} ShadeAnimationClip
+ * @typedef {import("../../ecs/transform/Transform64.js").Transform64} Transform64
+ */
+/**
+ * One draw of a prefab: a node that carries geometry, and the skin that deforms it if any.
+ */
+export class PrefabPrimitive {
+    /**
+     * Index of the node this primitive draws at.
+     *
+     * @type {number}
+     */
+    node: number;
+    /**
+     * @type {MeshletGeometry}
+     */
+    geometry: MeshletGeometry;
+    /**
+     * @type {ShadeMaterial}
+     */
+    material: ShadeMaterial;
+    /**
+     * Index into {@link Prefab.skins} of the skin this primitive deforms against, or -1 for a
+     * rigid primitive.
+     *
+     * @type {number}
+     */
+    skin: number;
+}
+/**
+ * A model compiled once, to be spawned as entities any number of times.
+ *
+ * **Everything in here is addressed by node index**, and a node index is what an instance turns
+ * into an entity. Parents precede children, so one forward pass composes every world transform
+ * and one forward pass spawns every entity with its parent already there. Node 0 is the root:
+ * the entity that places the model, which the prefab does not spawn and whose transform is the
+ * placement. It carries no name and no geometry of its own.
+ *
+ * Skins name their joints and their meshes by node index; clips target node indices. Geometry,
+ * materials, inverse-bind matrices and animation curves are shared by every instance — none of
+ * them is per-placement state — which is what makes a prefab cheap to instantiate and what a
+ * per-instance copy of a node tree could never be.
+ *
+ * Built by `prefab_compile`, from what a loader produced. Read-only afterwards.
+ */
+export class Prefab {
+    /**
+     * @type {number}
+     */
+    node_count: number;
+    /**
+     * Parent node of each node; -1 for the root, and every parent's index is below its child's.
+     *
+     * @type {Int32Array}
+     */
+    parent: Int32Array;
+    /**
+     * The name the asset gave each node, or an empty string.
+     *
+     * @type {string[]}
+     */
+    name: string[];
+    /**
+     * Each node's rest pose, relative to its parent. A skinned mesh node's is the frame its skin
+     * deforms in, not what the file said — see `prefab_normalize_skin_frames`.
+     *
+     * @type {Transform64[]}
+     */
+    local: Transform64[];
+    /**
+     * Each node's rest pose relative to the root, as a column-major 4×4, composed from
+     * {@link local}. The root's is the identity.
+     *
+     * @type {Float64Array[]}
+     */
+    world: Float64Array[];
+    /**
+     * Whether a node is one the GPU may take over: a joint of a skin, the target of a clip, or
+     * anything under either — the GPU composes a driven joint's whole subtree. These are the nodes
+     * an instance declares `GPUStateAuthority` on, so that a later grant is a bit write rather
+     * than a component add.
+     *
+     * @type {Uint8Array}
+     */
+    animated: Uint8Array;
+    /**
+     * @type {PrefabPrimitive[]}
+     */
+    primitives: PrefabPrimitive[];
+    /**
+     * Skins with `joints` and `meshes` as node indices.
+     *
+     * @type {Skin[]}
+     */
+    skins: Skin[];
+    /**
+     * Clips whose channels target node indices.
+     *
+     * @type {ShadeAnimationClip[]}
+     */
+    clips: ShadeAnimationClip[];
+    /**
+     * Which node the asset calls `name`. A name authored twice answers with the first node in
+     * pre-order, which is the same answer a search would have given.
+     *
+     * @param {string} name
+     * @returns {number} the node index, or -1
+     */
+    index_of(name: string): number;
+    /**
+     * Build {@link index_of}'s table from {@link name}. For `prefab_compile`.
+     */
+    index_names(): void;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isPrefab: boolean;
+    #private;
+}
+export type MeshletGeometry = import("../../../shade/renderer/geometry/MeshletGeometry.js").MeshletGeometry;
+export type ShadeMaterial = import("../../../shade/renderer/material/ShadeMaterial.js").ShadeMaterial;
+export type Skin = import("../../../shade/renderer/animation/Skin.js").Skin;
+export type ShadeAnimationClip = import("../../../shade/renderer/animation/ShadeAnimationClip.js").ShadeAnimationClip;
+export type Transform64 = import("../../ecs/transform/Transform64.js").Transform64;
+//# sourceMappingURL=Prefab.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Prefab.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/prefab/Prefab.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;GAEG;AACH;IACI;;;;OAIG;IACH,MAFU,MAAM,CAEP;IAET;;OAEG;IACH,UAFU,eAAe,CAET;IAEhB;;OAEG;IACH,UAFU,aAAa,CAEP;IAEhB;;;;;OAKG;IACH,MAFU,MAAM,CAEN;CACb;AAED;;;;;;;;;;;;;;;GAeG;AACH;IACI;;OAEG;IACH,YAFU,MAAM,CAED;IAEf;;;;OAIG;IACH,QAFU,UAAU,CAEO;IAE3B;;;;OAIG;IACH,MAFU,MAAM,EAAE,CAER;IAEV;;;;;OAKG;IACH,OAFU,WAAW,EAAE,CAEZ;IAEX;;;;;OAKG;IACH,OAFU,YAAY,EAAE,CAEb;IAEX;;;;;;;OAOG;IACH,UAFU,UAAU,CAES;IAE7B;;OAEG;IACH,YAFU,eAAe,EAAE,CAEX;IAEhB;;;;OAIG;IACH,OAFU,IAAI,EAAE,CAEL;IAEX;;;;OAIG;IACH,OAFU,kBAAkB,EAAE,CAEnB;IAOX;;;;;;OAMG;IACH,eAHW,MAAM,GACJ,MAAM,CAMlB;IAED;;OAEG;IACH,oBAcC;IAGL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;;CANxB;8BA1JY,OAAO,qDAAqD,EAAE,eAAe;4BAC7E,OAAO,mDAAmD,EAAE,aAAa;mBACzE,OAAO,2CAA2C,EAAE,IAAI;iCACxD,OAAO,yDAAyD,EAAE,kBAAkB;0BACpF,OAAO,oCAAoC,EAAE,WAAW"}

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

@@ -0,0 +1,162 @@
+/**
+ * @typedef {import("../../../shade/renderer/geometry/MeshletGeometry.js").MeshletGeometry} MeshletGeometry
+ * @typedef {import("../../../shade/renderer/material/ShadeMaterial.js").ShadeMaterial} ShadeMaterial
+ * @typedef {import("../../../shade/renderer/animation/Skin.js").Skin} Skin
+ * @typedef {import("../../../shade/renderer/animation/ShadeAnimationClip.js").ShadeAnimationClip} ShadeAnimationClip
+ * @typedef {import("../../ecs/transform/Transform64.js").Transform64} Transform64
+ */
+
+/**
+ * One draw of a prefab: a node that carries geometry, and the skin that deforms it if any.
+ */
+export class PrefabPrimitive {
+    /**
+     * Index of the node this primitive draws at.
+     *
+     * @type {number}
+     */
+    node = 0;
+
+    /**
+     * @type {MeshletGeometry}
+     */
+    geometry = null;
+
+    /**
+     * @type {ShadeMaterial}
+     */
+    material = null;
+
+    /**
+     * Index into {@link Prefab.skins} of the skin this primitive deforms against, or -1 for a
+     * rigid primitive.
+     *
+     * @type {number}
+     */
+    skin = -1;
+}
+
+/**
+ * A model compiled once, to be spawned as entities any number of times.
+ *
+ * **Everything in here is addressed by node index**, and a node index is what an instance turns
+ * into an entity. Parents precede children, so one forward pass composes every world transform
+ * and one forward pass spawns every entity with its parent already there. Node 0 is the root:
+ * the entity that places the model, which the prefab does not spawn and whose transform is the
+ * placement. It carries no name and no geometry of its own.
+ *
+ * Skins name their joints and their meshes by node index; clips target node indices. Geometry,
+ * materials, inverse-bind matrices and animation curves are shared by every instance — none of
+ * them is per-placement state — which is what makes a prefab cheap to instantiate and what a
+ * per-instance copy of a node tree could never be.
+ *
+ * Built by `prefab_compile`, from what a loader produced. Read-only afterwards.
+ */
+export class Prefab {
+    /**
+     * @type {number}
+     */
+    node_count = 0;
+
+    /**
+     * Parent node of each node; -1 for the root, and every parent's index is below its child's.
+     *
+     * @type {Int32Array}
+     */
+    parent = new Int32Array(0);
+
+    /**
+     * The name the asset gave each node, or an empty string.
+     *
+     * @type {string[]}
+     */
+    name = [];
+
+    /**
+     * Each node's rest pose, relative to its parent. A skinned mesh node's is the frame its skin
+     * deforms in, not what the file said — see `prefab_normalize_skin_frames`.
+     *
+     * @type {Transform64[]}
+     */
+    local = [];
+
+    /**
+     * Each node's rest pose relative to the root, as a column-major 4×4, composed from
+     * {@link local}. The root's is the identity.
+     *
+     * @type {Float64Array[]}
+     */
+    world = [];
+
+    /**
+     * Whether a node is one the GPU may take over: a joint of a skin, the target of a clip, or
+     * anything under either — the GPU composes a driven joint's whole subtree. These are the nodes
+     * an instance declares `GPUStateAuthority` on, so that a later grant is a bit write rather
+     * than a component add.
+     *
+     * @type {Uint8Array}
+     */
+    animated = new Uint8Array(0);
+
+    /**
+     * @type {PrefabPrimitive[]}
+     */
+    primitives = [];
+
+    /**
+     * Skins with `joints` and `meshes` as node indices.
+     *
+     * @type {Skin[]}
+     */
+    skins = [];
+
+    /**
+     * Clips whose channels target node indices.
+     *
+     * @type {ShadeAnimationClip[]}
+     */
+    clips = [];
+
+    /**
+     * @type {Map<string, number>}
+     */
+    #index_by_name = new Map();
+
+    /**
+     * Which node the asset calls `name`. A name authored twice answers with the first node in
+     * pre-order, which is the same answer a search would have given.
+     *
+     * @param {string} name
+     * @returns {number} the node index, or -1
+     */
+    index_of(name) {
+        const index = this.#index_by_name.get(name);
+
+        return index === undefined ? -1 : index;
+    }
+
+    /**
+     * Build {@link index_of}'s table from {@link name}. For `prefab_compile`.
+     */
+    index_names() {
+        const by_name = this.#index_by_name;
+
+        by_name.clear();
+
+        const names = this.name;
+
+        for (let i = 0; i < names.length; i++) {
+            const name = names[i];
+
+            if (name !== "" && !by_name.has(name)) {
+                by_name.set(name, i);
+            }
+        }
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+Prefab.prototype.isPrefab = true;

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

@@ -0,0 +1,72 @@
+/**
+ * @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: Prefab;
+    /**
+     * The entity that placed the model. Node 0 of the prefab.
+     *
+     * @type {number}
+     */
+    root: number;
+    /**
+     * The entity of each node of the prefab, by node index.
+     *
+     * @type {Int32Array}
+     */
+    entities: Int32Array;
+    /**
+     * 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: 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.
+     *
+     * @param {string} name
+     * @returns {number} the entity, or -1 when the model has no such node
+     */
+    entity_of(name: string): number;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    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

@@ -0,0 +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"}

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

@@ -0,0 +1,80 @@
+/**
+ * @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;

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

@@ -0,0 +1,23 @@
+/**
+ * Compile what a loader produced into a {@link Prefab}.
+ *
+ * The bundle is read and never written: it is the loader's, shared by every placement of the
+ * model and by whatever else reads it. Geometry, materials, inverse-bind matrices and curves are
+ * referenced, not copied.
+ *
+ * The bundle's nodes are in pre-order, so one forward pass indexes them with every parent below
+ * its children and composes each world from its parent's. Skins and clips are re-addressed from
+ * the bundle's indices to the prefab's; nothing about them changes otherwise. Then, once per model
+ * rather than once per placement, each skin's meshes are put into the frame the skin deforms in
+ * ({@link prefab_normalize_skin_frames}) and each clip that scales something is checked against
+ * each skin ({@link prefab_skin_clip_scale_conflicts}), both reported the way the animation
+ * manager used to report them on registration.
+ *
+ * @param {SceneBundle} bundle
+ * @returns {Prefab}
+ */
+export function prefab_compile(bundle: SceneBundle): Prefab;
+export type SceneBundle = import("../../../shade/renderer/loader/SceneBundle.js").SceneBundle;
+export type SceneNode = import("../../../shade/renderer/loader/SceneNode.js").SceneNode;
+import { Prefab } from "./Prefab.js";
+//# sourceMappingURL=prefab_compile.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prefab_compile.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/prefab/prefab_compile.js"],"names":[],"mappings":"AA6CA;;;;;;;;;;;;;;;;;GAiBG;AACH,uCAHW,WAAW,GACT,MAAM,CA0KlB;0BA5NY,OAAO,+CAA+C,EAAE,WAAW;wBACnE,OAAO,6CAA6C,EAAE,SAAS;uBANpC,aAAa"}