@woosh/meep-engine 3.11.3 → 3.12.0

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/buffer/graph_inspect_gpu_buffer.js

@@ -1,137 +1,137 @@
-import { assert } from "../../../core/assert.js";
-import { BufferResourceDescriptor } from "../../device/graph/BufferResourceDescriptor.js";
-import { u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { inspect_gpu_buffer_typed } from "./inspect_gpu_buffer_typed.js";
-import { shader_buffer_copy_storage_to_storage } from "./util/shader_buffer_copy_storage_to_storage.js";
-
-/**
- *
- * @param {FrameGraph} graph
- * @param {number} buffer
- * @param {WebGPUType} type
- * @param {number} [offset] byte offset where to start reading
- * @param {number} [count] optional number of members of given type to read, if not specified will read the entire buffer
- * @param {function([])} callback
- */
-export function graph_inspect_gpu_buffer({
-                                             graph,
-                                             buffer,
-                                             type,
-                                             offset = 0,
-                                             count,
-                                             callback
-                                         }) {
-
-
-    /**
-     *
-     * @param data
-     * @param {FramePassResources} resources
-     * @param {GraphicsExecutionContext} context
-     */
-    function execute(data, resources, context) {
-        /**
-         * @type {GPUBuffer}
-         */
-        let source = resources.get(data.input);
-
-        const graphics = context.graphics;
-
-        let copy_size;
-        if (count !== undefined) {
-            assert.isNonNegativeInteger(count, 'count');
-            copy_size = count * type.size;
-        } else {
-            copy_size = source.size - offset;
-        }
-
-        let _offset = offset;
-
-
-        // take a snapshot of the buffer
-
-        let destination_buffer;
-        const encoder = context.encoder;
-
-        if (
-            (source.usage & GPUBufferUsage.COPY_SRC) === 0
-            && (source.usage & GPUBufferUsage.STORAGE) !== 0
-            && copy_size % 4 === 0
-        ) {
-            // does not qualify for .copyBufferToBuffer
-            // use a shader to copy to a qualifying buffer instead
-            // TODO check if possible overflow might happen when size is not a multiple of 4
-
-            const tmp = graphics.buffer_allocator_main.get(BufferResourceDescriptor.from(
-                copy_size,
-                GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
-            ))
-
-            const word_count = Math.ceil(copy_size / 4);
-            // size in 32-bit words
-            const u_size = encoder.allocateTransientValueBuffer(u32, word_count);
-            shader_buffer_copy_storage_to_storage.dispatchLinear({
-                encoder: encoder,
-                bindings: {
-                    source: {
-                        buffer: source,
-                        offset,
-                        size: copy_size,
-                    },
-                    destination: {
-                        buffer: tmp,
-                        offset: 0,
-                        size: copy_size,
-                    },
-                    size: u_size,
-                },
-                element_count:word_count,
-            });
-
-            source = tmp;
-            _offset = 0;
-
-            encoder.onFinished.addOne(() => graphics.buffer_allocator_main.release(tmp));
-        }
-
-        const descriptor = BufferResourceDescriptor.from(
-            copy_size,
-            GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
-        );
-
-        destination_buffer = graphics.buffer_allocator_main.get(descriptor)
-        encoder.copyBufferToBuffer(source, _offset, destination_buffer, 0, copy_size);
-
-
-        // get results once encoder is submitted
-        encoder.onFinished.addOne(() => {
-
-            const p = inspect_gpu_buffer_typed({
-                buffer: destination_buffer,
-                device: context.graphics.device,
-                type,
-                offset: 0,
-                // the pooled buffer can be larger than the copy; deriving the count from
-                // its size would hand the callback phantom rows of stale pooled bytes
-                count: count ?? Math.floor(copy_size / type.size),
-            });
-
-            p
-                .then(callback)
-                .finally(() => {
-                    graphics.buffer_allocator_main.release(destination_buffer)
-                });
-        });
-
-
-    }
-
-
-    const pass_data = {};
-    const pass = graph.add("inspect typed buffer", pass_data, execute);
-
-    pass_data.input = pass.read(buffer);
-    pass.make_side_effect(); // force pass to run
-
-    return pass_data.input;
+import { assert } from "../../../core/assert.js";
+import { BufferResourceDescriptor } from "../../device/graph/BufferResourceDescriptor.js";
+import { u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { inspect_gpu_buffer_typed } from "./inspect_gpu_buffer_typed.js";
+import { shader_buffer_copy_storage_to_storage } from "./util/shader_buffer_copy_storage_to_storage.js";
+
+/**
+ *
+ * @param {FrameGraph} graph
+ * @param {number} buffer
+ * @param {WebGPUType} type
+ * @param {number} [offset] byte offset where to start reading
+ * @param {number} [count] optional number of members of given type to read, if not specified will read the entire buffer
+ * @param {function([])} callback
+ */
+export function graph_inspect_gpu_buffer({
+                                             graph,
+                                             buffer,
+                                             type,
+                                             offset = 0,
+                                             count,
+                                             callback
+                                         }) {
+
+
+    /**
+     *
+     * @param data
+     * @param {FramePassResources} resources
+     * @param {GraphicsExecutionContext} context
+     */
+    function execute(data, resources, context) {
+        /**
+         * @type {GPUBuffer}
+         */
+        let source = resources.get(data.input);
+
+        const graphics = context.graphics;
+
+        let copy_size;
+        if (count !== undefined) {
+            assert.isNonNegativeInteger(count, 'count');
+            copy_size = count * type.size;
+        } else {
+            copy_size = source.size - offset;
+        }
+
+        let _offset = offset;
+
+
+        // take a snapshot of the buffer
+
+        let destination_buffer;
+        const encoder = context.encoder;
+
+        if (
+            (source.usage & GPUBufferUsage.COPY_SRC) === 0
+            && (source.usage & GPUBufferUsage.STORAGE) !== 0
+            && copy_size % 4 === 0
+        ) {
+            // does not qualify for .copyBufferToBuffer
+            // use a shader to copy to a qualifying buffer instead
+            // TODO check if possible overflow might happen when size is not a multiple of 4
+
+            const tmp = graphics.buffer_allocator_main.get(BufferResourceDescriptor.from(
+                copy_size,
+                GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
+            ))
+
+            const word_count = Math.ceil(copy_size / 4);
+            // size in 32-bit words
+            const u_size = encoder.allocateTransientValueBuffer(u32, word_count);
+            shader_buffer_copy_storage_to_storage.dispatchThreads({
+                encoder: encoder,
+                bindings: {
+                    source: {
+                        buffer: source,
+                        offset,
+                        size: copy_size,
+                    },
+                    destination: {
+                        buffer: tmp,
+                        offset: 0,
+                        size: copy_size,
+                    },
+                    size: u_size,
+                },
+                thread_count_x:word_count,
+            });
+
+            source = tmp;
+            _offset = 0;
+
+            encoder.onFinished.addOne(() => graphics.buffer_allocator_main.release(tmp));
+        }
+
+        const descriptor = BufferResourceDescriptor.from(
+            copy_size,
+            GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
+        );
+
+        destination_buffer = graphics.buffer_allocator_main.get(descriptor)
+        encoder.copyBufferToBuffer(source, _offset, destination_buffer, 0, copy_size);
+
+
+        // get results once encoder is submitted
+        encoder.onFinished.addOne(() => {
+
+            const p = inspect_gpu_buffer_typed({
+                buffer: destination_buffer,
+                device: context.graphics.device,
+                type,
+                offset: 0,
+                // the pooled buffer can be larger than the copy; deriving the count from
+                // its size would hand the callback phantom rows of stale pooled bytes
+                count: count ?? Math.floor(copy_size / type.size),
+            });
+
+            p
+                .then(callback)
+                .finally(() => {
+                    graphics.buffer_allocator_main.release(destination_buffer)
+                });
+        });
+
+
+    }
+
+
+    const pass_data = {};
+    const pass = graph.add("inspect typed buffer", pass_data, execute);
+
+    pass_data.input = pass.read(buffer);
+    pass.make_side_effect(); // force pass to run
+
+    return pass_data.input;
 }

package/src/shade/renderer/buffer/table/GPUDatabase.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUDatabase.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/GPUDatabase.js"],"names":[],"mappings":"AAuCA;;;;;;;;;GASG;AACH;IA0EI;;;;;OAKG;IACH,4FAqEC;IAnJD;;;OAGG;IACH,kCAAW;IAEX;;;;OAIG;IACH,QAFU,oBAAe,CAElB;IASP;;;OAGG;IACH,kBAAO;IAyCP;;OAEG;IACH,8BAEC;IA+ED;;;;;OAKG;IACH,UAHW,MAAM,GACJ,qBAAc,SAAS,CAUnC;IAGD;;;;;OAKG;IACH,gCAEC;IAoPD;;;OAGG;IACH,8CAoIC;IA2DD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,2BAJW,MAAM,GACJ,QAAQ,KAAG,CAAC,CA6HxB;IAED;;;;;;;OAOG;IACH,+BAJW,MAAM,iBACN,MAAM,GACJ,YAAU,CAkCtB;IAED;;;OAGG;IACH,+BAQC;IAED;;OAEG;IACH,gBAIC;;CACJ;8BAh2B6B,oBAAoB"}
+{"version":3,"file":"GPUDatabase.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/GPUDatabase.js"],"names":[],"mappings":"AAsCA;;;;;;;;;GASG;AACH;IA0EI;;;;;OAKG;IACH,4FAqEC;IAnJD;;;OAGG;IACH,kCAAW;IAEX;;;;OAIG;IACH,QAFU,oBAAe,CAElB;IASP;;;OAGG;IACH,kBAAO;IAyCP;;OAEG;IACH,8BAEC;IA+ED;;;;;OAKG;IACH,UAHW,MAAM,GACJ,qBAAc,SAAS,CAUnC;IAGD;;;;;OAKG;IACH,gCAEC;IAoPD;;;OAGG;IACH,8CAoIC;IA2DD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,2BAJW,MAAM,GACJ,QAAQ,KAAG,CAAC,CA6HxB;IAED;;;;;;;OAOG;IACH,+BAJW,MAAM,iBACN,MAAM,GACJ,YAAU,CAkCtB;IAED;;;OAGG;IACH,+BAQC;IAED;;OAEG;IACH,gBAIC;;CACJ;8BAh2B6B,oBAAoB"}

package/src/shade/renderer/buffer/table/GPUDatabase.js

@@ -10,7 +10,6 @@ import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { inspect_gpu_buffer } from "../inspect_gpu_buffer.js";
 import { inspect_gpu_buffer_typed } from "../inspect_gpu_buffer_typed.js";
 import { GPU_DATABASE_BUFFER_ELEMENT_TYPE } from "./GPU_DATABASE_BUFFER_ELEMENT_TYPE.js";
-import { GPU_DATABASE_UPLOAD_DISPATCH_GROUP_SIZE } from "./GPU_DATABASE_UPLOAD_DISPATCH_GROUP_SIZE.js";
 import {
     gpu_table_element_upload_shader,
     GPU_TABLE_UPLOAD_SETTINGS_STRUCT
@@ -568,14 +567,14 @@ export class GPUDatabase {
                     chunk_byte_size
                 );
 
-                gpu_table_element_upload_shader.dispatch({
+                gpu_table_element_upload_shader.dispatchThreads({
                     encoder,
                     bindings: {
                         settings,
                         upload_buffer,
                         database: this.buffer,
                     },
-                    group_count_x: Math.ceil(chunk_count / GPU_DATABASE_UPLOAD_DISPATCH_GROUP_SIZE),
+                    thread_count_x: chunk_count,
                 });
 
                 elements_uploaded += chunk_count;