@woosh/meep-engine 3.23.0 → 3.25.0

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

@@ -0,0 +1,116 @@
+import { assert } from "../../../core/assert.js";
+import { m4_invert } from "../../../core/geom/3d/mat4/m4_invert.js";
+import { m4_multiply } from "../../../core/geom/3d/mat4/m4_multiply.js";
+import { m4_rigidity_defect } from "../../../core/geom/3d/mat4/m4_rigidity_defect.js";
+
+/**
+ * @typedef {import("./Prefab.js").Prefab} Prefab
+ * @typedef {import("../../../shade/renderer/animation/Skin.js").Skin} Skin
+ */
+
+const _inverse_frame = new Float64Array(16);
+const _joint_matrix = new Float64Array(16);
+const _folded = new Float64Array(16);
+
+/**
+ * A joint's skinning matrix at the prefab's rest pose: the joint's world under the root, times
+ * its inverse-bind matrix. What the skin matrix prep pass computes on the GPU from the row's
+ * `global`, computed here from the prefab's own composition.
+ *
+ * @param {Float64Array} out
+ * @param {Prefab} prefab
+ * @param {Skin} skin joints as node indices
+ * @param {number} joint_index
+ * @returns {Float64Array} `out`
+ */
+export function prefab_skin_joint_matrix(out, prefab, skin, joint_index) {
+    assert.isArrayLike(out, 'out');
+    assert.defined(prefab, 'prefab');
+    assert.defined(skin, 'skin');
+    assert.isNonNegativeInteger(joint_index, 'joint_index');
+    assert.lessThan(joint_index, skin.joints.length, 'joint_index');
+
+    const offset = joint_index * 16;
+
+    assert.greaterThanOrEqual(
+        skin.inverse_bind_matrices.length, offset + 16,
+        'skin.inverse_bind_matrices.length'
+    );
+
+    return m4_multiply(
+        out,
+        prefab.world[skin.joints[joint_index]],
+        skin.inverse_bind_matrices.subarray(offset, offset + 16)
+    );
+}
+
+/**
+ * The frame a skin's meshes are deformed in: its first joint's skinning matrix at rest. For a
+ * skin whose rest pose is rigid every joint gives the same answer, and the first is as good as any.
+ *
+ * @param {Float64Array} out
+ * @param {Prefab} prefab
+ * @param {Skin} skin
+ * @returns {Float64Array} `out`
+ */
+export function prefab_skin_bind_transform(out, prefab, skin) {
+    assert.greaterThanOrEqual(skin.joints.length, 1, 'skin.joints.length');
+
+    return prefab_skin_joint_matrix(out, prefab, skin, 0);
+}
+
+/**
+ * How far a skin is from being deformable in `frame`: the worst rigidity defect of
+ * `inverse(frame) × joint.world × inverse_bind` over its joints, at rest. Zero for a skin that
+ * folds rigidly, `Infinity` for a frame with no inverse or a joint that reflects.
+ *
+ * A reflection scores perfectly on orthonormality, which is why it is caught by its determinant
+ * rather than by the defect: a dual quaternion would answer it with a rotation, silently, which is
+ * precisely the class of failure this exists to end.
+ *
+ * @param {Prefab} prefab
+ * @param {Skin} skin
+ * @param {ArrayLike<number>} frame
+ * @returns {number}
+ */
+export function prefab_skin_frame_defect(prefab, skin, frame) {
+    assert.isArrayLike(frame, 'frame');
+
+    if (!m4_invert(_inverse_frame, frame)) {
+        return Infinity;
+    }
+
+    const joint_count = skin.joints.length;
+
+    let worst = 0;
+
+    for (let j = 0; j < joint_count; j++) {
+        prefab_skin_joint_matrix(_joint_matrix, prefab, skin, j);
+
+        m4_multiply(_folded, _inverse_frame, _joint_matrix);
+
+        if (m4_linear_determinant(_folded) < 0) {
+            return Infinity;
+        }
+
+        const defect = m4_rigidity_defect(_folded);
+
+        if (defect > worst) {
+            worst = defect;
+        }
+    }
+
+    return worst;
+}
+
+/**
+ * @param {ArrayLike<number>} mat4
+ * @returns {number}
+ */
+function m4_linear_determinant(mat4) {
+    const a = mat4[0], b = mat4[4], c = mat4[8];
+    const d = mat4[1], e = mat4[5], f = mat4[9];
+    const g = mat4[2], h = mat4[6], i = mat4[10];
+
+    return a * (e * i - f * h) - b * (d * i - f * g) + c * (d * h - e * g);
+}

package/src/engine/graphics3/preview/make_model_preview_scene.d.ts

@@ -2,34 +2,36 @@
  * A scene holding one model and the light to see it by, and a camera framed on it.
  *
  * **The bundle is read, never moved.** A loaded model is shared — the asset manager hands the same
- * `SceneBundle` to everything that places it — so a preview that scaled the bundle's own roots to
+ * `SceneBundle` to everything that places it — so a preview that scaled the bundle's own nodes to
  * fit an icon would scale every copy of that model in the world. What goes into the preview scene
- * is a fresh `Mesh` per drawing node, over the *same* geometry and the *same* material, placed at
- * the node's own global transform under a root carrying the framing.
+ * is a placement of the model compiled as a prefab: entities over the *same* geometry and the
+ * *same* material, under a root carrying the framing, each holding a row of the scene's context.
  *
- * **A skinned mesh does not come across**, the same boundary `shade_node_to_entity_composition`
- * draws: its vertices are deformed against a skeleton the renderer poses, and a preview scene has
- * registered no skin. A model that is nothing but skinned meshes therefore previews as an empty
- * frame, which is what `false` says.
+ * **A skinned mesh does not come across**: its vertices are deformed against a skeleton the
+ * renderer poses, and a preview scene has registered no skin. A model that is nothing but skinned
+ * meshes therefore previews as an empty frame, which is what `drawn === 0` says.
  *
+ * @param {GraphicsEngine} graphics what draws it — the scene's rows live on its context
  * @param {SceneBundle} bundle
  * @param {ModelPreviewFraming} framing as `model_preview_framing` answered for this bundle
  * @param {number} aspect_ratio width over height of the picture
- * @returns {{scene: Scene, camera: PerspectiveCamera, drawn: number}} `drawn` is how many meshes
- * the preview holds; zero means there is nothing to look at
+ * @returns {{scene: Scene, camera: PerspectiveCamera, drawn: number}} `drawn` is how many
+ * primitives the preview holds; zero means there is nothing to look at
  */
-export function make_model_preview_scene(bundle: SceneBundle, framing: ModelPreviewFraming, aspect_ratio: number): {
+export function make_model_preview_scene(graphics: GraphicsEngine, bundle: SceneBundle, framing: ModelPreviewFraming, aspect_ratio: number): {
     scene: Scene;
     camera: PerspectiveCamera;
     drawn: number;
 };
 /**
- * Vertical field of view a preview is drawn with, radians. Narrow enough that a model does not bend
- * at its edges and wide enough that it is not an orthographic projection in disguise.
- *
- * @type {number}
+ * @typedef {import("../../../shade/renderer/loader/SceneBundle.js").SceneBundle} SceneBundle
+ * @typedef {import("./ModelPreviewFraming.js").ModelPreviewFraming} ModelPreviewFraming
+ * @typedef {import("../GraphicsEngine.js").GraphicsEngine} GraphicsEngine
  */
 export const MODEL_PREVIEW_FOV: number;
+export type SceneBundle = import("../../../shade/renderer/loader/SceneBundle.js").SceneBundle;
+export type ModelPreviewFraming = import("./ModelPreviewFraming.js").ModelPreviewFraming;
+export type GraphicsEngine = import("../GraphicsEngine.js").GraphicsEngine;
 import { Scene } from "../../../shade/renderer/scene/Scene.js";
 import { PerspectiveCamera } from "../../../shade/renderer/camera/PerspectiveCamera.js";
 //# sourceMappingURL=make_model_preview_scene.d.ts.map

package/src/engine/graphics3/preview/make_model_preview_scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"make_model_preview_scene.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/preview/make_model_preview_scene.js"],"names":[],"mappings":"AAoEA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,0GAJW,MAAM,GACJ;IAAC,KAAK,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,iBAAiB,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAoEpE;AAhJD;;;;;GAKG;AACH,gCAFU,MAAM,CAEoC;sBAR9B,wCAAwC;kCAJ5B,qDAAqD"}
+{"version":3,"file":"make_model_preview_scene.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/preview/make_model_preview_scene.js"],"names":[],"mappings":"AAyDA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,mDAPW,cAAc,UACd,WAAW,WACX,mBAAmB,gBACnB,MAAM,GACJ;IAAC,KAAK,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,iBAAiB,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAmDpE;AAjHD;;;;GAIG;AAEH,uCAAoD;0BALvC,OAAO,+CAA+C,EAAE,WAAW;kCACnE,OAAO,0BAA0B,EAAE,mBAAmB;6BACtD,OAAO,sBAAsB,EAAE,cAAc;sBAPpC,wCAAwC;kCAL5B,qDAAqD"}

package/src/engine/graphics3/preview/make_model_preview_scene.js

@@ -1,154 +1,126 @@
-import { assert } from "../../../core/assert.js";
-import Quaternion from "../../../core/geom/Quaternion.js";
-import Vector3 from "../../../core/geom/Vector3.js";
-import { PerspectiveCamera } from "../../../shade/renderer/camera/PerspectiveCamera.js";
-import { DirectionalLight } from "../../../shade/renderer/light/model/DirectionalLight.js";
-import { Mesh } from "../../../shade/renderer/scene/Mesh.js";
-import { Node3D } from "../../../shade/renderer/scene/Node3D.js";
-import { Scene } from "../../../shade/renderer/scene/Scene.js";
-
-/**
- * Vertical field of view a preview is drawn with, radians. Narrow enough that a model does not bend
- * at its edges and wide enough that it is not an orthographic projection in disguise.
- *
- * @type {number}
- */
-export const MODEL_PREVIEW_FOV = 45 * Math.PI / 180;
-
-/**
- * The lights a preview is lit by: a direction to point each one in, and its strength.
- *
- * A key from over the viewer's shoulder, a weaker one straight down the view axis so the side
- * facing us is not read off the key alone, and a dim one from behind and below so a silhouette does
- * not close up into black.
- *
- * **There is no ambient term.** Shade takes ambient from the environment map, and a preview scene
- * has none: an icon of a model is a picture of the model, not of a place it would stand in.
- *
- * @type {{direction: number[], intensity: number}[]}
- */
-const LIGHTS = [
-    { direction: [1, -1, 1], intensity: 3 },
-    { direction: [0, 0, 1], intensity: 1.5 },
-    { direction: [-0.5, 1, -0.5], intensity: 0.6 }
-];
-
-const scratch_rotation = new Quaternion();
-const scratch_direction = new Vector3();
-const scratch_target = new Vector3(0, 0, 0);
-
-/**
- * @param {number[]} direction
- * @param {number} intensity
- * @returns {DirectionalLight}
- */
-function makeLight(direction, intensity) {
-    const light = new DirectionalLight();
-
-    // a preview is one object over nothing; a shadow has nothing to fall on and costs an atlas
-    light.casts_shadow = false;
-    light.intensity = intensity;
-
-    scratch_direction.set(direction[0], direction[1], direction[2]).normalize();
-
-    scratch_rotation.fromUnitVectors(Vector3.forward, scratch_direction);
-    scratch_rotation.normalize();
-
-    light.transform_local.setRotation(
-        scratch_rotation.x,
-        scratch_rotation.y,
-        scratch_rotation.z,
-        scratch_rotation.w
-    );
-
-    light.updateMatrices();
-
-    return light;
-}
-
-/**
- * A scene holding one model and the light to see it by, and a camera framed on it.
- *
- * **The bundle is read, never moved.** A loaded model is shared — the asset manager hands the same
- * `SceneBundle` to everything that places it — so a preview that scaled the bundle's own roots to
- * fit an icon would scale every copy of that model in the world. What goes into the preview scene
- * is a fresh `Mesh` per drawing node, over the *same* geometry and the *same* material, placed at
- * the node's own global transform under a root carrying the framing.
- *
- * **A skinned mesh does not come across**, the same boundary `shade_node_to_entity_composition`
- * draws: its vertices are deformed against a skeleton the renderer poses, and a preview scene has
- * registered no skin. A model that is nothing but skinned meshes therefore previews as an empty
- * frame, which is what `false` says.
- *
- * @param {SceneBundle} bundle
- * @param {ModelPreviewFraming} framing as `model_preview_framing` answered for this bundle
- * @param {number} aspect_ratio width over height of the picture
- * @returns {{scene: Scene, camera: PerspectiveCamera, drawn: number}} `drawn` is how many meshes
- * the preview holds; zero means there is nothing to look at
- */
-export function make_model_preview_scene(bundle, framing, aspect_ratio) {
-    assert.defined(bundle, 'bundle');
-    assert.defined(framing, 'framing');
-    assert.greaterThan(aspect_ratio, 0, 'aspect_ratio');
-
-    const scene = new Scene();
-
-    const root = new Node3D();
-
-    const scale = framing.scale;
-    const offset = framing.offset;
-
-    root.transform_local.setScale(scale, scale, scale);
-    root.transform_local.setTranslation(offset.x, offset.y, offset.z);
-
-    let drawn = 0;
-
-    const scenes = bundle.scenes;
-
-    for (let i = 0; i < scenes.length; i++) {
-        scenes[i].updateMatrices();
-
-        scenes[i].traverse(node => {
-            if (node.isMesh !== true || node.isSkinnedMesh === true) {
-                return;
-            }
-
-            const copy = Mesh.from(node.geometry, node.material);
-
-            copy.name = node.name;
-            copy.transform_local.copy(node.transform_global);
-
-            root.addChild(copy);
-
-            drawn++;
-        });
-    }
-
-    root.updateMatrices();
-
-    scene.add(root);
-
-    for (let i = 0; i < LIGHTS.length; i++) {
-        scene.add(makeLight(LIGHTS[i].direction, LIGHTS[i].intensity));
-    }
-
-    const camera = new PerspectiveCamera();
-
-    camera.fov = MODEL_PREVIEW_FOV;
-    camera.aspect = aspect_ratio;
-    camera.near = 0.01;
-    camera.far = framing.camera_distance * 4 + 4;
-
-    /*
-     Which side the camera stands on is the renderer's convention, and this is where it is applied:
-     Shade's own samples put a camera at negative Z looking back at the origin, so that is where a
-     preview's camera stands.
-    */
-    camera.transform.setTranslation(0, 0, -framing.camera_distance);
-
-    camera.transform.lookAt(scratch_target);
-
-    camera.update_matrices();
-
-    return { scene, camera, drawn };
-}
+import { assert } from "../../../core/assert.js";
+import Quaternion from "../../../core/geom/Quaternion.js";
+import Vector3 from "../../../core/geom/Vector3.js";
+import { PerspectiveCamera } from "../../../shade/renderer/camera/PerspectiveCamera.js";
+import { EntityComponentDataset } from "../../ecs/EntityComponentDataset.js";
+import { Transform64 } from "../../ecs/transform/Transform64.js";
+import { DirectionalLight } from "../../../shade/renderer/light/model/DirectionalLight.js";
+import { place_light } from "../../../shade/renderer/light/place_light.js";
+import { Scene } from "../../../shade/renderer/scene/Scene.js";
+import { prefab_compile } from "../prefab/prefab_compile.js";
+import { prefab_place } from "../prefab/prefab_place.js";
+
+/**
+ * @typedef {import("../../../shade/renderer/loader/SceneBundle.js").SceneBundle} SceneBundle
+ * @typedef {import("./ModelPreviewFraming.js").ModelPreviewFraming} ModelPreviewFraming
+ * @typedef {import("../GraphicsEngine.js").GraphicsEngine} GraphicsEngine
+ */
+
+export const MODEL_PREVIEW_FOV = 45 * Math.PI / 180;
+
+const LIGHTS = [
+    { direction: [1, -1, 1], intensity: 3 },
+    { direction: [0, 0, 1], intensity: 1.5 },
+    { direction: [-0.5, 1, -0.5], intensity: 0.6 }
+];
+
+const scratch_rotation = new Quaternion();
+const scratch_direction = new Vector3();
+const scratch_target = new Vector3(0, 0, 0);
+
+/**
+ * @param {number[]} direction
+ * @param {number} intensity
+ * @returns {DirectionalLight}
+ */
+function makeLight(direction, intensity) {
+    const light = new DirectionalLight();
+
+    // a preview is one object over nothing; a shadow has nothing to fall on and costs an atlas
+    light.casts_shadow = false;
+    light.intensity = intensity;
+
+    scratch_direction.set(direction[0], direction[1], direction[2]).normalize();
+    scratch_rotation.fromUnitVectors(Vector3.forward, scratch_direction);
+    scratch_rotation.normalize();
+
+    light.transform.setRotation(
+        scratch_rotation.x,
+        scratch_rotation.y,
+        scratch_rotation.z,
+        scratch_rotation.w
+    );
+    light.transform.updateMatrix();
+
+    return light;
+}
+
+/**
+ * A scene holding one model and the light to see it by, and a camera framed on it.
+ *
+ * **The bundle is read, never moved.** A loaded model is shared — the asset manager hands the same
+ * `SceneBundle` to everything that places it — so a preview that scaled the bundle's own nodes to
+ * fit an icon would scale every copy of that model in the world. What goes into the preview scene
+ * is a placement of the model compiled as a prefab: entities over the *same* geometry and the
+ * *same* material, under a root carrying the framing, each holding a row of the scene's context.
+ *
+ * **A skinned mesh does not come across**: its vertices are deformed against a skeleton the
+ * renderer poses, and a preview scene has registered no skin. A model that is nothing but skinned
+ * meshes therefore previews as an empty frame, which is what `drawn === 0` says.
+ *
+ * @param {GraphicsEngine} graphics what draws it — the scene's rows live on its context
+ * @param {SceneBundle} bundle
+ * @param {ModelPreviewFraming} framing as `model_preview_framing` answered for this bundle
+ * @param {number} aspect_ratio width over height of the picture
+ * @returns {{scene: Scene, camera: PerspectiveCamera, drawn: number}} `drawn` is how many
+ * primitives the preview holds; zero means there is nothing to look at
+ */
+export function make_model_preview_scene(graphics, bundle, framing, aspect_ratio) {
+    assert.defined(graphics, 'graphics');
+    assert.defined(bundle, 'bundle');
+    assert.equal(bundle.isSceneBundle, true, 'bundle.isSceneBundle !== true');
+    assert.defined(framing, 'framing');
+    assert.greaterThan(aspect_ratio, 0, 'aspect_ratio');
+
+    const scene = new Scene();
+
+    // the model and the lights are entities; a dataset with no systems is a map of components,
+    // which is all a preview wants
+    scene.dataset = new EntityComponentDataset();
+
+    const scale = framing.scale;
+    const offset = framing.offset;
+
+    const placement = new Transform64();
+
+    placement.setScale(scale, scale, scale);
+    placement.setTranslation(offset.x, offset.y, offset.z);
+    placement.updateMatrix();
+
+    const { drawn } = prefab_place(graphics.scene_context(scene), scene.dataset, prefab_compile(bundle), placement, {
+        register_animation: false,
+        skinned: false,
+    });
+
+    for (let i = 0; i < LIGHTS.length; i++) {
+        place_light(scene, makeLight(LIGHTS[i].direction, LIGHTS[i].intensity));
+    }
+
+    const camera = new PerspectiveCamera();
+
+    camera.fov = MODEL_PREVIEW_FOV;
+    camera.aspect = aspect_ratio;
+    camera.near = 0.01;
+    camera.far = framing.camera_distance * 4 + 4;
+
+    /*
+     Which side the camera stands on is the renderer's convention, and this is where it is applied:
+     Shade's own samples put a camera at negative Z looking back at the origin, so that is where a
+     preview's camera stands.
+    */
+    camera.transform.setTranslation(0, 0, -framing.camera_distance);
+    camera.transform.lookAt(scratch_target);
+    camera.update_matrices();
+
+    return { scene, camera, drawn };
+}

package/src/engine/graphics3/preview/make_model_thumbnail.js

@@ -38,7 +38,7 @@ export async function make_model_thumbnail(graphics, bundle, width, height, marg
 
     const framing = model_preview_framing(new ModelPreviewFraming(), bounds, MODEL_PREVIEW_FOV, margin);
 
-    const { scene, camera, drawn } = make_model_preview_scene(bundle, framing, width / height);
+    const { scene, camera, drawn } = make_model_preview_scene(graphics, bundle, framing, width / height);
 
     if (drawn === 0) {
         return null;

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

@@ -7,14 +7,14 @@
  * every joint has a row in the scene. Until then the skin is inert rather than wrong: no
  * deformation runs.
  *
- * The instance's nodes therefore do **not** have to be in the scene yet.
+ * 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 {SceneBundleInstance} instance
+ * @param {PrefabInstance} instance its skins name joint and mesh entities
  * @returns {InstanceAnimationRegistration}
  */
-export function register_instance_animation(context: GPUSceneContext, instance: SceneBundleInstance): 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.
@@ -42,11 +42,11 @@ export function unregister_instance_animation(registration: InstanceAnimationReg
  * add together.
  *
  * @param {GPUSceneContext} context
- * @param {SceneBundleInstance} instance
+ * @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: SceneBundleInstance, slots: ArrayLike<number>): 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.
@@ -55,7 +55,7 @@ export function register_instance_clips(context: GPUSceneContext, instance: Scen
  */
 export function unregister_instance_clips(registration: InstanceClipRegistration): void;
 /**
- * What the animation manager handed back for one {@link SceneBundleInstance}'s **skins**.
+ * What the animation manager handed back for one {@link PrefabInstance}'s **skins**.
  *
  * Positional: `skins[i]` is the id of the instance's `skins[i]`.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"register_instance_animation.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/register_instance_animation.js"],"names":[],"mappings":"AAmCA;;;;;;;;;;;;;;;GAeG;AACH,sGAFa,6BAA6B,CAmBzC;AAED;;;;;;;;;;;GAWG;AACH,4DAFW,6BAA6B,QAevC;AA+BD;;;;;;;;;;;;;;;;;GAiBG;AACH,wGAHW,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"}
+{"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,7 +1,7 @@
 import { assert } from "../../core/assert.js";
 
 /**
- * What the animation manager handed back for one {@link SceneBundleInstance}'s **skins**.
+ * What the animation manager handed back for one {@link PrefabInstance}'s **skins**.
  *
  * Positional: `skins[i]` is the id of the instance's `skins[i]`.
  *
@@ -42,11 +42,11 @@ export class InstanceAnimationRegistration {
  * every joint has a row in the scene. Until then the skin is inert rather than wrong: no
  * deformation runs.
  *
- * The instance's nodes therefore do **not** have to be in the scene yet.
+ * 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 {SceneBundleInstance} instance
+ * @param {PrefabInstance} instance its skins name joint and mesh entities
  * @returns {InstanceAnimationRegistration}
  */
 export function register_instance_animation(context, instance) {
@@ -138,7 +138,7 @@ export class InstanceClipRegistration {
  * add together.
  *
  * @param {GPUSceneContext} context
- * @param {SceneBundleInstance} instance
+ * @param {PrefabInstance} instance its clips target entities
  * @param {ArrayLike<number>} slots indices into `instance.clips`; duplicates are ignored
  * @returns {InstanceClipRegistration}
  */

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

@@ -1,10 +1,6 @@
 /**
- * The box a loaded model occupies, in the model's own space.
- *
- * **Matrices are refreshed here.** A `Mesh`'s `bounding_box` is its geometry's box projected
- * through its global transform, and a bundle handed straight off a loader has never had
- * {@link Node3D.updateMatrices} run on it — so asking for the bounds without refreshing them reads
- * whatever the loader left, which for a node under a transformed parent is the wrong box.
+ * The box a loaded model occupies, in the model's own space: every primitive's geometry box
+ * under its node's world transform, composed here from the bundle's locals.
  *
  * A bundle with no geometry in it — a file that is all empties, or a scene that is only lights —
  * has no bounds, and that is what `false` says. `result` is untouched then.

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

@@ -1 +1 @@
-{"version":3,"file":"shade_bundle_bounds.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/shade_bundle_bounds.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH,yEAFa,OAAO,CAsCnB"}
+{"version":3,"file":"shade_bundle_bounds.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/shade_bundle_bounds.js"],"names":[],"mappings":"AAMA;;;;;;;;;;GAUG;AACH,yEAFa,OAAO,CA+BnB"}