@woosh/meep-engine 3.23.0 → 3.24.0

package/src/engine/graphics3/shade_bundle_bounds.js

@@ -1,55 +1,47 @@
-import { assert } from "../../core/assert.js";
-import { aabb3_array_combine } from "../../core/geom/3d/aabb/aabb3_array_combine.js";
-
-/**
- * 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.
- *
- * 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.
- *
- * @param {AABB3} result
- * @param {SceneBundle} bundle
- * @returns {boolean} whether the bundle had any geometry to bound
- */
-export function shade_bundle_bounds(result, bundle) {
-    assert.defined(result, 'result');
-    assert.defined(bundle, 'bundle');
-
-    let found = false;
-
-    /**
-     * @param {Mesh} node
-     */
-    function combine(node) {
-        if (node.isMesh !== true) {
-            // a grouping node carries no geometry, so it has no bounds of its own
-            return;
-        }
-
-        const bounds = node.bounding_box;
-
-        if (found) {
-            aabb3_array_combine(result, 0, result, 0, bounds, 0);
-        } else {
-            result.setBounds(bounds[0], bounds[1], bounds[2], bounds[3], bounds[4], bounds[5]);
-
-            found = true;
-        }
-    }
-
-    const scenes = bundle.scenes;
-
-    for (let i = 0; i < scenes.length; i++) {
-        const root = scenes[i];
-
-        root.updateMatrices();
-        root.traverse(combine);
-    }
-
-    return found;
-}
+import { assert } from "../../core/assert.js";
+import { aabb3_array_combine } from "../../core/geom/3d/aabb/aabb3_array_combine.js";
+import { aabb3_matrix4_project } from "../../core/geom/3d/aabb/aabb3_matrix4_project.js";
+
+const SCRATCH_BOX = new Float64Array(6);
+
+/**
+ * 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.
+ *
+ * @param {AABB3} result
+ * @param {SceneBundle} bundle
+ * @returns {boolean} whether the bundle had any geometry to bound
+ */
+export function shade_bundle_bounds(result, bundle) {
+    assert.defined(result, 'result');
+    assert.defined(bundle, 'bundle');
+    assert.equal(bundle.isSceneBundle, true, 'bundle.isSceneBundle !== true');
+
+    const nodes = bundle.nodes;
+    const worlds = bundle.compute_world_matrices();
+
+    let found = false;
+
+    for (let i = 0; i < nodes.length; i++) {
+        const geometry = nodes[i].geometry;
+
+        if (geometry === null) {
+            // a grouping node carries no geometry, so it has no bounds of its own
+            continue;
+        }
+
+        aabb3_matrix4_project(SCRATCH_BOX, geometry.bounding_box, worlds[i]);
+
+        if (found) {
+            aabb3_array_combine(result, 0, result, 0, SCRATCH_BOX, 0);
+        } else {
+            result.setBounds(SCRATCH_BOX[0], SCRATCH_BOX[1], SCRATCH_BOX[2], SCRATCH_BOX[3], SCRATCH_BOX[4], SCRATCH_BOX[5]);
+            found = true;
+        }
+    }
+
+    return found;
+}

package/src/engine/graphics3/terrain/pack_terrain_row_table.d.ts

@@ -1,26 +1,19 @@
 /**
- * Build the lookup the splat shader reads: one word per mesh row, 1 where the row is one of this
- * terrain's tiles, addressed by the row the visibility buffer writes.
+ * The lookup the splat pass reads a visibility-buffer mesh row through: one word per row, 1 for a
+ * row that is a tile of this terrain, 0 for anything else.
  *
- * **The scene decides the indices** — a tile that has not reached the scene database yet has no
- * row and contributes nothing, which is also what makes "no tile drawn yet" read as an empty
- * table rather than an error. Rebuilt per frame like the highlight table, and for the same
- * reason: rows move as the scene streams, and the walk is over this terrain's few tiles rather
- * than over the scene.
+ * A tile is an entity, and its row is the entity's, one on — so the table is sized by the highest
+ * tile entity and the rows in between belong to whatever else the level holds. Whether a row has
+ * been written yet is not this table's business: a row the scene has not placed is in no pixel of
+ * the visibility buffer, and marking it costs nothing.
  *
  * @param {object} args
- * @param {{values(): Iterable<Mesh>}} args.meshes the terrain's tile meshes, e.g. the entry's
- * `Map<TerrainTile, Mesh>`
- * @param {GPUSceneContext} args.scene resolves a node to its row
- * @param {Uint32Array} args.table reused between frames; replaced when it is too small
- * @returns {{table: Uint32Array, size: number}} `size` is one past the highest row written, and
- * zero when no tile is in the scene
+ * @param {Map<*, number>} args.tiles the terrain's tile entities, by whatever spawned them
+ * @param {Uint32Array} args.table the previous frame's table, reused when it is long enough
+ * @returns {{table: Uint32Array, size: number}} the table and how much of it is meaningful
  */
-export function pack_terrain_row_table({ meshes, scene, table }: {
-    meshes: {
-        values(): Iterable<Mesh>;
-    };
-    scene: GPUSceneContext;
+export function pack_terrain_row_table({ tiles, table }: {
+    tiles: Map<any, number>;
     table: Uint32Array;
 }): {
     table: Uint32Array;

package/src/engine/graphics3/terrain/pack_terrain_row_table.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pack_terrain_row_table.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/terrain/pack_terrain_row_table.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH;IAP4C,MAAM,EAAvC;QAAC,MAAM,IAAI,cAAc,CAAA;KAAC;IAEJ,KAAK;IACT,KAAK,EAAvB,WAAW;IACT;IAAC,KAAK,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAqC9C"}
+{"version":3,"file":"pack_terrain_row_table.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/terrain/pack_terrain_row_table.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH;IAJgC,KAAK,EAA1B,SAAO,MAAM,CAAC;IACI,KAAK,EAAvB,WAAW;IACT;IAAC,KAAK,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAiC9C"}

package/src/engine/graphics3/terrain/pack_terrain_row_table.js

@@ -1,53 +1,48 @@
-/**
- * Build the lookup the splat shader reads: one word per mesh row, 1 where the row is one of this
- * terrain's tiles, addressed by the row the visibility buffer writes.
- *
- * **The scene decides the indices** — a tile that has not reached the scene database yet has no
- * row and contributes nothing, which is also what makes "no tile drawn yet" read as an empty
- * table rather than an error. Rebuilt per frame like the highlight table, and for the same
- * reason: rows move as the scene streams, and the walk is over this terrain's few tiles rather
- * than over the scene.
- *
- * @param {object} args
- * @param {{values(): Iterable<Mesh>}} args.meshes the terrain's tile meshes, e.g. the entry's
- * `Map<TerrainTile, Mesh>`
- * @param {GPUSceneContext} args.scene resolves a node to its row
- * @param {Uint32Array} args.table reused between frames; replaced when it is too small
- * @returns {{table: Uint32Array, size: number}} `size` is one past the highest row written, and
- * zero when no tile is in the scene
- */
-export function pack_terrain_row_table({ meshes, scene, table }) {
-    let highest = -1;
-
-    /*
-     Two sweeps, because the table has to be as long as the highest row before anything can be
-     written into it. Asking twice is cheaper than growing a typed array mid-walk.
-    */
-    for (const mesh of meshes.values()) {
-        const row = scene.mesh_row_of(mesh);
-
-        if (row > highest) {
-            highest = row;
-        }
-    }
-
-    const size = highest + 1;
-
-    let result = table;
-
-    if (result.length < size) {
-        result = new Uint32Array(size);
-    } else {
-        result.fill(0, 0, size);
-    }
-
-    for (const mesh of meshes.values()) {
-        const row = scene.mesh_row_of(mesh);
-
-        if (row >= 0) {
-            result[row] = 1;
-        }
-    }
-
-    return { table: result, size };
-}
+import { row_of_entity } from "../../../shade/renderer/scene/rows/GPUSceneRows.js";
+
+/**
+ * The lookup the splat pass reads a visibility-buffer mesh row through: one word per row, 1 for a
+ * row that is a tile of this terrain, 0 for anything else.
+ *
+ * A tile is an entity, and its row is the entity's, one on — so the table is sized by the highest
+ * tile entity and the rows in between belong to whatever else the level holds. Whether a row has
+ * been written yet is not this table's business: a row the scene has not placed is in no pixel of
+ * the visibility buffer, and marking it costs nothing.
+ *
+ * @param {object} args
+ * @param {Map<*, number>} args.tiles the terrain's tile entities, by whatever spawned them
+ * @param {Uint32Array} args.table the previous frame's table, reused when it is long enough
+ * @returns {{table: Uint32Array, size: number}} the table and how much of it is meaningful
+ */
+export function pack_terrain_row_table({ tiles, table }) {
+    let highest = -1;
+
+    /*
+     Two sweeps, because the table has to be as long as the highest row before anything can be
+     written into it. Asking twice is cheaper than growing a typed array mid-walk — and is why this
+     takes the map rather than an iterator, which would be spent by the first.
+    */
+    for (const tile of tiles.values()) {
+        const row = row_of_entity(tile);
+
+        if (row > highest) {
+            highest = row;
+        }
+    }
+
+    const size = highest + 1;
+
+    let result = table;
+
+    if (result.length < size) {
+        result = new Uint32Array(size);
+    } else {
+        result.fill(0, 0, size);
+    }
+
+    for (const tile of tiles.values()) {
+        result[row_of_entity(tile)] = 1;
+    }
+
+    return { table: result, size };
+}

package/src/engine/physics/cloth/build/cloth_proxy_from_joints.d.ts

@@ -1,3 +1,7 @@
+/**
+ * @typedef {import("../../../graphics3/prefab/Prefab.js").Prefab} Prefab
+ * @typedef {import("../../../../shade/renderer/animation/Skin.js").Skin} Skin
+ */
 /**
  * # Building a proxy for a garment that is already rigged
  *
@@ -31,6 +35,14 @@
  * simulate in and no single fixed set — that is two garments, and nothing stops
  * a caller building two proxies.
  *
+ * ## The joint graph is the prefab's
+ *
+ * A model's hierarchy is its compiled prefab: parent indices, names and rest
+ * poses per node, fixed for every placement. The skin handed in is one of the
+ * prefab's — joints as node indices — and what comes back holds indices into
+ * that skin's joints, which is what a placement's own skin (joints as entities)
+ * is indexed by too. Built once per model, like the prefab.
+ *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
@@ -46,16 +58,19 @@
  * step 8) and they do not survive: what comes back holds indices into
  * `skin.joints`.
  *
- * @param {Skin} skin the instance's skin, or the asset's — the joint *order* is
+ * @param {Prefab} prefab the compiled model whose hierarchy the joints are nodes of
+ * @param {Skin} skin one of the prefab's skins — joints as node indices. The joint *order* is
  *   what is read, and instantiation preserves it
  * @param {string[]} joint_names the garment's own joints, in any order
  * @param {object} [options]
  * @param {string} [options.name]
  * @returns {ClothProxyBuildResult}
  */
-export function cloth_proxy_from_joints(skin: Skin, joint_names: string[], { name }?: {
+export function cloth_proxy_from_joints(prefab: Prefab, skin: Skin, joint_names: string[], { name }?: {
     name?: string;
 }): ClothProxyBuildResult;
+export type Prefab = import("../../../graphics3/prefab/Prefab.js").Prefab;
+export type Skin = import("../../../../shade/renderer/animation/Skin.js").Skin;
 export type ClothProxyBuildResult = {
     /**
      * `null` when the build refused

package/src/engine/physics/cloth/build/cloth_proxy_from_joints.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloth_proxy_from_joints.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/build/cloth_proxy_from_joints.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;GAaG;AACH,iEALW,MAAM,EAAE;IAES,IAAI,GAArB,MAAM;IACJ,qBAAqB,CAyLjC;;;;;WAzMa,UAAU,GAAC,IAAI;;;;WACf,MAAM;;2BA1CO,iBAAiB"}
+{"version":3,"file":"cloth_proxy_from_joints.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/build/cloth_proxy_from_joints.js"],"names":[],"mappings":"AAMA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;;GAcG;AACH,gDARW,MAAM,QACN,IAAI,eAEJ,MAAM,EAAE;IAES,IAAI,GAArB,MAAM;IACJ,qBAAqB,CAwMjC;qBA5QY,OAAO,qCAAqC,EAAE,MAAM;mBACpD,OAAO,8CAA8C,EAAE,IAAI;;;;;WAkD1D,UAAU,GAAC,IAAI;;;;WACf,MAAM;;2BAvDO,iBAAiB"}