@woosh/meep-engine 3.11.3 → 3.13.0

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":"AA0EA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IA2MI;;;;;;;OAOG;IACH,sEAPW;QACV,UAAgB,qBAAqB;QACrC,iBAAuB,sBAAsB;QAC7C,aAAmB,kBAAkB;QACrC,MAAY,YAAY;KACrB,EAYH;IAED;;;;;;OAMG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,2BAEC;IAED;;;;;;;OAOG;IACH,wCAEC;IAED;;;;;;;;;;;;;;OAcG;IACH,mCAFa,MAAM,CAelB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,iCAFW,MAAM,QAmBhB;IAED;;;;;;;OAOG;IACH,gCAFa,MAAM,GAAC,SAAS,CAI5B;IAED;;;;;;;;;;OAUG;IACH,gCAYC;IAED;;;;;;;;OAQG;IACH,4BAFW,MAAM,QAYhB;IAyCD;;;;;;;;;;;;;;;OAeG;IACH,8CA2NC;IAsSD,gBAiBC;;CACJ"}
+{"version":3,"file":"GPUMeshSkinningContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/GPUMeshSkinningContext.js"],"names":[],"mappings":"AAyEA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IA2MI;;;;;;;OAOG;IACH,sEAPW;QACV,UAAgB,qBAAqB;QACrC,iBAAuB,sBAAsB;QAC7C,aAAmB,kBAAkB;QACrC,MAAY,YAAY;KACrB,EAYH;IAED;;;;;;OAMG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,2BAEC;IAED;;;;;;;OAOG;IACH,wCAEC;IAED;;;;;;;;;;;;;;OAcG;IACH,mCAFa,MAAM,CAelB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,iCAFW,MAAM,QAmBhB;IAED;;;;;;;OAOG;IACH,gCAFa,MAAM,GAAC,SAAS,CAI5B;IAED;;;;;;;;;;OAUG;IACH,gCAYC;IAED;;;;;;;;OAQG;IACH,4BAFW,MAAM,QAYhB;IAyCD;;;;;;;;;;;;;;;OAeG;IACH,8CAkNC;IAsSD,gBAiBC;;CACJ"}

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

@@ -1,5 +1,4 @@
 import { assert } from "../../../../core/assert.js";
-import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { write_gpu_typed_buffer } from "../../shader/type/serde/write_gpu_typed_buffer.js";
 import {
     shader_geometry_sphere_derive,
@@ -600,13 +599,11 @@ export class GPUMeshSkinningContext {
         // work is identical to a single huge dispatch.
         for (let offset = 0; offset < total; offset += max_workgroups) {
             const this_chunk = Math.min(max_workgroups, total - offset);
-            const dispatch_offset = cmd_ctx.allocateTransientValueBuffer(u32, offset);
-
             shader_meshlet_apply_skinning.dispatch({
                 encoder: cmd_ctx,
                 group_count_x: this_chunk,
                 bindings: {
-                    dispatch_offset,
+                    dispatch_offset: offset,
                     meshlet_data: meshlets.buffer_data,
                     meshlet_metadata: meshlets.buffer_metadata,
                     skin_matrices: this.#animation_manager.skin_matrices_buffer,
@@ -657,17 +654,14 @@ export class GPUMeshSkinningContext {
                 const this_chunk = Math.min(max_workgroups, total_workgroups - offset_wg);
                 // dispatch_offset is in *pair* units for scatter — the
                 // shader does `gid.x + dispatch_offset`.
-                const dispatch_offset = cmd_ctx.allocateTransientValueBuffer(
-                    u32,
-                    offset_wg * BOUNDS_SCATTER_WORKGROUP_SIZE
-                );
-                const total_pair_count = cmd_ctx.allocateTransientValueBuffer(u32, total);
                 shader_meshlet_bounds_scatter.dispatch({
                     encoder: cmd_ctx,
                     group_count_x: this_chunk,
                     bindings: {
-                        dispatch_offset,
-                        total_pair_count,
+                        settings: {
+                            dispatch_offset: offset_wg * BOUNDS_SCATTER_WORKGROUP_SIZE,
+                            total_pair_count: total,
+                        },
                         skinning_bindings: this.#bindings_buffer,
                         dispatch_lookup: this.#dispatch_lookup_buffer,
                         meshlet_metadata_atomic: meshlets.buffer_metadata,
@@ -682,13 +676,11 @@ export class GPUMeshSkinningContext {
         // skinning; same pagination.
         for (let offset = 0; offset < total; offset += max_workgroups) {
             const this_chunk = Math.min(max_workgroups, total - offset);
-            const dispatch_offset = cmd_ctx.allocateTransientValueBuffer(u32, offset);
-
             shader_meshlet_bounds_reduce.dispatch({
                 encoder: cmd_ctx,
                 group_count_x: this_chunk,
                 bindings: {
-                    dispatch_offset,
+                    dispatch_offset: offset,
                     skinning_bindings: this.#bindings_buffer,
                     dispatch_lookup: this.#dispatch_lookup_buffer,
                     meshlet_data: meshlets.buffer_data,
@@ -705,12 +697,11 @@ export class GPUMeshSkinningContext {
         {
             const total_workgroups = Math.ceil(binding_count / SPHERE_DERIVE_WORKGROUP_SIZE);
             if (total_workgroups > 0) {
-                const binding_count_u = cmd_ctx.allocateTransientValueBuffer(u32, binding_count);
                 shader_geometry_sphere_derive.dispatch({
                     encoder: cmd_ctx,
                     group_count_x: total_workgroups,
                     bindings: {
-                        binding_count: binding_count_u,
+                        binding_count,
                         skinning_bindings: this.#bindings_buffer,
                         geometry_metadata_atomic: geometry_metadata_buffer,
                     },
@@ -725,12 +716,11 @@ export class GPUMeshSkinningContext {
         {
             const total_workgroups = Math.ceil(binding_count / MESH_BOUNDS_REFRESH_WORKGROUP_SIZE);
             if (total_workgroups > 0) {
-                const binding_count_u = cmd_ctx.allocateTransientValueBuffer(u32, binding_count);
                 shader_skinned_mesh_bounds_refresh.dispatch({
                     encoder: cmd_ctx,
                     group_count_x: total_workgroups,
                     bindings: {
-                        binding_count: binding_count_u,
+                        binding_count,
                         skinning_bindings: this.#bindings_buffer,
                         scene_database: scene_database_buffer,
                         geometries: geometry_metadata_buffer,

package/src/shade/renderer/animation/skinning/bounds_refresh/shader_geometry_sphere_derive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_geometry_sphere_derive.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/animation/skinning/bounds_refresh/shader_geometry_sphere_derive.js"],"names":[],"mappings":"AAQA,gCAAiC;AAsEjC;;;;;;;;;;;;;;GAcG;AACH,0DAKG;8BA9F2B,kCAAkC"}
+{"version":3,"file":"shader_geometry_sphere_derive.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/animation/skinning/bounds_refresh/shader_geometry_sphere_derive.js"],"names":[],"mappings":"AAQA,gCAAiC;AAwEjC;;;;;;;;;;;;;;GAcG;AACH,0DAIG;8BA/F2B,kCAAkC"}

package/src/shade/renderer/animation/skinning/bounds_refresh/shader_geometry_sphere_derive.js

@@ -13,11 +13,13 @@ const GEOMETRY_SPHERE_OFFSET_WORDS = GEOMETRY_METADATA_STRUCT.get('bounding_sphe
 const GEOMETRY_STRIDE_WORDS = GEOMETRY_METADATA_STRUCT.size / 4;
 
 const resources = new ShaderResourceSetDescriptor();
+
+// per-dispatch, four bytes, read-only: immediate data rather than a uniform buffer
+resources.setImmediate("binding_count", u32);
 resources.createGroup()
     // Number of active skinning bindings. Threads past `binding_count`
     // early-out (the dispatch is sized to `ceil(binding_count/64)`
     // workgroups, so the tail can have up to 63 idle threads).
-    .addUniform('binding_count', u32)
     .addStorageBuffer('skinning_bindings', WebGPUArray.from(SKINNING_BINDING_STRUCT), false)
     // Same buffer the rasterizer reads as a typed struct array; we
     // atomicLoad the freshly-merged `bounding_box` cells and
@@ -95,5 +97,4 @@ export const shader_geometry_sphere_derive = ComputeShader.from({
     label: "Skinning/GeometrySphereDerive",
     resources,
     body,
-    group_size: [WORKGROUP_SIZE, 1, 1],
 });

package/src/shade/renderer/animation/skinning/bounds_refresh/shader_meshlet_bounds_reduce.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_meshlet_bounds_reduce.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/animation/skinning/bounds_refresh/shader_meshlet_bounds_reduce.js"],"names":[],"mappings":"AAUA;;;;;;;GAOG;AACH,gCAAiC;AAmKjC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,yDAKG;8BA/M2B,kCAAkC"}
+{"version":3,"file":"shader_meshlet_bounds_reduce.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/animation/skinning/bounds_refresh/shader_meshlet_bounds_reduce.js"],"names":[],"mappings":"AAUA;;;;;;;GAOG;AACH,gCAAiC;AAsKjC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,yDAIG;8BAjN2B,kCAAkC"}

package/src/shade/renderer/animation/skinning/bounds_refresh/shader_meshlet_bounds_reduce.js

@@ -32,11 +32,14 @@ const GEOMETRY_BBOX_OFFSET_WORDS = GEOMETRY_METADATA_STRUCT.get('bounding_box').
 const GEOMETRY_STRIDE_WORDS = GEOMETRY_METADATA_STRUCT.size / 4;
 
 const resources = new ShaderResourceSetDescriptor();
+
+// per-dispatch, four bytes, read-only: immediate data rather than a uniform buffer, allocated once
+// per paginated sub-dispatch
+resources.setImmediate("dispatch_offset", u32);
 resources.createGroup()
     // First-workgroup offset in this sub-dispatch (workgroup units).
     // One workgroup per pair, so this matches the skinning shader's
     // `dispatch_offset` semantic.
-    .addUniform('dispatch_offset', u32)
     .addStorageBuffer('skinning_bindings', WebGPUArray.from(SKINNING_BINDING_STRUCT), false)
     .addStorageBuffer('dispatch_lookup', WebGPUArray.from(u32), false)
     // Clone vertex data: positions live at `address + index_section_size`
@@ -209,5 +212,4 @@ export const shader_meshlet_bounds_reduce = ComputeShader.from({
     label: "Skinning/MeshletBoundsReduce",
     resources,
     body,
-    group_size: [WORKGROUP_SIZE, 1, 1],
 });

package/src/shade/renderer/animation/skinning/bounds_refresh/shader_meshlet_bounds_scatter.d.ts

@@ -7,7 +7,7 @@ export const WORKGROUP_SIZE: 64;
  * Linear-thread dispatch: one thread per (binding, meshlet) pair in
  * the skinning context's `dispatch_lookup`. With workgroup size 64,
  * `ceil(total_pair_count / 64)` workgroups cover everything; the
- * `dispatch_offset` uniform lets the host paginate when
+ * `settings.dispatch_offset` immediate lets the host paginate when
  * `total_pair_count > maxComputeWorkgroupsPerDimension * 64`
  * (currently won't trigger — 65535 * 64 ≈ 4M pairs).
  *

package/src/shade/renderer/animation/skinning/bounds_refresh/shader_meshlet_bounds_scatter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_meshlet_bounds_scatter.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/animation/skinning/bounds_refresh/shader_meshlet_bounds_scatter.js"],"names":[],"mappings":"AASA,gCAAiC;AAwFjC;;;;;;;;;;;;;;;;;GAiBG;AACH,0DAKG;8BAnH2B,kCAAkC"}
+{"version":3,"file":"shader_meshlet_bounds_scatter.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/animation/skinning/bounds_refresh/shader_meshlet_bounds_scatter.js"],"names":[],"mappings":"AAUA,gCAAiC;AAsGjC;;;;;;;;;;;;;;;;;GAiBG;AACH,0DAIG;8BAhI2B,kCAAkC"}

package/src/shade/renderer/animation/skinning/bounds_refresh/shader_meshlet_bounds_scatter.js

@@ -1,5 +1,6 @@
 import { atomic_u32, 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 { MESHLET_METADATA_STRUCT } from "../../../geometry/meshlet/encoding/MESHLET_METADATA_STRUCT.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
@@ -20,14 +21,28 @@ const MESHLET_STRIDE_WORDS = MESHLET_METADATA_STRUCT.size / 4;
 const GEOMETRY_BBOX_OFFSET_WORDS = GEOMETRY_METADATA_STRUCT.get('bounding_box').offset / 4;
 const GEOMETRY_STRIDE_WORDS = GEOMETRY_METADATA_STRUCT.size / 4;
 
+/**
+ * Per-dispatch, eight bytes, read-only.
+ *
+ * `dispatch_offset` is the sub-dispatch's first-pair offset, in pair units. The host paginates if
+ * `total_pair_count > maxComputeWorkgroupsPerDimension * WORKGROUP_SIZE`; under typical stress-test
+ * scale (~71k pairs) a single sub-dispatch suffices and `dispatch_offset` is zero.
+ *
+ * The two were separate u32 uniforms, so two transient buffers per sub-dispatch. WGSL allows one
+ * immediate per entry point, so carrying them as immediate data means carrying them together.
+ *
+ * @type {WebGPUStruct}
+ */
+const SCATTER_SETTINGS = WebGPUStruct.from({
+    dispatch_offset: u32,
+    total_pair_count: u32,
+}, 'MeshletBoundsScatterSettings');
+
 const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate('settings', SCATTER_SETTINGS);
+
 resources.createGroup()
-    // Sub-dispatch first-pair offset, in pair units. The host
-    // paginates if `total_pair_count > maxComputeWorkgroupsPerDimension
-    // * WORKGROUP_SIZE`; under typical stress-test scale (~71k pairs)
-    // a single sub-dispatch suffices and `dispatch_offset` is zero.
-    .addUniform('dispatch_offset', u32)
-    .addUniform('total_pair_count', u32)
     .addStorageBuffer('skinning_bindings', WebGPUArray.from(SKINNING_BINDING_STRUCT), false)
     .addStorageBuffer('dispatch_lookup', WebGPUArray.from(u32), false)
     // Same buffers the rasterizer reads as typed structs, bound here
@@ -49,8 +64,8 @@ const GEOMETRY_STRIDE: u32        = ${GEOMETRY_STRIDE_WORDS}u;
 
 @compute @workgroup_size(${WORKGROUP_SIZE},1,1)
 fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let pair_index = gid.x + dispatch_offset;
-    if pair_index >= total_pair_count {
+    let pair_index = gid.x + settings.dispatch_offset;
+    if pair_index >= settings.total_pair_count {
         return;
     }
 
@@ -103,7 +118,7 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
  * Linear-thread dispatch: one thread per (binding, meshlet) pair in
  * the skinning context's `dispatch_lookup`. With workgroup size 64,
  * `ceil(total_pair_count / 64)` workgroups cover everything; the
- * `dispatch_offset` uniform lets the host paginate when
+ * `settings.dispatch_offset` immediate lets the host paginate when
  * `total_pair_count > maxComputeWorkgroupsPerDimension * 64`
  * (currently won't trigger — 65535 * 64 ≈ 4M pairs).
  *
@@ -117,5 +132,4 @@ export const shader_meshlet_bounds_scatter = ComputeShader.from({
     label: "Skinning/MeshletBoundsScatter",
     resources,
     body,
-    group_size: [WORKGROUP_SIZE, 1, 1],
 });

package/src/shade/renderer/animation/skinning/bounds_refresh/shader_skinned_mesh_bounds_refresh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_skinned_mesh_bounds_refresh.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/animation/skinning/bounds_refresh/shader_skinned_mesh_bounds_refresh.js"],"names":[],"mappings":"AAWA,gCAAiC;AAuCjC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,+DAKG;8BApE2B,kCAAkC"}
+{"version":3,"file":"shader_skinned_mesh_bounds_refresh.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/animation/skinning/bounds_refresh/shader_skinned_mesh_bounds_refresh.js"],"names":[],"mappings":"AAWA,gCAAiC;AAyCjC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,+DAIG;8BArE2B,kCAAkC"}

package/src/shade/renderer/animation/skinning/bounds_refresh/shader_skinned_mesh_bounds_refresh.js

@@ -12,10 +12,12 @@ import { SKINNING_BINDING_STRUCT } from "../SKINNING_BINDING_STRUCT.js";
 export const WORKGROUP_SIZE = 64;
 
 const resources = new ShaderResourceSetDescriptor();
+
+// per-dispatch, four bytes, read-only: immediate data rather than a uniform buffer
+resources.setImmediate("binding_count", u32);
 resources.createGroup()
     // Number of active skinning bindings (= one per skinned mesh
     // instance). Threads past `binding_count` early-out.
-    .addUniform('binding_count', u32)
     .addStorageBuffer('skinning_bindings', WebGPUArray.from(SKINNING_BINDING_STRUCT), false)
     // `chunk_update_object_property_mesh_instance_bounds` expects
     // these binding names — see its docstring's importing-shader
@@ -72,5 +74,4 @@ export const shader_skinned_mesh_bounds_refresh = ComputeShader.from({
     label: "Skinning/SkinnedMeshBoundsRefresh",
     resources,
     body,
-    group_size: [WORKGROUP_SIZE, 1, 1],
 });

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

@@ -1 +1 @@
-{"version":3,"file":"shader_meshlet_apply_skinning.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/shader_meshlet_apply_skinning.js"],"names":[],"mappings":"AAqCA;;;;GAIG;AACH,yCAA0C;AA6S1C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,0DAKG;8BAnV2B,+BAA+B"}
+{"version":3,"file":"shader_meshlet_apply_skinning.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/shader_meshlet_apply_skinning.js"],"names":[],"mappings":"AAqCA;;;;GAIG;AACH,yCAA0C;AAiT1C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,0DAIG;8BAtV2B,+BAA+B"}

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

@@ -43,6 +43,11 @@ import { SKINNING_BINDING_STRUCT } from "./SKINNING_BINDING_STRUCT.js";
 export const SKINNING_WORKGROUP_SIZE = 64;
 
 const resources = new ShaderResourceSetDescriptor();
+
+// per-dispatch, four bytes, read-only: immediate data rather than a uniform buffer. Skinning is
+// paginated into sub-dispatches when the workload exceeds maxComputeWorkgroupsPerDimension, so the
+// buffer was allocated once per chunk to carry one integer.
+resources.setImmediate("dispatch_offset", u32);
 resources.createGroup()
     // First workgroup of the current sub-dispatch. WebGPU caps
     // `dispatchWorkgroups` along each dimension at the device's
@@ -52,7 +57,6 @@ resources.createGroup()
     // between them. The shader adds it to `wg_id.x` before indexing
     // `dispatch_lookup`, so the per-pair mapping stays a flat array
     // regardless of how many sub-dispatches it gets split into.
-    .addUniform('dispatch_offset', u32)
     .addStorageBuffer('meshlet_data', WebGPUArray.from(u32), true)
     .addStorageBuffer('meshlet_metadata', WebGPUArray.from(MESHLET_METADATA_STRUCT), false)
     .addStorageBuffer('skin_matrices', WebGPUArray.from(mat4x4f), false)
@@ -368,5 +372,4 @@ export const shader_meshlet_apply_skinning = ComputeShader.from({
     label: "Skinning/MeshletApplySkinning",
     resources,
     body,
-    group_size: [SKINNING_WORKGROUP_SIZE, 1, 1],
 });

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

@@ -1 +1 @@
-{"version":3,"file":"shader_skin_matrix_prep.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/shader_skin_matrix_prep.js"],"names":[],"mappings":"AAUA;;;;;;GAMG;AACH,gCAAiC;AAiEjC;;;;;;;;;;;;;;;;GAgBG;AACH,oDAKG;8BApG2B,+BAA+B"}
+{"version":3,"file":"shader_skin_matrix_prep.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/shader_skin_matrix_prep.js"],"names":[],"mappings":"AAUA;;;;;;GAMG;AACH,gCAAiC;AAiEjC;;;;;;;;;;;;;;;;GAgBG;AACH,oDAIG;8BAnG2B,+BAA+B"}

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

@@ -1,105 +1,104 @@
-import { mat4x4f, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { chunk_scene_database_access } from "../../scene/chunk_scene_database_access.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import { ANIMATION_DATABASE_SPEC } from "../ANIMATION_DATABASE_SPEC.js";
-
-const SKIN_JOINT_BLOCK_TABLE = ANIMATION_DATABASE_SPEC.get('animation_skin_joint_blocks');
-
-/**
- * Workgroup size for the skin-matrix-prep pass. Exported so dispatchers
- * can pair it with
- * `animation_skin_joint_blocks.dispatch_group_count(WORKGROUP_SIZE)` —
- * the page iterator's slot-to-workgroup mapping is computed against
- * this value, so the two must agree.
- */
-export const WORKGROUP_SIZE = 64;
-
-const PG_PREFIX = SKIN_JOINT_BLOCK_TABLE.page_iterator_symbol_prefix(WORKGROUP_SIZE);
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addStorageBuffer('animation_database', WebGPUArray.from(u32), false)
-    .addStorageBuffer('scene_database', WebGPUArray.from(u32), false)
-    .addStorageBuffer('skin_matrices', WebGPUArray.from(mat4x4f), true);
-
-// One thread per joint-block slot — page iterator handles allocation/
-// occupancy. Each thread loads its block, then walks its inline joints
-// in a bounded inner loop. The block carries the absolute write
-// offset into `skin_matrices` (baked at registration time), so there's
-// no indirection back through the skin record.
-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(&animation_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;
-    }
-
-    let block = ${PG_PREFIX}_read(&animation_database, slot_in_page);
-
-    // Per-joint skin matrix is just joint-world × inverse-bind. The
-    // inverse-bind already takes a vertex from mesh-local space into
-    // joint-bind-local, so joint.global brings the deformed vertex
-    // back into world. The rasterizer then re-applies
-    // mesh.transform_global to the clone vertex (same path used for
-    // every other mesh's vertices, see chunk_mesh_resolve_vertex_
-    // position_world.js) — so any mesh-node factor in this formula
-    // would double-cancel against that re-application and shrink the
-    // rig back to mesh-local coordinates rendered as world. Keeping
-    // the formula minimal lets the SkinnedMesh sit at any transform
-    // in the scene graph and still render correctly via the standard
-    // mesh transform path.
-
-    for(var i = 0u; i < block.count; i++){
-        let joint = block.joints[i];
-        let node = scene_read_node(&scene_database, joint.node);
-
-        skin_matrices[block.skin_matrix_offset + i] =
-            node.global * joint.inverse_bind;
-    }
-}
-`, [
-        SKIN_JOINT_BLOCK_TABLE.chunk_iterate(WORKGROUP_SIZE),
-        chunk_scene_database_access,
-    ]
-);
-
-/**
- * Compute shader that walks the `animation_skin_joint_blocks` table —
- * one thread per joint-block slot via the page iterator — and writes
- * each joint's per-frame skinning matrix `node.global * inverse_bind`
- * to the shared `skin_matrices` scratch buffer at the block's pre-baked
- * absolute offset.
- *
- * Run after `graph_scene_update_transform_hierarchy` (so each joint's
- * `node.global` is up to date) and before any pass that consumes the
- * skin matrices (the pre-skinning compute pass).
- *
- * Dispatch via
- * `shader_skin_matrix_prep.dispatch({ group_count_x: animation_skin_joint_blocks.dispatch_group_count(WORKGROUP_SIZE), ... })`.
- * Skip the dispatch when `group_count_x === 0` — no skins registered
- * means the iterator has no work and `skin_matrices_buffer` may be
- * `null` on the manager.
- */
-export const shader_skin_matrix_prep = ComputeShader.from({
-    label: "Animation/SkinMatrixPrep",
-    body,
-    resources,
-    group_size: [WORKGROUP_SIZE, 1, 1],
-});
+import { mat4x4f, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { chunk_scene_database_access } from "../../scene/chunk_scene_database_access.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { ANIMATION_DATABASE_SPEC } from "../ANIMATION_DATABASE_SPEC.js";
+
+const SKIN_JOINT_BLOCK_TABLE = ANIMATION_DATABASE_SPEC.get('animation_skin_joint_blocks');
+
+/**
+ * Workgroup size for the skin-matrix-prep pass. Exported so dispatchers
+ * can pair it with
+ * `animation_skin_joint_blocks.dispatch_group_count(WORKGROUP_SIZE)` —
+ * the page iterator's slot-to-workgroup mapping is computed against
+ * this value, so the two must agree.
+ */
+export const WORKGROUP_SIZE = 64;
+
+const PG_PREFIX = SKIN_JOINT_BLOCK_TABLE.page_iterator_symbol_prefix(WORKGROUP_SIZE);
+
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup()
+    .addStorageBuffer('animation_database', WebGPUArray.from(u32), false)
+    .addStorageBuffer('scene_database', WebGPUArray.from(u32), false)
+    .addStorageBuffer('skin_matrices', WebGPUArray.from(mat4x4f), true);
+
+// One thread per joint-block slot — page iterator handles allocation/
+// occupancy. Each thread loads its block, then walks its inline joints
+// in a bounded inner loop. The block carries the absolute write
+// offset into `skin_matrices` (baked at registration time), so there's
+// no indirection back through the skin record.
+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(&animation_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;
+    }
+
+    let block = ${PG_PREFIX}_read(&animation_database, slot_in_page);
+
+    // Per-joint skin matrix is just joint-world × inverse-bind. The
+    // inverse-bind already takes a vertex from mesh-local space into
+    // joint-bind-local, so joint.global brings the deformed vertex
+    // back into world. The rasterizer then re-applies
+    // mesh.transform_global to the clone vertex (same path used for
+    // every other mesh's vertices, see chunk_mesh_resolve_vertex_
+    // position_world.js) — so any mesh-node factor in this formula
+    // would double-cancel against that re-application and shrink the
+    // rig back to mesh-local coordinates rendered as world. Keeping
+    // the formula minimal lets the SkinnedMesh sit at any transform
+    // in the scene graph and still render correctly via the standard
+    // mesh transform path.
+
+    for(var i = 0u; i < block.count; i++){
+        let joint = block.joints[i];
+        let node = scene_read_node(&scene_database, joint.node);
+
+        skin_matrices[block.skin_matrix_offset + i] =
+            node.global * joint.inverse_bind;
+    }
+}
+`, [
+        SKIN_JOINT_BLOCK_TABLE.chunk_iterate(WORKGROUP_SIZE),
+        chunk_scene_database_access,
+    ]
+);
+
+/**
+ * Compute shader that walks the `animation_skin_joint_blocks` table —
+ * one thread per joint-block slot via the page iterator — and writes
+ * each joint's per-frame skinning matrix `node.global * inverse_bind`
+ * to the shared `skin_matrices` scratch buffer at the block's pre-baked
+ * absolute offset.
+ *
+ * Run after `graph_scene_update_transform_hierarchy` (so each joint's
+ * `node.global` is up to date) and before any pass that consumes the
+ * skin matrices (the pre-skinning compute pass).
+ *
+ * Dispatch via
+ * `shader_skin_matrix_prep.dispatch({ group_count_x: animation_skin_joint_blocks.dispatch_group_count(WORKGROUP_SIZE), ... })`.
+ * Skip the dispatch when `group_count_x === 0` — no skins registered
+ * means the iterator has no work and `skin_matrices_buffer` may be
+ * `null` on the manager.
+ */
+export const shader_skin_matrix_prep = ComputeShader.from({
+    label: "Animation/SkinMatrixPrep",
+    body,
+    resources,
+});

package/src/shade/renderer/atmosphere/shader_multiscatter_lut.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_multiscatter_lut.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/shader_multiscatter_lut.js"],"names":[],"mappings":"AA+JA,oDAKG;8BAhK2B,4BAA4B"}
+{"version":3,"file":"shader_multiscatter_lut.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/shader_multiscatter_lut.js"],"names":[],"mappings":"AA+JA,oDAIG;8BA/J2B,4BAA4B"}

package/src/shade/renderer/atmosphere/shader_multiscatter_lut.js

@@ -161,5 +161,4 @@ export const shader_multiscatter_lut = ComputeShader.from({
     label: "Sky / multi-scatter LUT",
     body,
     resources,
-    group_size: [MULTISCATTER_LUT_DIRECTION_COUNT, 1, 1],
 });

package/src/shade/renderer/atmosphere/shader_transmittance_lut.js

@@ -20,9 +20,9 @@ const TRANSMITTANCE_LUT_SETTINGS_STRUCT = WebGPUStruct.from({
 });
 
 const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addUniform("settings", TRANSMITTANCE_LUT_SETTINGS_STRUCT)
-;
+
+// per-pass, 16 bytes, read-only: immediate data rather than a uniform buffer
+resources.setImmediate("settings", TRANSMITTANCE_LUT_SETTINGS_STRUCT);
 
 /**
  * @see https://www.shadertoy.com/view/slSXRW