@woosh/meep-engine 3.23.0 → 3.25.0

package/src/shade/renderer/animation/skinning/GPUMeshSkinningContext.js

@@ -26,13 +26,14 @@ import {
     MESHLET_METADATA_STRUCT
 } from "../../geometry/meshlet/encoding/MESHLET_METADATA_STRUCT.js";
 import { GPUBLASRefitBatch } from "../../geometry/bvh/GPUBLASRefitBatch.js";
+import { row_of_entity } from "../../scene/rows/GPUSceneRows.js";
 
 /**
  * @typedef {import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext} ShadeGPUCommandContext
  * @typedef {import("../../geometry/GPUGeometryManager.js").GPUGeometryManager} GPUGeometryManager
  * @typedef {import("../../scene/GPUSceneContext.js").GPUSceneContext} GPUSceneContext
- * @typedef {import("../../scene/Mesh.js").Mesh} Mesh
- * @typedef {import("../../scene/SkinnedMesh.js").SkinnedMesh} SkinnedMesh
+ * @typedef {import("../../geometry/MeshletGeometry.js").MeshletGeometry} MeshletGeometry
+ * @typedef {import("../../geometry/GPUGeometryMetadata.js").GPUGeometryMetadata} GPUGeometryMetadata
  * @typedef {import("../GPUAnimationManager.js").GPUAnimationManager} GPUAnimationManager
  */
 
@@ -84,16 +85,21 @@ const MESHLET_STRIDE_BYTES = MESHLET_METADATA_STRUCT.aligned_size;
  * Per-scene container for the skinning subsystem's state. Owned by
  * {@link GPUSceneContext}; receives the scene's
  * {@link GPUGeometryManager} so it can allocate per-instance geometry
- * clones for {@link SkinnedMesh} instances and route the skinning
- * compute pass against those clones.
+ * clones for skinned entities and route the skinning compute pass
+ * against those clones.
+ *
+ * **Everything here is addressed by entity.** A skinned entity is one whose mesh row draws a
+ * per-instance clone of its geometry, and its mesh row is `entity + 1` — the same row its
+ * transform holds — so a binding never has to be told where its mesh went.
  *
  * Three responsibilities:
- *  1. Geometry-clone routing — `obtain_geometry_index(mesh)` returns
- *     the clone id for SkinnedMesh, the source id for everyone else.
- *  2. Skinning binding bookkeeping — each SkinnedMesh with a `skin_id`
+ *  1. Geometry clones — {@link obtain_clone} makes an entity's per-instance copy of its source
+ *     geometry when its mesh row is written, and {@link release_clone} gives it back when the
+ *     row goes.
+ *  2. Skinning binding bookkeeping — each entity bound to a `skin_id`
  *     produces one binding record linking its clone's vertex region
  *     back to the source's data and to the skin's matrix range.
- *  3. Per-frame dispatch — `update(cmd_ctx, animation_manager)`
+ *  3. Per-frame dispatch — `update(cmd_ctx)`
  *     uploads any new bindings and dispatches the skinning compute
  *     pass that deforms the cloned vertex regions in place.
  *
@@ -114,49 +120,34 @@ export class GPUMeshSkinningContext {
     #animation_manager;
 
     /**
-     * Per-SkinnedMesh clone metadata, cached so repeated lookups
-     * (binding-registration, geometry id resolution) hit the same
-     * record rather than re-cloning the source. Persists across
-     * scene rebuilds (unlike id_mapping).
+     * Each skinned entity's per-instance clone of its source geometry, and the source it was
+     * cloned from. Made by {@link obtain_clone} when the entity's mesh row is first written, and
+     * given back by {@link release_clone} when that row goes.
      *
-     * @type {Map<SkinnedMesh, GPUGeometryMetadata>}
+     * @type {Map<number, {clone: GPUGeometryMetadata, source: MeshletGeometry}>}
      */
     #clones = new Map();
 
     /**
-     * Per-mesh skin assignment. Populated by {@link bind}; consumed
-     * by {@link #register_binding} when it stamps the GPU binding
-     * record. A mesh present here has had a skinning binding
-     * registered exactly once — re-binding the same mesh is a
-     * no-op (the existing binding stands).
-     *
-     * Held here rather than on the {@link SkinnedMesh} so the public
-     * mesh class doesn't carry GPU-side state; consumers who need
-     * to look up "what skin is mesh X bound to?" can query via
-     * {@link get_skin_id}.
+     * Which skin each entity is bound to. Populated by {@link bind}; consumed by
+     * {@link #register_binding} when it stamps the GPU binding record. Outlives the clone: an
+     * entity whose mesh row goes and comes back keeps its skin, and the binding is rebuilt from
+     * here when the new clone is made.
      *
-     * @type {Map<SkinnedMesh, number>}
+     * @type {Map<number, number>}
      */
-    #skin_id_by_mesh = new Map();
+    #skin_by_entity = new Map();
 
     /**
-     * One CPU record per `(SkinnedMesh, clone)` binding registered via
+     * One CPU record per `(entity, clone)` binding registered via
      * {@link #register_binding}. Resolved into GPU bytes at upload
      * time — `skin_id` becomes `skin_matrix_offset` via
-     * {@link GPUAnimationManager#get_skin_matrix_offset}, and `mesh`
-     * becomes a meshes-table row via
-     * {@link GPUSceneContext#mesh_row_of}. The mesh is held rather
-     * than its row because the row is not stable: registration
-     * happens before the scene has placed the mesh at all, and the
-     * table reuses rows afterwards.
-     *
-     * Append-only in this MVP — removing a SkinnedMesh leaks its
-     * binding (alongside its clone). Acceptable at the lifetime-
-     * distinct-instance scale; phase-4 frees both together.
+     * {@link GPUAnimationManager#get_skin_matrix_offset}, and the
+     * entity is its own meshes-table row, `entity + 1`.
      *
      * @type {{
      *     skin_id: number,
-     *     mesh: SkinnedMesh,
+     *     entity: number,
      *     source_meshlet_metadata_offset: number,
      *     clone_meshlet_metadata_offset: number,
      *     meshlet_count: number,
@@ -181,15 +172,6 @@ export class GPUMeshSkinningContext {
      */
     #bindings_dirty = false;
 
-    /**
-     * The scene context's {@link GPUSceneContext#mesh_rows_version} as of the last bindings upload.
-     * The records hold meshes-table rows and that table reuses them, so a difference here means
-     * every record's row has to be resolved again.
-     *
-     * @type {number}
-     */
-    #uploaded_mesh_rows_version = -1;
-
     /**
      * GPU mirror of {@link #bindings}, with `skin_id` resolved to
      * `skin_matrix_offset`. `null` until the first binding is
@@ -311,17 +293,8 @@ export class GPUMeshSkinningContext {
     #prev_position_offsets_cpu = new Uint32Array(0);
 
     /**
-     * Back-reference to the owning {@link GPUSceneContext} so the
-     * bindings-upload path can resolve a mesh to its meshes-table row
-     * via {@link GPUSceneContext#mesh_row_of} without the caller
-     * threading that lookup through every `bind()` call.
-     *
-     * Resolution cannot happen at registration time: `bind` and
-     * `obtain_geometry_index` both run before `scene.build` has given
-     * the mesh a row. Nor does resolving once suffice — the table
-     * hands out the lowest free row, so a mesh that leaves and
-     * re-enters the scene lands somewhere else, which is what
-     * {@link GPUSceneContext#mesh_rows_version} is compared for.
+     * The owning {@link GPUSceneContext}, for the scene database the skinning pass reads the
+     * mesh rows and their transforms out of.
      *
      * @type {GPUSceneContext}
      */
@@ -405,70 +378,84 @@ export class GPUMeshSkinningContext {
     }
 
     /**
-     * Geometry id to assign to this mesh's instance record. Idempotent.
+     * The per-instance clone of `geometry` an entity's mesh row draws. Made on the first call and
+     * returned on every later one. If the entity has already been bound to a skin via
+     * {@link bind}, the binding is registered here too, so a row written after its skin arrived
+     * is not stranded without a deformation pass.
      *
-     * - For a {@link SkinnedMesh}: a per-instance clone of the source's
-     *   GPU geometry. The first time we see a given mesh, allocate a
-     *   clone; subsequent calls return the cached id. If the mesh has
-     *   already been bound to a skin via {@link bind}, the binding's
-     *   registration also runs here so scene.build's first sight of
-     *   a pre-bound mesh doesn't strand it without a deformation pass.
-     * - For a regular {@link Mesh}: the source's id from the geometry
-     *   manager.
+     * Called by the scene rows when a skinned entity's mesh row is written — the geometry index
+     * the row carries is the clone's.
      *
-     * @param {Mesh} mesh
-     * @returns {number}
+     * @param {number} entity
+     * @param {MeshletGeometry} geometry the source
+     * @returns {GPUGeometryMetadata} the clone's record
      */
-    obtain_geometry_index(mesh) {
-        if (mesh.isSkinnedMesh === true) {
-            const clone_metadata = this.#ensure_clone(mesh);
-            // If the mesh has already been bound (bind() ran before
-            // scene.build for this mesh), register its binding now.
-            // No-op if not yet bound or if the binding has already
-            // been registered in a previous call.
-            this.#try_register_binding(mesh, clone_metadata);
-            return clone_metadata.index;
+    obtain_clone(entity, geometry) {
+        assert.isNonNegativeInteger(entity, 'entity');
+        assert.defined(geometry, 'geometry');
+
+        let entry = this.#clones.get(entity);
+
+        if (entry === undefined) {
+            this.#geometries.add(geometry);
+
+            entry = { clone: this.#geometries.add_clone(geometry), source: geometry };
+
+            this.#clones.set(entity, entry);
+        } else {
+            assert.equal(entry.source, geometry, `entity ${entity} has a clone of a different geometry; release it before cloning another`);
         }
 
-        this.#geometries.add(mesh.geometry);
-        return this.#geometries.getAddress(mesh.geometry);
+        this.#try_register_binding(entity, entry);
+
+        return entry.clone;
     }
 
     /**
-     * Bind a {@link SkinnedMesh} to a skin. The mesh's clone (if not
-     * already allocated) is created on demand; a skinning-pass
-     * binding record is registered so the deformation runs each
-     * frame. The skin id is stored on the context (not on the mesh
-     * — `SkinnedMesh` carries no GPU state).
+     * The clone an entity's mesh row draws, if it has one.
      *
-     * Re-binding the same mesh with a different skin id is rejected
-     * (single-binding model in this MVP — use {@link unbind} first if
-     * you need to swap). Calling with the same skin id is a no-op.
+     * @param {number} entity
+     * @returns {GPUGeometryMetadata|undefined}
+     */
+    clone_of(entity) {
+        const entry = this.#clones.get(entity);
+
+        return entry === undefined ? undefined : entry.clone;
+    }
+
+    /**
+     * Bind an entity's mesh to a skin: a skinning-pass binding record is registered so the
+     * deformation runs each frame, as soon as the entity has a clone to deform — which it has
+     * once its mesh row is written, before or after this call.
      *
-     * Tolerates being called before `scene.build` registers the mesh;
-     * the binding upload happens during the next per-frame
-     * {@link update}.
+     * Re-binding the same entity with a different skin id is rejected (one skin per mesh — use
+     * {@link unbind} first to swap). Calling with the same skin id is a no-op.
      *
-     * @param {SkinnedMesh} mesh
+     * @param {number} entity
      * @param {number} skin_id
      */
-    bind(mesh, skin_id) {
-        assert.defined(mesh, 'mesh');
-        assert.equal(mesh.isSkinnedMesh, true, 'mesh.isSkinnedMesh !== true');
+    bind(entity, skin_id) {
+        assert.isNonNegativeInteger(entity, 'entity');
         assert.isNonNegativeInteger(skin_id, 'skin_id');
 
-        const existing = this.#skin_id_by_mesh.get(mesh);
+        const existing = this.#skin_by_entity.get(entity);
+
         if (existing !== undefined) {
             assert.equal(
                 existing, skin_id,
-                `SkinnedMesh '${mesh.name}' is already bound to skin ${existing}; unbind before rebinding`
+                `entity ${entity} is already bound to skin ${existing}; unbind before rebinding`
             );
+
             return;
         }
 
-        this.#skin_id_by_mesh.set(mesh, skin_id);
-        const clone_metadata = this.#ensure_clone(mesh);
-        this.#try_register_binding(mesh, clone_metadata);
+        this.#skin_by_entity.set(entity, skin_id);
+
+        const entry = this.#clones.get(entity);
+
+        if (entry !== undefined) {
+            this.#try_register_binding(entity, entry);
+        }
     }
 
     /**
@@ -476,11 +463,11 @@ export class GPUMeshSkinningContext {
      * mesh hasn't been bound. Read-only accessor — bookkeeping lives
      * here, not on the mesh.
      *
-     * @param {SkinnedMesh} mesh
+     * @param {number} entity
      * @returns {number|undefined}
      */
-    get_skin_id(mesh) {
-        return this.#skin_id_by_mesh.get(mesh);
+    get_skin_id(entity) {
+        return this.#skin_by_entity.get(entity);
     }
 
     /**
@@ -492,14 +479,14 @@ export class GPUMeshSkinningContext {
      *
      * No-op if the mesh isn't bound.
      *
-     * @param {SkinnedMesh} mesh
+     * @param {number} entity
      */
-    unbind(mesh) {
-        if (!this.#skin_id_by_mesh.has(mesh)) return;
-        this.#skin_id_by_mesh.delete(mesh);
+    unbind(entity) {
+        if (!this.#skin_by_entity.has(entity)) return;
+        this.#skin_by_entity.delete(entity);
 
         for (let i = this.#bindings.length - 1; i >= 0; i--) {
-            if (this.#bindings[i].mesh === mesh) {
+            if (this.#bindings[i].entity === entity) {
                 this.#drop_binding_at(i);
                 break;
             }
@@ -519,7 +506,7 @@ export class GPUMeshSkinningContext {
         for (let i = this.#bindings.length - 1; i >= 0; i--) {
             const b = this.#bindings[i];
             if (b.skin_id === skin_id) {
-                this.#skin_id_by_mesh.delete(b.mesh);
+                this.#skin_by_entity.delete(b.entity);
                 this.#drop_binding_at(i);
             }
         }
@@ -614,95 +601,75 @@ export class GPUMeshSkinningContext {
     }
 
     /**
-     * Give back everything a {@link SkinnedMesh} was holding on the GPU: its binding, its
+     * Give back everything a skinned entity was holding on the GPU: its binding, its
      * prev-position slice, and the per-instance geometry clone it rendered.
      *
-     * **Called when the mesh leaves the scene, not when it unbinds.** A clone is named by the
-     * meshes-table row of the instance that renders it, so it lives exactly as long as that
-     * row does — {@link GPUSceneContext} calls this from the same place it gives the row
-     * back. Unbinding is a different event: an unbound mesh keeps rendering its clone frozen
-     * at the last pose the skinning pass wrote, and freeing there would hand a live renderer
-     * a vertex region that has since gone to somebody else.
+     * **Called when the entity's mesh row goes, not when it unbinds.** A clone lives exactly as
+     * long as the row that draws it — the scene rows call this from the same place they give
+     * the row back. Unbinding is a different event: an unbound mesh keeps rendering its clone
+     * frozen at the last pose the skinning pass wrote, and freeing there would hand a live
+     * renderer a vertex region that has since gone to somebody else.
      *
      * The binding record goes first, and for its own reason: it names the clone's meshlet
      * rows, and the skinning pass would deform whatever took their place.
      *
-     * **Which skin the mesh belongs to is not forgotten.** A mesh may leave the scene and
-     * come back — the row it gets is not even the row it had — and the engine's answer to
-     * that is {@link #try_register_binding}, which rebuilds the binding from
-     * {@link #skin_id_by_mesh} the next time `scene.build` asks for the mesh's geometry id.
-     * Releasing through {@link unbind} would drop that association too and hand the returning
-     * mesh back undeformed. Forgetting the skin is what {@link unbind} is for, and it is a
-     * different thing to want.
+     * **Which skin the entity belongs to is not forgotten.** A mesh row may go and come back,
+     * and the engine's answer to that is {@link #try_register_binding}, which rebuilds the
+     * binding from {@link #skin_by_entity} when the new clone is made. Releasing through
+     * {@link unbind} would drop that association too and hand the returning mesh back
+     * undeformed. Forgetting the skin is what {@link unbind} is for, and it is a different
+     * thing to want.
      *
-     * The mesh does pay for a fresh clone on its way back in: a new vertex region, its copy
-     * from source, and a new tree. That is the right trade while nothing removes a mesh from
-     * the scene except an entity that is actually leaving — culling and LOD never do — and it
-     * is what a clone cache keyed by source geometry would take away if that ever changes.
+     * The entity does pay for a fresh clone on its way back in: a new vertex region, its copy
+     * from source, and a new tree. That is the right trade while nothing takes a mesh row away
+     * except an entity that is actually leaving — culling and LOD never do — and it is what a
+     * clone cache keyed by source geometry would take away if that ever changes.
      *
-     * No-op for a mesh that has no clone — a {@link SkinnedMesh} that never reached
-     * `scene.build` or was released already.
+     * No-op for an entity that has no clone — one whose mesh row was never written, or was
+     * released already.
      *
-     * @param {SkinnedMesh} mesh
+     * @param {number} entity
      */
-    release_clone(mesh) {
-        assert.defined(mesh, 'mesh');
+    release_clone(entity) {
+        assert.isNonNegativeInteger(entity, 'entity');
 
-        const clone_metadata = this.#clones.get(mesh);
+        const entry = this.#clones.get(entity);
 
-        if (clone_metadata === undefined) {
+        if (entry === undefined) {
             return;
         }
 
         for (let i = this.#bindings.length - 1; i >= 0; i--) {
-            if (this.#bindings[i].mesh === mesh) {
+            if (this.#bindings[i].entity === entity) {
                 this.#drop_binding_at(i);
                 break;
             }
         }
 
-        this.#clones.delete(mesh);
-
-        this.#geometries.remove_clone(clone_metadata);
-    }
+        this.#clones.delete(entity);
 
-    /**
-     * Lookup-or-create the per-mesh clone metadata. Cached so that
-     * repeated lookups (binding-registration, geometry id resolution
-     * via obtain_geometry_index) hit the same record without
-     * re-cloning the source.
-     *
-     * @param {SkinnedMesh} mesh
-     * @returns {GPUGeometryMetadata}
-     */
-    #ensure_clone(mesh) {
-        let clone_metadata = this.#clones.get(mesh);
-        if (clone_metadata === undefined) {
-            clone_metadata = this.#geometries.add_clone(mesh.geometry);
-            this.#clones.set(mesh, clone_metadata);
-        }
-        return clone_metadata;
+        this.#geometries.remove_clone(entry.clone);
     }
 
     /**
-     * Register a binding for this mesh if conditions allow:
-     *   - the mesh has been bound to a skin via {@link bind}, AND
-     *   - we haven't already registered the binding for this mesh.
+     * Register a binding for this entity if conditions allow:
+     *   - the entity has been bound to a skin via {@link bind}, AND
+     *   - we haven't already registered the binding for it.
      *
-     * @param {SkinnedMesh} mesh
-     * @param {GPUGeometryMetadata} clone_metadata
+     * @param {number} entity
+     * @param {{clone: GPUGeometryMetadata, source: MeshletGeometry}} entry
      */
-    #try_register_binding(mesh, clone_metadata) {
-        const skin_id = this.#skin_id_by_mesh.get(mesh);
+    #try_register_binding(entity, entry) {
+        const skin_id = this.#skin_by_entity.get(entity);
         if (skin_id === undefined) return;
         // The binding's presence in #bindings is the source of truth
         // for "already registered". Cheap O(bindings) scan; bindings
         // are O(skinned-mesh-count).
         for (let i = 0; i < this.#bindings.length; i++) {
-            if (this.#bindings[i].mesh === mesh) return;
+            if (this.#bindings[i].entity === entity) return;
         }
 
-        this.#register_binding(mesh, clone_metadata, skin_id);
+        this.#register_binding(entity, entry, skin_id);
     }
 
     /**
@@ -720,10 +687,12 @@ export class GPUMeshSkinningContext {
      * `skin_matrix_offset` for the binding records.
      *
      * @param {ShadeGPUCommandContext} cmd_ctx
+     * @returns {boolean} whether a skinning pass ran — whether any bound row's vertices, and so
+     * its bounds, moved this frame
      */
     update(cmd_ctx) {
         if (this.#bindings.length === 0) {
-            return;
+            return false;
         }
 
         // Flush any meshlet-clone work that hasn't been drained yet —
@@ -749,19 +718,11 @@ export class GPUMeshSkinningContext {
         // job; here we just need the meshlet pending-clone flush.
         this.#geometries.meshlets.update(cmd_ctx);
 
-        // The binding record carries a meshes-table row, and that table reuses rows: a scene the
-        // mesh left and re-entered puts it somewhere else, and every other binding's row can move
-        // out from under it too. So the records are re-resolved whenever the table's membership has
-        // changed since they were written, not only when a binding was added or dropped.
-        const mesh_rows_version = this.#scene_context.mesh_rows_version;
-
-        if (this.#bindings_dirty || this.#uploaded_mesh_rows_version !== mesh_rows_version) {
+        if (this.#bindings_dirty) {
+            // A binding's row is its entity's, and an entity's row never moves — so the records
+            // are written when the list changes and at no other time.
             this.#upload_bindings();
 
-            this.#uploaded_mesh_rows_version = mesh_rows_version;
-        }
-
-        if (this.#bindings_dirty) {
             // None of these reads anything outside the binding list, so a scene edit that left
             // the list alone cannot have moved them.
             this.#upload_dispatch_lookup();
@@ -938,6 +899,9 @@ export class GPUMeshSkinningContext {
         // once, not a dispatch per clone: the command count is the same for one skinned mesh as
         // for three hundred, and each tree's climb overlaps the next's instead of waiting on it.
         this.#record_blas_refits(cmd_ctx);
+
+        // every bound mesh's clone was deformed this frame, so every bound row's bounds moved
+        return true;
     }
 
     /**
@@ -966,12 +930,14 @@ export class GPUMeshSkinningContext {
     }
 
     /**
-     * @param {SkinnedMesh} mesh
-     * @param {GPUGeometryMetadata} clone_metadata
+     * @param {number} entity
+     * @param {{clone: GPUGeometryMetadata, source: MeshletGeometry}} entry
      * @param {number} skin_id
      */
-    #register_binding(mesh, clone_metadata, skin_id) {
-        const source_metadata = this.#geometries.get_metadata(mesh.geometry);
+    #register_binding(entity, entry, skin_id) {
+        const clone_metadata = entry.clone;
+
+        const source_metadata = this.#geometries.get_metadata(entry.source);
         assert.defined(source_metadata, 'source_metadata');
 
         const meshlet_count = clone_metadata.meshlets.meshlet_count;
@@ -979,7 +945,7 @@ export class GPUMeshSkinningContext {
 
         const binding = {
             skin_id,
-            mesh,
+            entity,
             source_meshlet_metadata_offset: source_metadata.meshlets.metadata.offset,
             clone_meshlet_metadata_offset,
             meshlet_count,
@@ -1170,20 +1136,8 @@ export class GPUMeshSkinningContext {
         for (let i = 0; i < binding_count; i++) {
             const b = this.#bindings[i];
 
-            // The meshes table is asked for the row rather than having it
-            // derived from the transforms row: every node earns a
-            // transforms row and only the geometry-bearing ones earn a
-            // mesh row, so the two tables run at different rates as soon
-            // as the scene holds a group, an anchor or a joint — which is
-            // every glTF. A bound mesh is in the scene: assertion catches
-            // both a SkinnedMesh scene.build has not seen yet and one that
-            // left the scene without being unbound, either of which would
-            // otherwise reach the shader as a garbage row.
-            const mesh_instance_index = this.#scene_context.mesh_row_of(b.mesh);
-            assert.isNonNegativeInteger(
-                mesh_instance_index,
-                `SkinnedMesh '${b.mesh.name}' (id=${b.mesh.id}) has no meshes-table row — scene.build must run before skinning bindings upload`
-            );
+            // the entity is the row, in the meshes table as in the transforms table
+            const mesh_instance_index = row_of_entity(b.entity);
 
             write_gpu_typed_buffer({
                 skin_matrix_offset: this.#animation_manager.get_skin_matrix_offset(b.skin_id),

package/src/shade/renderer/animation/skinning/SKINNING_BINDING_STRUCT.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SKINNING_BINDING_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/SKINNING_BINDING_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AACH,mDA2DsB;6BA7EO,mCAAmC"}
+{"version":3,"file":"SKINNING_BINDING_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/SKINNING_BINDING_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AACH,mDAwDsB;6BA1EO,mCAAmC"}

package/src/shade/renderer/animation/skinning/SKINNING_BINDING_STRUCT.js

@@ -66,13 +66,10 @@ export const SKINNING_BINDING_STRUCT = WebGPUStruct.from({
     clone_geometry_index: u32,
 
     /**
-     * Row of the SkinnedMesh in the scene database's `meshes` table.
-     * Resolved at upload time from `gpu_scene.mesh_row_of(mesh)`.
-     * **Not derivable from the transforms row**: every node earns a
-     * transforms row and only the geometry-bearing ones earn a mesh
-     * row, so the two run at different rates in any scene holding a
-     * group, an anchor or a joint. The bounds-refresh's final stage uses this
-     * to call {@link chunk_update_object_property_mesh_instance_bounds}
+     * Row of the mesh entity in the scene database's `meshes` table:
+     * the entity, one on (`row_of_entity`), which is also its transforms
+     * row. Resolved at upload time. The bounds-refresh's final stage uses
+     * this to call {@link chunk_update_object_property_mesh_instance_bounds}
      * and write the post-deformation world-space mesh bounds.
      */
     mesh_instance_index: u32,

package/src/shade/renderer/animation/skinning/chunk_skin_blend_mesh_local.d.ts

@@ -31,8 +31,8 @@
  * cancel against. Both shapes are legal glTF and both are in the wild.
  *
  * The condition that does hold is `mesh.global == the skin's bind transform`, and
- * {@link skin_normalize_mesh_frame} makes it true at `register_skin` for every asset rather than
- * leaving it to the exporter. The product is then the joint's displacement from bind, which is rigid
+ * `prefab_normalize_skin_frames` makes it true when a model is compiled, for every asset rather
+ * than leaving it to the exporter. The product is then the joint's displacement from bind, which is rigid
  * whenever the clip rotates and translates and does not scale. `SKINNING_FRAME_PLAN.md` is the
  * argument, and what a violation looks like on screen.
  */

package/src/shade/renderer/animation/skinning/chunk_skin_blend_mesh_local.js

@@ -39,8 +39,8 @@ import {
  * cancel against. Both shapes are legal glTF and both are in the wild.
  *
  * The condition that does hold is `mesh.global == the skin's bind transform`, and
- * {@link skin_normalize_mesh_frame} makes it true at `register_skin` for every asset rather than
- * leaving it to the exporter. The product is then the joint's displacement from bind, which is rigid
+ * `prefab_normalize_skin_frames` makes it true when a model is compiled, for every asset rather
+ * than leaving it to the exporter. The product is then the joint's displacement from bind, which is rigid
  * whenever the clip rotates and translates and does not scale. `SKINNING_FRAME_PLAN.md` is the
  * argument, and what a violation looks like on screen.
  */