@woosh/meep-engine 3.23.0 → 3.25.0

package/src/shade/renderer/loader/usd/usd_build_scene.d.ts

@@ -12,14 +12,14 @@
  *
  * @param {Object.<string, { specType: number, fields: Object }>} specs_by_path
  * @param {UsdBuildOptions} [options]
- * @returns {Node3D[]} Root-level nodes
+ * @returns {SceneBundle} the model's nodes, in pre-order; no skins and no clips, which UsdSkel would fill in
  */
 export function usd_build_scene(specs_by_path: {
     [x: string]: {
         specType: number;
         fields: any;
     };
-}, options?: UsdBuildOptions): Node3D[];
+}, options?: UsdBuildOptions): SceneBundle;
 export type UsdBuildOptions = {
     /**
      * - Map of relative paths to file data (from USDZ)
@@ -30,5 +30,5 @@ export type UsdBuildOptions = {
      */
     extensions?: import("./UsdExtensionRegistry.js").UsdExtensionRegistry;
 };
-import { Node3D } from "../../scene/Node3D.js";
+import { SceneBundle } from "../SceneBundle.js";
 //# sourceMappingURL=usd_build_scene.d.ts.map

package/src/shade/renderer/loader/usd/usd_build_scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"usd_build_scene.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/usd/usd_build_scene.js"],"names":[],"mappings":"AAkCA;;;;GAIG;AAGH;;;;;;;;;;GAUG;AACH;QAJmB,MAAM,GAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,MAAQ;KAAE;aACpD,eAAe,GACb,MAAM,EAAE,CAqEpB;;;;;iBAnFa,IAAI,MAAM,EAAE,UAAU,CAAC;;;;iBACvB,OAAO,2BAA2B,EAAE,oBAAoB;;uBAR/C,uBAAuB"}
+{"version":3,"file":"usd_build_scene.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/usd/usd_build_scene.js"],"names":[],"mappings":"AAkCA;;;;GAIG;AAGH;;;;;;;;;;GAUG;AACH;QAJmB,MAAM,GAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,MAAQ;KAAE;aACpD,eAAe,GACb,WAAW,CA8DvB;;;;;iBA5Ea,IAAI,MAAM,EAAE,UAAU,CAAC;;;;iBACvB,OAAO,2BAA2B,EAAE,oBAAoB;;4BAV1C,mBAAmB"}

package/src/shade/renderer/loader/usd/usd_build_scene.js

@@ -1,6 +1,6 @@
 /**
  * Converts the unified `specsByPath` intermediate representation into
- * the engine's scene graph (Node3D, Mesh, StandardShadeMaterial).
+ * a loader's bundle: nodes in pre-order (SceneNode), materials (StandardShadeMaterial).
  *
  * This module is format-agnostic — it consumes the same specsByPath
  * dictionary regardless of whether the source was USDA, USDC, or USDZ.
@@ -25,9 +25,9 @@ import { StandardAttributes } from "../../geometry/StandardAttributes.js";
 import { normalize_attribute } from "../../geometry/util/normalize_attribute.js";
 import { ShadeDrawSide } from "../../material/ShadeDrawSide.js";
 import { StandardShadeMaterial } from "../../material/StandardShadeMaterial.js";
+import { SceneBundle } from "../SceneBundle.js";
+import { SceneNode } from "../SceneNode.js";
 import { TransparencyMode } from "../../material/TransparencyMode.js";
-import { Mesh } from "../../scene/Mesh.js";
-import { Node3D } from "../../scene/Node3D.js";
 import { usd_compose_transform } from "../../../../format/scene/usd/usd_compose_transform.js";
 import { usd_expand_face_varying, usd_triangulate } from "../../../../format/scene/usd/usd_triangulate.js";
 
@@ -48,7 +48,7 @@ import { usd_expand_face_varying, usd_triangulate } from "../../../../format/sce
  *
  * @param {Object.<string, { specType: number, fields: Object }>} specs_by_path
  * @param {UsdBuildOptions} [options]
- * @returns {Node3D[]} Root-level nodes
+ * @returns {SceneBundle} the model's nodes, in pre-order; no skins and no clips, which UsdSkel would fill in
  */
 export function usd_build_scene(specs_by_path, options = {}) {
 
@@ -89,39 +89,32 @@ export function usd_build_scene(specs_by_path, options = {}) {
 
     // --- Build prim hierarchy ---
     const prim_children = root_fields.primChildren || [];
-    const roots = [];
+    const bundle = new SceneBundle();
 
     // Check if correction is non-identity
     const has_correction = up_axis === "Z" || meters_per_unit !== 1.0;
 
     for (const child_name of prim_children) {
         const child_path = "/" + child_name;
-        const node = build_prim(child_path, specs_by_path, materials, correction, options, registry);
-
-        if (node !== null) {
-            // Bake correction into root nodes' local transforms so that
-            // updateMatrices() propagates it correctly to global transforms
-            if (has_correction) {
-                const corrected = m4_allocate();
-                m4_multiply(corrected, correction, node.transform_local.matrix);
-                node.transform_local.fromMatrix(corrected);
-            }
+        const index = build_prim(child_path, specs_by_path, materials, correction, options, registry, bundle, -1);
 
-            roots.push(node);
-        }
-    }
+        if (index !== -1 && has_correction) {
+            // Bake the correction into the roots' own transforms, so that everything under them
+            // composes it
+            const node = bundle.nodes[index];
+            const corrected = m4_allocate();
 
-    // Propagate local transforms → global transforms and compute bounds
-    for (const root of roots) {
-        root.updateMatrices();
+            m4_multiply(corrected, correction, node.local.matrix);
+            node.local.fromMatrix(corrected);
+        }
     }
 
-    return roots;
+    return bundle;
 }
 
 
 /**
- * Recursively build a Node3D from a prim spec.
+ * Recursively add a prim and what is under it to the bundle.
  *
  * @param {string} path
  * @param {Object} specs_by_path
@@ -129,14 +122,14 @@ export function usd_build_scene(specs_by_path, options = {}) {
  * @param {mat4} parent_world_transform
  * @param {UsdBuildOptions} options
  * @param {import("./UsdExtensionRegistry.js").UsdExtensionRegistry|null} registry
- * @returns {Node3D|null}
+ * @returns {number} the node's index in the bundle, or -1 for a prim that produced nothing
  */
-function build_prim(path, specs_by_path, materials, parent_world_transform, options, registry) {
+function build_prim(path, specs_by_path, materials, parent_world_transform, options, registry, bundle, parent) {
 
     const spec = specs_by_path[path];
 
     if (!spec || spec.specType !== 6) {
-        return null;
+        return -1;
     }
 
     const fields = spec.fields;
@@ -150,7 +143,10 @@ function build_prim(path, specs_by_path, materials, parent_world_transform, opti
                 const result = ext.processPrim(path, fields, { specs_by_path, materials, options });
 
                 if (result !== null && result !== undefined) {
-                    return result;
+                    // an extension answers with a record of its own, which goes under this prim's parent
+                    result.parent = parent;
+
+                    return bundle.add_node(result);
                 }
             }
         }
@@ -167,7 +163,7 @@ function build_prim(path, specs_by_path, materials, parent_world_transform, opti
     // Attempt to build a Mesh if this is a UsdGeomMesh
     // @see https://openusd.org/release/api/class_usd_geom_mesh.html
     if (type_name === "Mesh") {
-        return build_mesh_node(path, prim_name, fields, specs_by_path, materials, local_transform, world_transform, options, registry);
+        return build_mesh_node(path, prim_name, fields, specs_by_path, materials, local_transform, world_transform, options, registry, bundle, parent);
     }
 
     // Warn on unrecognized prim types that carry data we silently ignore
@@ -175,24 +171,22 @@ function build_prim(path, specs_by_path, materials, parent_world_transform, opti
         console.warn(`[USD] Unhandled prim type "${type_name}" at ${path}, treating as group node`);
     }
 
-    // For Xform, Scope, and other grouping types, create a Node3D container
-    const node = new Node3D();
+    // For Xform, Scope, and other grouping types, a node that only places its children
+    const node = new SceneNode();
     node.name = prim_name;
-    node.transform_local.fromMatrix(local_transform);
+    node.parent = parent;
+    node.local.fromMatrix(local_transform);
+
+    const index = bundle.add_node(node);
 
     // Recurse into children
     const children = fields.primChildren || [];
-
     for (const child_name of children) {
         const child_path = path + "/" + child_name;
-        const child = build_prim(child_path, specs_by_path, materials, world_transform, options, registry);
-
-        if (child !== null) {
-            node.addChild(child);
-        }
+        build_prim(child_path, specs_by_path, materials, world_transform, options, registry, bundle, index);
     }
 
-    return node;
+    return index;
 }
 
 
@@ -219,9 +213,9 @@ function build_prim(path, specs_by_path, materials, parent_world_transform, opti
  * @param {mat4} world_transform
  * @param {UsdBuildOptions} options
  * @param {import("./UsdExtensionRegistry.js").UsdExtensionRegistry|null} registry
- * @returns {Mesh|Node3D}
+ * @returns {number} the node's index in the bundle
  */
-function build_mesh_node(path, name, fields, specs_by_path, materials, local_transform, world_transform, options, registry) {
+function build_mesh_node(path, name, fields, specs_by_path, materials, local_transform, world_transform, options, registry, bundle, parent) {
 
     // --- Read topology ---
     const face_vertex_counts = read_attr(specs_by_path, path, "faceVertexCounts");
@@ -229,11 +223,12 @@ function build_mesh_node(path, name, fields, specs_by_path, materials, local_tra
     const points_raw = read_attr(specs_by_path, path, "points");
 
     if (!face_vertex_counts || !face_vertex_indices || !points_raw) {
-        // Not enough data to build a mesh — return as empty node
-        const node = new Node3D();
+        // Not enough data to build a mesh — a node that draws nothing
+        const node = new SceneNode();
         node.name = name;
-        node.transform_local.fromMatrix(local_transform);
-        return node;
+        node.parent = parent;
+        node.local.fromMatrix(local_transform);
+        return bundle.add_node(node);
     }
 
     // Validate that vertex indices are within bounds
@@ -375,30 +370,27 @@ function build_mesh_node(path, name, fields, specs_by_path, materials, local_tra
         material.draw_side = ShadeDrawSide.Double;
     }
 
-    // --- Build engine Mesh ---
+    // --- The primitive ---
     const meshlet_geo = meshlet_geometry_build_from_geometry(geometry);
-
-    const mesh = new Mesh();
+    const mesh = new SceneNode();
     mesh.name = name;
+    mesh.parent = parent;
     mesh.geometry = meshlet_geo;
     mesh.material = material;
-    mesh.transform_local.fromMatrix(local_transform);
+    mesh.local.fromMatrix(local_transform);
+
+    const index = bundle.add_node(mesh);
 
     // Recurse into children (mesh prims can have child prims)
     const children = fields.primChildren || [];
-
     if (children.length > 0) {
         for (const child_name of children) {
             const child_path = path + "/" + child_name;
-            const child = build_prim(child_path, specs_by_path, materials, world_transform, options, registry);
-
-            if (child !== null) {
-                mesh.addChild(child);
-            }
+            build_prim(child_path, specs_by_path, materials, world_transform, options, registry, bundle, index);
         }
     }
 
-    return mesh;
+    return index;
 }
 
 

package/src/shade/renderer/material/GPUMaterialManager.js

@@ -501,7 +501,7 @@ export class GPUMaterialManager {
              * @type {GPUMaterialContext[]}
              */
             const materials = [];
-            const scene_materials = view.scene.scene.instances.materials;
+            const scene_materials = view.scene.drawn_materials;
             for (const m of scene_materials) {
 
                 if (m.transparency_mode === TransparencyMode.Transparent) {

package/src/shade/renderer/material/resident/GPUResidentMaterialContext.d.ts

@@ -44,23 +44,24 @@ export class GPUResidentMaterialContext {
     build_textures(): void;
     build_materials(): void;
     /**
+     * Make every material the scene draws with resident — the list its rows keep, each once.
      *
-     * @param {Scene} scene
+     * @param {GPUSceneContext} scene_context
      */
-    ensure_scene_materials(scene: Scene): void;
+    ensure_scene_materials(scene_context: GPUSceneContext): void;
     update(): void;
     destroy(): void;
     #private;
 }
 export type GraphicsContext = import("../../GraphicsContext.js").GraphicsContext;
-export type Scene = import("../../scene/Scene.js").Scene;
+export type GPUSceneContext = import("../../scene/GPUSceneContext.js").GPUSceneContext;
 export type ShadeTexture = import("../../texture/ShadeTexture.js").ShadeTexture;
 export type ShadeMaterial = import("../ShadeMaterial.js").ShadeMaterial;
 export type StandardShadeMaterial = import("../StandardShadeMaterial.js").StandardShadeMaterial;
 import { GPUTextureContext } from "../../texture/GPUTextureContext.js";
 /**
  * @typedef {import("../../GraphicsContext.js").GraphicsContext} GraphicsContext
- * @typedef {import("../../scene/Scene.js").Scene} Scene
+ * @typedef {import("../../scene/GPUSceneContext.js").GPUSceneContext} GPUSceneContext
  * @typedef {import("../../texture/ShadeTexture.js").ShadeTexture} ShadeTexture
  * @typedef {import("../ShadeMaterial.js").ShadeMaterial} ShadeMaterial
  * @typedef {import("../StandardShadeMaterial.js").StandardShadeMaterial} StandardShadeMaterial

package/src/shade/renderer/material/resident/GPUResidentMaterialContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUResidentMaterialContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/resident/GPUResidentMaterialContext.js"],"names":[],"mappings":"AA+DA,sDAAuD;AAEvD,wDAAyD;AAEzD,+DAAiJ;AAEjJ,+DAA+I;AAE/I;IA8GI;;;;OAIG;IACH,yCAFW,eAAe,EAsCzB;IA3HD;;;OAGG;IACH,6BAEC;IAQD;;;OAGG;IACH,kCAEC;IAQD;;;OAGG;IACH,yCAEC;IAED;;;OAGG;IACH,kCAIC;IA0GD;;;;OAIG;IACH,0BAHW,aAAa,GACX,YAAY,CAIxB;IAgBD;;;;OAIG;IACH,wBAHW,YAAY,GACV,WAAW,CAIvB;IAGD,uBA+HC;IAED,wBA2EC;IAED;;;OAGG;IACH,8BAFW,KAAK,QAkBf;IAoCD,eASC;IAGD,gBAGC;;CACJ;8BA7hBY,OAAO,0BAA0B,EAAE,eAAe;oBAClD,OAAO,sBAAsB,EAAE,KAAK;2BACpC,OAAO,+BAA+B,EAAE,YAAY;4BACpD,OAAO,qBAAqB,EAAE,aAAa;oCAC3C,OAAO,6BAA6B,EAAE,qBAAqB;kCAZtC,oCAAoC;AAOtE;;;;;;GAMG;AAEH;IACI,WAAM;IAEN;;OAEG;IACH,QAFU,qBAAqB,CAExB;IAEP;;OAEG;IACH,gBAFU,WAAW,CAEP;IAEd;;OAEG;IACH,aAFU,WAAW,CAEV;IAEX;;OAEG;IACH,gBAFU,WAAW,CAEP;IACd;;OAEG;IACH,kBAFU,WAAW,CAEL;CACnB;AAED;IACI,WAAO;IAEP;;OAEG;IACH,QAFU,YAAY,CAEf;CACV"}
+{"version":3,"file":"GPUResidentMaterialContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/resident/GPUResidentMaterialContext.js"],"names":[],"mappings":"AA+DA,sDAAuD;AAEvD,wDAAyD;AAEzD,+DAAiJ;AAEjJ,+DAA+I;AAE/I;IA8GI;;;;OAIG;IACH,yCAFW,eAAe,EAsCzB;IA3HD;;;OAGG;IACH,6BAEC;IAQD;;;OAGG;IACH,kCAEC;IAQD;;;OAGG;IACH,yCAEC;IAED;;;OAGG;IACH,kCAIC;IA0GD;;;;OAIG;IACH,0BAHW,aAAa,GACX,YAAY,CAIxB;IAgBD;;;;OAIG;IACH,wBAHW,YAAY,GACV,WAAW,CAIvB;IAGD,uBA+HC;IAED,wBA2EC;IAED;;;;OAIG;IACH,sCAFW,eAAe,QAUzB;IAoCD,eASC;IAGD,gBAGC;;CACJ;8BAthBY,OAAO,0BAA0B,EAAE,eAAe;8BAClD,OAAO,gCAAgC,EAAE,eAAe;2BACxD,OAAO,+BAA+B,EAAE,YAAY;4BACpD,OAAO,qBAAqB,EAAE,aAAa;oCAC3C,OAAO,6BAA6B,EAAE,qBAAqB;kCAZtC,oCAAoC;AAOtE;;;;;;GAMG;AAEH;IACI,WAAM;IAEN;;OAEG;IACH,QAFU,qBAAqB,CAExB;IAEP;;OAEG;IACH,gBAFU,WAAW,CAEP;IAEd;;OAEG;IACH,aAFU,WAAW,CAEV;IAEX;;OAEG;IACH,gBAFU,WAAW,CAEP;IACd;;OAEG;IACH,kBAFU,WAAW,CAEL;CACnB;AAED;IACI,WAAO;IAEP;;OAEG;IACH,QAFU,YAAY,CAEf;CACV"}

package/src/shade/renderer/material/resident/GPUResidentMaterialContext.js

@@ -18,7 +18,7 @@ import { INDIRECT_MATERIAL_STRUCT } from "./INDIRECT_MATERIAL_STRUCT.js";
 
 /**
  * @typedef {import("../../GraphicsContext.js").GraphicsContext} GraphicsContext
- * @typedef {import("../../scene/Scene.js").Scene} Scene
+ * @typedef {import("../../scene/GPUSceneContext.js").GPUSceneContext} GPUSceneContext
  * @typedef {import("../../texture/ShadeTexture.js").ShadeTexture} ShadeTexture
  * @typedef {import("../ShadeMaterial.js").ShadeMaterial} ShadeMaterial
  * @typedef {import("../StandardShadeMaterial.js").StandardShadeMaterial} StandardShadeMaterial
@@ -487,25 +487,18 @@ export class GPUResidentMaterialContext {
     }
 
     /**
+     * Make every material the scene draws with resident — the list its rows keep, each once.
      *
-     * @param {Scene} scene
+     * @param {GPUSceneContext} scene_context
      */
-    ensure_scene_materials(scene) {
-        assert.equal(scene.isScene, true, "'scene' must be a Scene instance.")
+    ensure_scene_materials(scene_context) {
+        assert.equal(scene_context.isGPUSceneContext, true, 'scene_context.isGPUSceneContext !== true');
 
-        const meshes = scene.instances.instances;
-
-        for (let i = 0; i < meshes.length; i++) {
-            const mesh = meshes[i];
-
-            const material = mesh.material;
-
-            if (material !== undefined && material !== null) {
-                this.obtain_material(material);
-            }
+        const materials = scene_context.drawn_materials;
 
+        for (let i = 0; i < materials.length; i++) {
+            this.obtain_material(materials[i]);
         }
-
     }
 
     #commit() {

package/src/shade/renderer/object_property/shader_refresh_all_mesh_bounds.d.ts

@@ -1,20 +1,22 @@
-export const REFRESH_ALL_MESH_BOUNDS_SETTINGS_STRUCT: WebGPUStruct;
+export const WORKGROUP_SIZE: number;
 /**
- * Recompute bounding box + bounding sphere for every mesh in the scene.
+ * Recompute the world-space bounding box and sphere of every mesh row in the scene, from the
+ * geometry's own bounds under the node's `global` — after the hierarchy pass has composed it.
  *
- * Coarser than the OPR-stream-driven `shader_object_property_process` —
- * that one only refreshes meshes whose own transform was animated. When a
- * non-mesh ancestor (joint, anchor) is animated, its descendant meshes'
- * world transforms change too, but they have no animation binding and
- * never make it into the OPR stream. Walking descendants on the GPU to
- * find them is the right answer eventually; for now this pass just
- * refreshes everyone, paying O(instance_count) per frame to dodge the
- * stale-bounds → frustum-culling drop-out the targeted refresh would
- * otherwise leave behind.
+ * **This is what makes render bounds the GPU's.** A row's `global` is composed on the GPU from its
+ * TRS and its parent chain, and once an ancestor can be GPU-driven — a joint under a clip, a
+ * subtree the CPU has stopped composing — nothing on the CPU holds the world transform the bounds
+ * would need. So they are derived where the transform is: one thread per occupied row, every
+ * frame, over the table's pages rather than over `[0, count)`, because rows are addresses and a
+ * live one can sit above any number of holes.
  *
- * Dispatch one thread per mesh row in `[0, instance_count)`.
+ * Runs after the hierarchy pass and before anything culls. The skinning chain refreshes the
+ * clone geometry's own box before this reads it, so a skinned row lands here on the deformed
+ * bounds rather than the source's.
+ *
+ * Dispatch with {@link GPUTypedTable#dispatch_group_count} of the `meshes` table at
+ * {@link WORKGROUP_SIZE}.
  */
 export const shader_refresh_all_mesh_bounds: ComputeShader;
-import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
 import { ComputeShader } from "../shader/ComputeShader.js";
 //# sourceMappingURL=shader_refresh_all_mesh_bounds.d.ts.map

package/src/shade/renderer/object_property/shader_refresh_all_mesh_bounds.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_refresh_all_mesh_bounds.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/object_property/shader_refresh_all_mesh_bounds.js"],"names":[],"mappings":"AAaA,mEAEmC;AAQnC;;;;;;;;;;;;;;GAcG;AACH,2DAkBG;6BAtD0B,gCAAgC;8BAG/B,4BAA4B"}
+{"version":3,"file":"shader_refresh_all_mesh_bounds.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/object_property/shader_refresh_all_mesh_bounds.js"],"names":[],"mappings":"AAYA,oCAAgE;AAiBhE;;;;;;;;;;;;;;;;;GAiBG;AACH,2DA4BG;8BAtE2B,4BAA4B"}

package/src/shade/renderer/object_property/shader_refresh_all_mesh_bounds.js

@@ -1,40 +1,49 @@
 import { u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../shader/type/WebGPUArray.js";
-import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
 import { GEOMETRY_METADATA_STRUCT } from "../geometry/GEOMETRY_METADATA_STRUCT.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { COMPUTE_SHADER_DEFAULT_GROUP_SIZE } from "../shader/COMPUTE_SHADER_DEFAULT_GROUP_SIZE.js";
 import { ComputeShader } from "../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
+import { MESHES_TABLE } from "../scene/chunk_scene_database_access.js";
 import {
     chunk_update_object_property_mesh_instance_bounds
 } from "./chunk_update_object_property_mesh_instance_bounds.js";
 
-const WORKGROUP_SIZE = 64;
+export const WORKGROUP_SIZE = COMPUTE_SHADER_DEFAULT_GROUP_SIZE;
 
-export const REFRESH_ALL_MESH_BOUNDS_SETTINGS_STRUCT = WebGPUStruct.from({
-    instance_count: u32,
-}, "RefreshAllMeshBoundsSettings");
+/**
+ * Read-write iterator over the `meshes` table's pages: the pass writes the bounds it computes back
+ * into the same database it reads the transforms from, and WGSL will not coerce a `read_write`
+ * pointer down to `read`.
+ *
+ * @type {string}
+ */
+const PG_PREFIX = MESHES_TABLE.page_iterator_symbol_prefix(WORKGROUP_SIZE, true);
 
 const resources = new ShaderResourceSetDescriptor();
+
 resources.createGroup()
-    .addUniform('settings', REFRESH_ALL_MESH_BOUNDS_SETTINGS_STRUCT)
     .addStorageBuffer('scene_database', WebGPUArray.from(u32), true)
     .addStorageBuffer('geometries', WebGPUArray.from(GEOMETRY_METADATA_STRUCT), false);
 
 /**
- * Recompute bounding box + bounding sphere for every mesh in the scene.
+ * Recompute the world-space bounding box and sphere of every mesh row in the scene, from the
+ * geometry's own bounds under the node's `global` — after the hierarchy pass has composed it.
+ *
+ * **This is what makes render bounds the GPU's.** A row's `global` is composed on the GPU from its
+ * TRS and its parent chain, and once an ancestor can be GPU-driven — a joint under a clip, a
+ * subtree the CPU has stopped composing — nothing on the CPU holds the world transform the bounds
+ * would need. So they are derived where the transform is: one thread per occupied row, every
+ * frame, over the table's pages rather than over `[0, count)`, because rows are addresses and a
+ * live one can sit above any number of holes.
  *
- * Coarser than the OPR-stream-driven `shader_object_property_process` —
- * that one only refreshes meshes whose own transform was animated. When a
- * non-mesh ancestor (joint, anchor) is animated, its descendant meshes'
- * world transforms change too, but they have no animation binding and
- * never make it into the OPR stream. Walking descendants on the GPU to
- * find them is the right answer eventually; for now this pass just
- * refreshes everyone, paying O(instance_count) per frame to dodge the
- * stale-bounds → frustum-culling drop-out the targeted refresh would
- * otherwise leave behind.
+ * Runs after the hierarchy pass and before anything culls. The skinning chain refreshes the
+ * clone geometry's own box before this reads it, so a skinned row lands here on the deformed
+ * bounds rather than the source's.
  *
- * Dispatch one thread per mesh row in `[0, instance_count)`.
+ * Dispatch with {@link GPUTypedTable#dispatch_group_count} of the `meshes` table at
+ * {@link WORKGROUP_SIZE}.
  */
 export const shader_refresh_all_mesh_bounds = ComputeShader.from({
     label: "ObjectProperty/RefreshAllMeshBounds",
@@ -42,16 +51,26 @@ export const shader_refresh_all_mesh_bounds = ComputeShader.from({
         //language=WGSL
         `
 @compute @workgroup_size(${WORKGROUP_SIZE},1,1)
-fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let mesh_row = gid.x;
-    if(mesh_row >= settings.instance_count){
+fn main(
+    @builtin(workgroup_id) wg_id: vec3<u32>,
+    @builtin(local_invocation_index) local_id: u32,
+) {
+    // page_address is uniform across the workgroup, so this branch is uniform
+    if !${PG_PREFIX}_setup(&scene_database, wg_id.x, local_id) {
+        return;
+    }
+
+    let slot_in_page = ${PG_PREFIX}_slot_in_page(local_id);
+
+    if slot_in_page >= ${PG_PREFIX}_ELEMENTS_PER_PAGE || !${PG_PREFIX}_is_occupied(slot_in_page) {
         return;
     }
 
-    update_object_property_mesh_instance_bounds(mesh_row);
+    update_object_property_mesh_instance_bounds(${PG_PREFIX}_slot_to_index(slot_in_page));
 }
 `, [
             chunk_update_object_property_mesh_instance_bounds,
+            MESHES_TABLE.chunk_iterate(WORKGROUP_SIZE, true),
         ]),
     resources,
 });