@woosh/meep-engine 3.39.0 → 3.41.0

package/src/shade/renderer/animation/shader_animation_pose_resolve.js

@@ -1,176 +1,187 @@
-import { atomic_u32, u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../shader/type/WebGPUArray.js";
-import { chunk_scene_database_access_rw } from "../scene/chunk_scene_database_access.js";
-import { SCENE_DATABASE_SPEC } from "../scene/SCENE_DATABASE_SPEC.js";
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
-import { chunk_pose_accumulator } from "./chunk_pose_accumulator.js";
-
-const TRANSFORMS_TABLE = SCENE_DATABASE_SPEC.get('transforms');
-
-/**
- * Workgroup size for the resolve pass. Exported so dispatchers can pair
- * it with `transforms.dispatch_group_count(WORKGROUP_SIZE)`.
- */
-export const WORKGROUP_SIZE = 64;
-
-const PG_PREFIX = TRANSFORMS_TABLE.page_iterator_symbol_prefix(WORKGROUP_SIZE, true);
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addStorageBuffer('scene_database', WebGPUArray.from(u32), true)
-    .addStorageBuffer('pose_accumulator', WebGPUArray.from(atomic_u32), true);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-@compute @workgroup_size(${WORKGROUP_SIZE},1,1)
-fn main(
-    @builtin(workgroup_id) wg_id: vec3<u32>,
-    @builtin(local_invocation_index) local_id: u32,
-) {
-    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 {
-        return;
-    }
-    if !${PG_PREFIX}_is_occupied(slot_in_page) {
-        return;
-    }
-
-    // Absolute transforms-table row index. The accumulator is laid out
-    // one slot per row at the same index, so this is also the
-    // accumulator slot.
-    let row = ${PG_PREFIX}_slot_to_index(slot_in_page);
-
-    let slot_base = pose_accumulator_slot_base(row);
-    let dirty_word = slot_base + POSE_OFFSET_DIRTY;
-
-    // Single load of the dirty mask gates the whole resolve. If
-    // nothing was contributed to this row this frame, leave local_*
-    // alone (and the accumulator slot is already zero because the
-    // previous resolve drained it).
-    let dirty = atomicLoad(&pose_accumulator[dirty_word]);
-    if dirty == 0u {
-        return;
-    }
-
-    // ── Translation ───────────────────────────────────────────────
-    if (dirty & POSE_DIRTY_T_MASK) != 0u {
-        let t_base = slot_base + POSE_OFFSET_TRANSLATION;
-        // Per-axis: only overwrite the channels that actually had a
-        // contribution. Read the current local_translation through
-        // the rw helper and patch the dirty channels in-place — the
-        // sibling-axis race that the old direct writer already
-        // tolerated still applies (two threads writing different
-        // axes of the same node), but we now have at most one resolve
-        // thread per row, so it never triggers here.
-        var t = scene_read_node_rw(&scene_database, row).local_translation;
-        if (dirty & POSE_DIRTY_TX) != 0u {
-            t.x = bitcast<f32>(atomicLoad(&pose_accumulator[t_base + 0u]));
-            atomicStore(&pose_accumulator[t_base + 0u], 0u);
-        }
-        if (dirty & POSE_DIRTY_TY) != 0u {
-            t.y = bitcast<f32>(atomicLoad(&pose_accumulator[t_base + 1u]));
-            atomicStore(&pose_accumulator[t_base + 1u], 0u);
-        }
-        if (dirty & POSE_DIRTY_TZ) != 0u {
-            t.z = bitcast<f32>(atomicLoad(&pose_accumulator[t_base + 2u]));
-            atomicStore(&pose_accumulator[t_base + 2u], 0u);
-        }
-        scene_write_node_local_translation(&scene_database, row, t);
-    }
-
-    // ── Rotation ──────────────────────────────────────────────────
-    if (dirty & POSE_DIRTY_R) != 0u {
-        let r_base = slot_base + POSE_OFFSET_ROTATION;
-        let r = vec4<f32>(
-            bitcast<f32>(atomicLoad(&pose_accumulator[r_base + 0u])),
-            bitcast<f32>(atomicLoad(&pose_accumulator[r_base + 1u])),
-            bitcast<f32>(atomicLoad(&pose_accumulator[r_base + 2u])),
-            bitcast<f32>(atomicLoad(&pose_accumulator[r_base + 3u])),
-        );
-        atomicStore(&pose_accumulator[r_base + 0u], 0u);
-        atomicStore(&pose_accumulator[r_base + 1u], 0u);
-        atomicStore(&pose_accumulator[r_base + 2u], 0u);
-        atomicStore(&pose_accumulator[r_base + 3u], 0u);
-        // A sum of length zero carries no orientation to recover: every
-        // clip that writes this rotation is playing at weight zero, and
-        // the apply pass contributes to a bound clip whatever its
-        // weight. \`normalize\` answers NaN there, and one NaN local
-        // rotation reaches every skin matrix naming the joint, so the
-        // meshes it drives stop rasterising altogether — a rig loses a
-        // limb because a clip nobody is playing happens to be the only
-        // one that rotates it. Leaving the row alone is the rest pose,
-        // which is the answer the CPU twin gives (\`pose_evaluate_local\`)
-        // and the value the row still holds.
-        //
-        // Otherwise: the weighted-quaternion sum (\`w_i * q_i\`) is the
-        // standard nlerp blend numerator; normalise here, once, after
-        // every contributor has been folded in. The apply pass
-        // canonicalised signs at GLTF load so we don't hit the antipode
-        // case for imported clips.
-        if length(r) > 0.0 {
-            scene_write_node_local_rotation(&scene_database, row, normalize(r));
-        }
-    }
-
-    // ── Scale ─────────────────────────────────────────────────────
-    if (dirty & POSE_DIRTY_S_MASK) != 0u {
-        let s_base = slot_base + POSE_OFFSET_SCALE;
-        var s = scene_read_node_rw(&scene_database, row).local_scale;
-        if (dirty & POSE_DIRTY_SX) != 0u {
-            s.x = bitcast<f32>(atomicLoad(&pose_accumulator[s_base + 0u]));
-            atomicStore(&pose_accumulator[s_base + 0u], 0u);
-        }
-        if (dirty & POSE_DIRTY_SY) != 0u {
-            s.y = bitcast<f32>(atomicLoad(&pose_accumulator[s_base + 1u]));
-            atomicStore(&pose_accumulator[s_base + 1u], 0u);
-        }
-        if (dirty & POSE_DIRTY_SZ) != 0u {
-            s.z = bitcast<f32>(atomicLoad(&pose_accumulator[s_base + 2u]));
-            atomicStore(&pose_accumulator[s_base + 2u], 0u);
-        }
-        scene_write_node_local_scale(&scene_database, row, s);
-    }
-
-    // Clear the dirty mask itself last, so an interrupted resolve
-    // (theoretical — these passes don't yield) would still leave the
-    // dirty bits intact to be redone.
-    atomicStore(&pose_accumulator[dirty_word], 0u);
-}
-`, [
-        TRANSFORMS_TABLE.chunk_iterate(WORKGROUP_SIZE, true),
-        chunk_scene_database_access_rw,
-        chunk_pose_accumulator,
-    ]);
-
-/**
- * Compute shader that drains the pose accumulator into
- * `transforms_table.local_{translation,rotation,scale}`.
- *
- * Walks the transforms table via the read+write page iterator — one
- * thread per slot. For each occupied row whose accumulator slot has
- * any dirty bits set, reads the contributed components (atomic
- * loads, bitcast back to f32), writes them through the per-field
- * scene helpers, normalises rotation, and zeros the slot for next
- * frame.
- *
- * The accumulator buffer must be sized to at least
- * `transforms.dispatch_page_count * elements_per_page` rows —
- * {@link GPUAnimationManager#ensure_pose_accumulator_capacity}
- * handles that.
- *
- * Dispatch via
- * `shader_animation_pose_resolve.dispatch({ group_count_x: transforms.dispatch_group_count(WORKGROUP_SIZE), ... })`.
- */
-export const shader_animation_pose_resolve = ComputeShader.from({
-    label: "Animation/PoseResolve",
-    body,
-    resources,
-});
+import { atomic_u32, u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../shader/type/WebGPUArray.js";
+import { chunk_scene_database_access_rw } from "../scene/chunk_scene_database_access.js";
+import { SCENE_DATABASE_SPEC } from "../scene/SCENE_DATABASE_SPEC.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
+import { chunk_pose_accumulator } from "./chunk_pose_accumulator.js";
+
+const TRANSFORMS_TABLE = SCENE_DATABASE_SPEC.get('transforms');
+
+/**
+ * Workgroup size for the resolve pass. Exported so dispatchers can pair
+ * it with `transforms.dispatch_group_count(WORKGROUP_SIZE)`.
+ */
+export const WORKGROUP_SIZE = 64;
+
+const PG_PREFIX = TRANSFORMS_TABLE.page_iterator_symbol_prefix(WORKGROUP_SIZE, true);
+
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup()
+    .addStorageBuffer('scene_database', WebGPUArray.from(u32), true)
+    .addStorageBuffer('pose_accumulator', WebGPUArray.from(atomic_u32), true);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(${WORKGROUP_SIZE},1,1)
+fn main(
+    @builtin(workgroup_id) wg_id: vec3<u32>,
+    @builtin(local_invocation_index) local_id: u32,
+) {
+    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 {
+        return;
+    }
+    if !${PG_PREFIX}_is_occupied(slot_in_page) {
+        return;
+    }
+
+    // Absolute transforms-table row index. The accumulator is laid out
+    // one slot per row at the same index, so this is also the
+    // accumulator slot.
+    let row = ${PG_PREFIX}_slot_to_index(slot_in_page);
+
+    let slot_base = pose_accumulator_slot_base(row);
+    let dirty_word = slot_base + POSE_OFFSET_DIRTY;
+
+    // Single load of the dirty mask gates the whole resolve. If
+    // nothing was contributed to this row this frame, leave local_*
+    // alone (and the accumulator slot is already zero because the
+    // previous resolve drained it).
+    let dirty = atomicLoad(&pose_accumulator[dirty_word]);
+    if dirty == 0u {
+        return;
+    }
+
+    // ── Translation ───────────────────────────────────────────────
+    if (dirty & POSE_DIRTY_T_MASK) != 0u {
+        let t_base = slot_base + POSE_OFFSET_TRANSLATION;
+        // Per-axis: only overwrite the channels that actually had a
+        // contribution. Read the current local_translation through
+        // the rw helper and patch the dirty channels in-place — the
+        // sibling-axis race that the old direct writer already
+        // tolerated still applies (two threads writing different
+        // axes of the same node), but we now have at most one resolve
+        // thread per row, so it never triggers here.
+        var t = scene_read_node_rw(&scene_database, row).local_translation;
+        if (dirty & POSE_DIRTY_TX) != 0u {
+            t.x = bitcast<f32>(atomicLoad(&pose_accumulator[t_base + 0u]));
+            atomicStore(&pose_accumulator[t_base + 0u], 0u);
+        }
+        if (dirty & POSE_DIRTY_TY) != 0u {
+            t.y = bitcast<f32>(atomicLoad(&pose_accumulator[t_base + 1u]));
+            atomicStore(&pose_accumulator[t_base + 1u], 0u);
+        }
+        if (dirty & POSE_DIRTY_TZ) != 0u {
+            t.z = bitcast<f32>(atomicLoad(&pose_accumulator[t_base + 2u]));
+            atomicStore(&pose_accumulator[t_base + 2u], 0u);
+        }
+        scene_write_node_local_translation(&scene_database, row, t);
+    }
+
+    // ── Rotation ──────────────────────────────────────────────────
+    if (dirty & POSE_DIRTY_R) != 0u {
+        let r_base = slot_base + POSE_OFFSET_ROTATION;
+        let r = vec4<f32>(
+            bitcast<f32>(atomicLoad(&pose_accumulator[r_base + 0u])),
+            bitcast<f32>(atomicLoad(&pose_accumulator[r_base + 1u])),
+            bitcast<f32>(atomicLoad(&pose_accumulator[r_base + 2u])),
+            bitcast<f32>(atomicLoad(&pose_accumulator[r_base + 3u])),
+        );
+        atomicStore(&pose_accumulator[r_base + 0u], 0u);
+        atomicStore(&pose_accumulator[r_base + 1u], 0u);
+        atomicStore(&pose_accumulator[r_base + 2u], 0u);
+        atomicStore(&pose_accumulator[r_base + 3u], 0u);
+        // The weighted-quaternion sum (\`w_i * q_i\`) is the standard
+        // nlerp blend numerator; normalise here, once, after every
+        // contributor has been folded in. The apply pass canonicalised
+        // signs at GLTF load so we don't hit the antipode case for
+        // imported clips.
+        //
+        // A sum of length zero carries no orientation to recover: every
+        // clip that writes this rotation is playing at weight zero — a
+        // faded-out clip keeps its binding, and the apply pass
+        // contributes to a bound clip whatever its weight — or the
+        // contributions cancelled exactly. \`normalize\` answers NaN there,
+        // and one NaN local rotation reaches every skin matrix naming the
+        // joint, so the meshes it drives stop rasterising altogether. Nor
+        // can the row be left alone: once a clip has written it, it holds
+        // that clip's last pose, not the rest. The answer is the rest
+        // rotation, which every contribution carried into the slot from
+        // its binding — what the CPU twin (\`pose_evaluate_local\`) gives.
+        if length(r) > 0.0 {
+            scene_write_node_local_rotation(&scene_database, row, normalize(r));
+        } else {
+            let rest_base = slot_base + POSE_OFFSET_REST_ROTATION;
+            let rest = vec4<f32>(
+                bitcast<f32>(atomicLoad(&pose_accumulator[rest_base + 0u])),
+                bitcast<f32>(atomicLoad(&pose_accumulator[rest_base + 1u])),
+                bitcast<f32>(atomicLoad(&pose_accumulator[rest_base + 2u])),
+                bitcast<f32>(atomicLoad(&pose_accumulator[rest_base + 3u])),
+            );
+            scene_write_node_local_rotation(&scene_database, row, rest);
+        }
+    }
+
+    // ── Scale ─────────────────────────────────────────────────────
+    if (dirty & POSE_DIRTY_S_MASK) != 0u {
+        let s_base = slot_base + POSE_OFFSET_SCALE;
+        var s = scene_read_node_rw(&scene_database, row).local_scale;
+        if (dirty & POSE_DIRTY_SX) != 0u {
+            s.x = bitcast<f32>(atomicLoad(&pose_accumulator[s_base + 0u]));
+            atomicStore(&pose_accumulator[s_base + 0u], 0u);
+        }
+        if (dirty & POSE_DIRTY_SY) != 0u {
+            s.y = bitcast<f32>(atomicLoad(&pose_accumulator[s_base + 1u]));
+            atomicStore(&pose_accumulator[s_base + 1u], 0u);
+        }
+        if (dirty & POSE_DIRTY_SZ) != 0u {
+            s.z = bitcast<f32>(atomicLoad(&pose_accumulator[s_base + 2u]));
+            atomicStore(&pose_accumulator[s_base + 2u], 0u);
+        }
+        scene_write_node_local_scale(&scene_database, row, s);
+    }
+
+    // Clear the dirty mask itself last, so an interrupted resolve
+    // (theoretical — these passes don't yield) would still leave the
+    // dirty bits intact to be redone.
+    atomicStore(&pose_accumulator[dirty_word], 0u);
+}
+`, [
+        TRANSFORMS_TABLE.chunk_iterate(WORKGROUP_SIZE, true),
+        chunk_scene_database_access_rw,
+        chunk_pose_accumulator,
+    ]);
+
+/**
+ * Compute shader that drains the pose accumulator into
+ * `transforms_table.local_{translation,rotation,scale}`.
+ *
+ * Walks the transforms table via the read+write page iterator — one
+ * thread per slot. For each occupied row whose accumulator slot has
+ * any dirty bits set, reads the contributed components (atomic
+ * loads, bitcast back to f32), writes them through the per-field
+ * scene helpers, normalises rotation — or, for a rotation summing to
+ * nothing, writes the rest rotation the contributions carried — and
+ * zeros the sums and the dirty mask for next frame.
+ *
+ * The accumulator buffer must be sized to at least
+ * `transforms.dispatch_page_count * elements_per_page` rows —
+ * {@link GPUAnimationManager#ensure_pose_accumulator_capacity}
+ * handles that.
+ *
+ * Dispatch via
+ * `shader_animation_pose_resolve.dispatch({ group_count_x: transforms.dispatch_group_count(WORKGROUP_SIZE), ... })`.
+ */
+export const shader_animation_pose_resolve = ComputeShader.from({
+    label: "Animation/PoseResolve",
+    body,
+    resources,
+});

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

@@ -65,6 +65,13 @@ export class GPUMeshSkinningContext {
      * @returns {GPUBuffer|null}
      */
     get bindings_buffer(): any;
+    /**
+     * Bound {@link SkinnedMesh}es — the records {@link bindings_buffer} holds once {@link update} has
+     * uploaded them, which it does on the frame they change.
+     *
+     * @returns {number}
+     */
+    get binding_count(): number;
     /**
      * Per-meshlet base offsets into {@link prev_positions_buffer},
      * indexed by absolute meshlet metadata row. Non-clone meshlets

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

@@ -1 +1 @@
-{"version":3,"file":"GPUMeshSkinningContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/GPUMeshSkinningContext.js"],"names":[],"mappings":"AAmFA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAgNI;;;;;;;OAOG;IACH,sEAPW;QACV,UAAgB,EAAE,kBAAkB,CAAC;QACrC,iBAAuB,EAAE,mBAAmB,CAAC;QAC7C,aAAmB,EAAE,eAAe,CAAC;QACrC,MAAY,YAAY;KACrB,EAcH;IAED;;;;;;OAMG;IACH,iCAEC;IAED;;;;;;;OAOG;IACH,yCAEC;IAED;;;;;;OAMG;IACH,2BAEC;IAED;;;;;;;OAOG;IACH,wCAEC;IAED;;;;;;;;;;;;OAYG;IACH,qBAJW,MAAM,YACN,eAAe,GACb,mBAAmB,CAqB/B;IAED;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,mBAAmB,GAAC,SAAS,CAMzC;IAED;;;;;;;;;;OAUG;IACH,aAHW,MAAM,WACN,MAAM,QAwBhB;IAED;;;;;;;OAOG;IACH,oBAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAI5B;IAED;;;;;;;;;;OAUG;IACH,eAFW,MAAM,QAYhB;IAED;;;;;;;;OAQG;IACH,4BAFW,MAAM,QAUhB;IA4FD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,sBAFW,MAAM,QAqBhB;IAuBD;;;;;;;;;;;;;;;;;OAiBG;IACH,gBAJW,sBAAsB,GACpB,OAAO,CA0NnB;IAkXD;;;;;;;OAOG;IACH,gBA+BC;;CACJ;qCA/wCY,OAAO,2CAA2C,EAAE,sBAAsB;iCAC1E,OAAO,sCAAsC,EAAE,kBAAkB;8BACjE,OAAO,gCAAgC,EAAE,eAAe;8BACxD,OAAO,mCAAmC,EAAE,eAAe;kCAC3D,OAAO,uCAAuC,EAAE,mBAAmB;kCACnE,OAAO,2BAA2B,EAAE,mBAAmB"}
+{"version":3,"file":"GPUMeshSkinningContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/GPUMeshSkinningContext.js"],"names":[],"mappings":"AAmFA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAgNI;;;;;;;OAOG;IACH,sEAPW;QACV,UAAgB,EAAE,kBAAkB,CAAC;QACrC,iBAAuB,EAAE,mBAAmB,CAAC;QAC7C,aAAmB,EAAE,eAAe,CAAC;QACrC,MAAY,YAAY;KACrB,EAcH;IAED;;;;;;OAMG;IACH,iCAEC;IAED;;;;;;;OAOG;IACH,yCAEC;IAED;;;;;;OAMG;IACH,2BAEC;IAED;;;;;OAKG;IACH,4BAEC;IAED;;;;;;;OAOG;IACH,wCAEC;IAED;;;;;;;;;;;;OAYG;IACH,qBAJW,MAAM,YACN,eAAe,GACb,mBAAmB,CAqB/B;IAED;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,mBAAmB,GAAC,SAAS,CAMzC;IAED;;;;;;;;;;OAUG;IACH,aAHW,MAAM,WACN,MAAM,QAwBhB;IAED;;;;;;;OAOG;IACH,oBAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAI5B;IAED;;;;;;;;;;OAUG;IACH,eAFW,MAAM,QAYhB;IAED;;;;;;;;OAQG;IACH,4BAFW,MAAM,QAUhB;IA4FD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,sBAFW,MAAM,QAqBhB;IAuBD;;;;;;;;;;;;;;;;;OAiBG;IACH,gBAJW,sBAAsB,GACpB,OAAO,CA0NnB;IAmXD;;;;;;;OAOG;IACH,gBA+BC;;CACJ;qCA1xCY,OAAO,2CAA2C,EAAE,sBAAsB;iCAC1E,OAAO,sCAAsC,EAAE,kBAAkB;8BACjE,OAAO,gCAAgC,EAAE,eAAe;8BACxD,OAAO,mCAAmC,EAAE,eAAe;kCAC3D,OAAO,uCAAuC,EAAE,mBAAmB;kCACnE,OAAO,2BAA2B,EAAE,mBAAmB"}

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

@@ -372,6 +372,16 @@ export class GPUMeshSkinningContext {
         return this.#bindings_buffer;
     }
 
+    /**
+     * Bound {@link SkinnedMesh}es — the records {@link bindings_buffer} holds once {@link update} has
+     * uploaded them, which it does on the frame they change.
+     *
+     * @returns {number}
+     */
+    get binding_count() {
+        return this.#bindings.length;
+    }
+
     /**
      * Per-meshlet base offsets into {@link prev_positions_buffer},
      * indexed by absolute meshlet metadata row. Non-clone meshlets
@@ -1233,6 +1243,7 @@ export class GPUMeshSkinningContext {
 
             write_gpu_typed_buffer({
                 skin_matrix_offset: this.#animation_manager.get_skin_matrix_offset(b.skin_id),
+                skin_matrix_count: this.#animation_manager.get_skin_joint_count(b.skin_id),
                 source_meshlet_metadata_offset: b.source_meshlet_metadata_offset,
                 clone_meshlet_metadata_offset: b.clone_meshlet_metadata_offset,
                 meshlet_count: b.meshlet_count,

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

@@ -9,7 +9,9 @@
  *  - `skin_matrix_offset` is the skin's first joint row, read from the
  *    animation manager's {@link GPUAnimationManager#get_skin_matrix_offset}
  *    — a joint's matrix sits at its row — so the shader can index
- *    `skin_matrices` directly without dereferencing the skin record.
+ *    `skin_matrices` directly without dereferencing the skin record;
+ *    `skin_matrix_count`, its number of joints, from
+ *    {@link GPUAnimationManager#get_skin_joint_count}.
  *  - The two `*_meshlet_metadata_offset` values are the starts of the
  *    source's and clone's meshlet ranges in the meshlet metadata
  *    buffer; combined with `meshlet_count`, they bound the per-binding

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;;;;;;;;;;;;;;;;GAgBG;AACH,mDAwDsB;6BA3EO,mCAAmC"}
+{"version":3,"file":"SKINNING_BINDING_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/SKINNING_BINDING_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;GAkBG;AACH,mDA+DsB;6BApFO,mCAAmC"}

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

@@ -12,7 +12,9 @@ import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
  *  - `skin_matrix_offset` is the skin's first joint row, read from the
  *    animation manager's {@link GPUAnimationManager#get_skin_matrix_offset}
  *    — a joint's matrix sits at its row — so the shader can index
- *    `skin_matrices` directly without dereferencing the skin record.
+ *    `skin_matrices` directly without dereferencing the skin record;
+ *    `skin_matrix_count`, its number of joints, from
+ *    {@link GPUAnimationManager#get_skin_joint_count}.
  *  - The two `*_meshlet_metadata_offset` values are the starts of the
  *    source's and clone's meshlet ranges in the meshlet metadata
  *    buffer; combined with `meshlet_count`, they bound the per-binding
@@ -26,6 +28,13 @@ export const SKINNING_BINDING_STRUCT = WebGPUStruct.from({
      */
     skin_matrix_offset: u32,
 
+    /**
+     * How many joints the skin has: its matrices are `skin_matrix_count` rows from
+     * `skin_matrix_offset`. The skinning shader needs no count — a vertex names its joints — but a
+     * pass over the skin's pose does, such as the virtual shadow map's test of whether it moved.
+     */
+    skin_matrix_count: u32,
+
     /**
      * First source meshlet record in the meshlet metadata buffer. The
      * skinning shader reads attributes (position / normal / tangent /

package/src/shade/renderer/buffer/table/serde/table_wgsl_gen_read_code.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"table_wgsl_gen_read_code.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/buffer/table/serde/table_wgsl_gen_read_code.js"],"names":[],"mappings":"AAyKA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,uEAZW,MAAM,eACN,MAAM,qBAEJ,IAAI,CA8BhB"}
+{"version":3,"file":"table_wgsl_gen_read_code.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/buffer/table/serde/table_wgsl_gen_read_code.js"],"names":[],"mappings":"AAqMA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,uEAZW,MAAM,eACN,MAAM,qBAEJ,IAAI,CA8BhB"}

package/src/shade/renderer/buffer/table/serde/table_wgsl_gen_read_code.js

@@ -1,13 +1,17 @@
 import { assert } from "../../../../../core/assert.js";
 import {
     f32,
+    i32,
     mat4x4f,
     u32,
     vec2f,
+    vec2i,
     vec2u,
     vec3f,
+    vec3i,
     vec3u,
     vec4f,
+    vec4i,
     vec4u
 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 
@@ -50,6 +54,30 @@ function table_wgsl_gen_read_code_primitive(
         case f32:
             builder.extend(`bitcast<f32>(${buffer_name}[base_offset + ${offset}])`);
             return;
+        case i32:
+            builder.extend(`bitcast<i32>(${buffer_name}[base_offset + ${offset}])`);
+            return;
+        case vec2i:
+            builder.extend(`vec2<i32>(`);
+            builder.indent();
+            read_multiple(builder, offset, buffer_name, i32, 2);
+            builder.dedent();
+            builder.extend(')');
+            return;
+        case vec3i:
+            builder.extend(`vec3<i32>(`);
+            builder.indent();
+            read_multiple(builder, offset, buffer_name, i32, 3);
+            builder.dedent();
+            builder.extend(')');
+            return;
+        case vec4i:
+            builder.extend(`vec4<i32>(`);
+            builder.indent();
+            read_multiple(builder, offset, buffer_name, i32, 4);
+            builder.dedent();
+            builder.extend(')');
+            return;
         case vec2f:
             builder.extend(`vec2<f32>(`);
             builder.indent();

package/src/shade/renderer/buffer/table/serde/table_wgsl_gen_write_code.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"table_wgsl_gen_write_code.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/buffer/table/serde/table_wgsl_gen_write_code.js"],"names":[],"mappings":"AAoHA;;;;;;;;;;;;;;GAcG;AACH,wEANW,MAAM,eACN,MAAM,iCAEN,MAAM,GACJ,IAAI,CAyBhB"}
+{"version":3,"file":"table_wgsl_gen_write_code.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/buffer/table/serde/table_wgsl_gen_write_code.js"],"names":[],"mappings":"AAkJA;;;;;;;;;;;;;;GAcG;AACH,wEANW,MAAM,eACN,MAAM,iCAEN,MAAM,GACJ,IAAI,CAyBhB"}

package/src/shade/renderer/buffer/table/serde/table_wgsl_gen_write_code.js

@@ -1,5 +1,19 @@
 import { assert } from "../../../../../core/assert.js";
-import { f32, mat4x4f, u32, vec2f, vec2u, vec3f, vec3u, vec4f, vec4u } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import {
+    f32,
+    i32,
+    mat4x4f,
+    u32,
+    vec2f,
+    vec2i,
+    vec2u,
+    vec3f,
+    vec3i,
+    vec3u,
+    vec4f,
+    vec4i,
+    vec4u
+} from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 
 /**
  *
@@ -21,8 +35,24 @@ function table_wgsl_gen_write_code_primitive(
             builder.add(`${buffer_name}[base_offset + ${offset}] = ${value_expr};`);
             return;
         case f32:
+        case i32:
             builder.add(`${buffer_name}[base_offset + ${offset}] = bitcast<u32>(${value_expr});`);
             return;
+        case vec2i:
+            for (let i = 0; i < 2; i++) {
+                table_wgsl_gen_write_code_primitive(builder, offset + i, buffer_name, i32, `${value_expr}[${i}]`);
+            }
+            return;
+        case vec3i:
+            for (let i = 0; i < 3; i++) {
+                table_wgsl_gen_write_code_primitive(builder, offset + i, buffer_name, i32, `${value_expr}[${i}]`);
+            }
+            return;
+        case vec4i:
+            for (let i = 0; i < 4; i++) {
+                table_wgsl_gen_write_code_primitive(builder, offset + i, buffer_name, i32, `${value_expr}[${i}]`);
+            }
+            return;
         case vec2f:
             for (let i = 0; i < 2; i++) {
                 table_wgsl_gen_write_code_primitive(builder, offset + i, buffer_name, f32, `${value_expr}[${i}]`);

package/src/shade/renderer/geometry/MeshletGeometry.d.ts

@@ -35,5 +35,8 @@ export class MeshletGeometry {
     equals(other: MeshletGeometry): boolean;
     isMeshletGeometry: boolean;
 }
+export namespace MeshletGeometry {
+    let typeName: string;
+}
 import { MeshletBatch } from "./meshlet/MeshletBatch.js";
 //# sourceMappingURL=MeshletGeometry.d.ts.map

package/src/shade/renderer/geometry/MeshletGeometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MeshletGeometry.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/geometry/MeshletGeometry.js"],"names":[],"mappings":"AAIA;;;GAGG;AACH;IACI,WAAkB;IAElB;;;OAGG;IACH,MAFU,MAAM,CAEN;IAEV,2BAAmC;IACnC,8BAAsC;IAEtC;;;OAGG;IACH,iBAFU,MAAM,CAEI;IAEpB,wBAGC;IAED;;OAEG;IACH,UAFU,YAAY,CAEQ;IAE9B;;;;OAIG;IACH,KAFU,WAAW,CAEG;IAExB,eAEC;IAED;;;OAGG;IACH,cAFW,eAAe,WAMzB;IAGL,2BAA2C;CAF1C;6BAxD4B,2BAA2B"}
+{"version":3,"file":"MeshletGeometry.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/geometry/MeshletGeometry.js"],"names":[],"mappings":"AAIA;;;GAGG;AACH;IACI,WAAkB;IAElB;;;OAGG;IACH,MAFU,MAAM,CAEN;IAEV,2BAAmC;IACnC,8BAAsC;IAEtC;;;OAGG;IACH,iBAFU,MAAM,CAEI;IAEpB,wBAGC;IAED;;OAEG;IACH,UAFU,YAAY,CAEQ;IAE9B;;;;OAIG;IACH,KAFU,WAAW,CAEG;IAExB,eAEC;IAED;;;OAGG;IACH,cAFW,eAAe,WAMzB;IAGL,2BAA2C;CAF1C;;;;6BAxD4B,2BAA2B"}

package/src/shade/renderer/geometry/MeshletGeometry.js

@@ -57,4 +57,5 @@ export class MeshletGeometry {
 }
 
 MeshletGeometry.prototype.isMeshletGeometry = true;
+MeshletGeometry.typeName = "MeshletGeometry";
 

package/src/shade/renderer/light/LIGHT_DATABASE_SPEC.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LIGHT_DATABASE_SPEC.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/light/LIGHT_DATABASE_SPEC.js"],"names":[],"mappings":"AAUA,wDAiBG;sCA1BmC,0CAA0C"}
+{"version":3,"file":"LIGHT_DATABASE_SPEC.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/light/LIGHT_DATABASE_SPEC.js"],"names":[],"mappings":"AAYA,wDAkCG;sCA7CmC,0CAA0C"}