@woosh/meep-engine 3.12.0 → 3.13.0

package/src/shade/renderer/scene/shader_bvh_extract_instance_leaves.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_bvh_extract_instance_leaves.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/shader_bvh_extract_instance_leaves.js"],"names":[],"mappings":"AAUA,4CAA6C;AA+G7C;;;;;;;;;;;;;;;;;GAiBG;AACH,iDAFU,aAAa,CAMpB;8BA1I2B,4BAA4B"}
+{"version":3,"file":"shader_bvh_extract_instance_leaves.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/shader_bvh_extract_instance_leaves.js"],"names":[],"mappings":"AAUA,4CAA6C;AAkH7C;;;;;;;;;;;;;;;;;GAiBG;AACH,iDAFU,aAAa,CAMpB;8BA7I2B,4BAA4B"}

package/src/shade/renderer/scene/shader_bvh_extract_instance_leaves.js

@@ -1,144 +1,147 @@
-import { WebGPUExtensionType } from "../../descriptor/WebGPUExtensionType.js";
-import { atomic_u32, f32, u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../shader/type/WebGPUArray.js";
-import { chunk_aabb_atomic_f32 } from "../animation/skinning/bounds_refresh/chunk_aabb_atomic_f32.js";
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
-import { BVH_BUILD_SETTINGS_STRUCT } from "../gpu_primitive/bvh/BVH_BUILD_SETTINGS_STRUCT.js";
-import { chunk_scene_database_access } from "./chunk_scene_database_access.js";
-
-export const BVH_EXTRACT_WORKGROUP_SIZE = 64;
-
-/**
- * Subgroup size is a runtime value of at least 4, so a workgroup splits into at most this many
- * subgroups. The array of per-subgroup partials is sized for the worst case.
- *
- * @type {number}
- */
-const MAX_SUBGROUPS = BVH_EXTRACT_WORKGROUP_SIZE / 4;
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addUniform("settings", BVH_BUILD_SETTINGS_STRUCT)
-    // occupied rows of the scene database's `meshes` table, compacted — dead and reused rows never
-    // reach the build
-    .addStorageBuffer("rows", WebGPUArray.from(u32), false)
-    .addStorageBuffer("scene_database", WebGPUArray.from(u32), false)
-    .addStorageBuffer("leaf_bounds", WebGPUArray.from(f32), true)
-    .addStorageBuffer("leaf_payload", WebGPUArray.from(u32), true)
-    // six words holding plain f32 bit patterns, seeded to +/-inf before this pass runs
-    .addStorageBuffer("scene_bounds", WebGPUArray.from(atomic_u32), true);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-const WORKGROUP_SIZE = ${BVH_EXTRACT_WORKGROUP_SIZE}u;
-
-// The scatter sentinels in scene_bounds are true +/-inf, written host-side as u32 bit patterns.
-// Here they cannot be: WGSL will not const-fold bitcast<f32>(0x7F800000u), because the result is
-// not representable as a literal. The largest finite f32 is the identity element in practice —
-// no world-space bound comes within many orders of magnitude of it.
-const FLOAT_MAX = 3.4028234e38;
-
-var<workgroup> wg_low: array<vec3<f32>, ${MAX_SUBGROUPS}>;
-var<workgroup> wg_high: array<vec3<f32>, ${MAX_SUBGROUPS}>;
-
-@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
-fn main(
-    @builtin(global_invocation_id) gid: vec3<u32>,
-    @builtin(local_invocation_index) thread_id: u32,
-    @builtin(subgroup_invocation_id) lane_id: u32,
-    @builtin(subgroup_size) lane_count: u32,
-) {
-    let i = gid.x;
-
-    // Threads past the end contribute the identity element rather than returning: the reduction
-    // below is workgroup-wide and every lane has to reach it.
-    var low = vec3<f32>(FLOAT_MAX);
-    var high = vec3<f32>(-FLOAT_MAX);
-
-    if (i < settings.element_count) {
-        let row = rows[i];
-
-        let mesh = scene_read_mesh(&scene_database, row);
-
-        low = vec3<f32>(mesh.bounding_box[0], mesh.bounding_box[1], mesh.bounding_box[2]);
-        high = vec3<f32>(mesh.bounding_box[3], mesh.bounding_box[4], mesh.bounding_box[5]);
-
-        let destination = i * 6u;
-
-        leaf_bounds[destination] = low.x;
-        leaf_bounds[destination + 1u] = low.y;
-        leaf_bounds[destination + 2u] = low.z;
-        leaf_bounds[destination + 3u] = high.x;
-        leaf_bounds[destination + 4u] = high.y;
-        leaf_bounds[destination + 5u] = high.z;
-
-        // The leaf's payload IS the mesh row — what the traversal hands to scene_read_mesh on a hit.
-        leaf_payload[i] = row;
-    }
-
-    // Subgroups first, workgroup memory only across subgroup boundaries.
-    let subgroup_low = subgroupMin(low);
-    let subgroup_high = subgroupMax(high);
-
-    let subgroup_id = thread_id / lane_count;
-    let subgroup_count = WORKGROUP_SIZE / lane_count;
-
-    if (lane_id == 0u) {
-        wg_low[subgroup_id] = subgroup_low;
-        wg_high[subgroup_id] = subgroup_high;
-    }
-
-    workgroupBarrier();
-
-    // At most MAX_SUBGROUPS entries left; one thread walks them, so nothing here depends on the
-    // subgroup width and no barrier sits under a bound derived from it.
-    if (thread_id == 0u) {
-        var group_low = wg_low[0];
-        var group_high = wg_high[0];
-
-        for (var s = 1u; s < subgroup_count; s += 1u) {
-            group_low = min(group_low, wg_low[s]);
-            group_high = max(group_high, wg_high[s]);
-        }
-
-        aabb_atomic_min_f32(&scene_bounds[0], group_low.x);
-        aabb_atomic_min_f32(&scene_bounds[1], group_low.y);
-        aabb_atomic_min_f32(&scene_bounds[2], group_low.z);
-        aabb_atomic_max_f32(&scene_bounds[3], group_high.x);
-        aabb_atomic_max_f32(&scene_bounds[4], group_high.y);
-        aabb_atomic_max_f32(&scene_bounds[5], group_high.z);
-    }
-}
-`, [
-    chunk_scene_database_access,
-    chunk_aabb_atomic_f32,
-]);
-
-body.addExtension(WebGPUExtensionType.Subgroups);
-
-/**
- * Turn the TLAS's live instance rows into the flat leaf set {@link graph_bvh_build_lbvh} consumes,
- * and reduce their union into the scene-bounds cell the Morton pass quantises against.
- *
- * World AABBs come from the scene database's `meshes` table rather than from the CPU tree's leaves:
- * it is the single source of truth, it is refreshed GPU-side for GPU-authority rows (which the CPU
- * never learns about at all), and reading it removes the build's dependency on CPU-side bounds
- * bookkeeping.
- *
- * This is the only scene-aware pass in the build, which is why it lives here with the scene code
- * rather than in `gpu_primitive/bvh/` — everything downstream of it takes flat boxes and payloads
- * and serves geometry just as well as instances.
- *
- * `scene_bounds` must be seeded with +/-inf before this runs; a pool-cleared buffer is zeroed, and
- * zero is a perfectly good coordinate.
- *
- * @type {ComputeShader}
- */
-export const shader_bvh_extract_instance_leaves = ComputeShader.from({
-    label: "BVHBuild/ExtractInstanceLeaves",
-    resources,
-    body,
-});
+import { WebGPUExtensionType } from "../../descriptor/WebGPUExtensionType.js";
+import { atomic_u32, f32, u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../shader/type/WebGPUArray.js";
+import { chunk_aabb_atomic_f32 } from "../animation/skinning/bounds_refresh/chunk_aabb_atomic_f32.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
+import { BVH_BUILD_SETTINGS_STRUCT } from "../gpu_primitive/bvh/BVH_BUILD_SETTINGS_STRUCT.js";
+import { chunk_scene_database_access } from "./chunk_scene_database_access.js";
+
+export const BVH_EXTRACT_WORKGROUP_SIZE = 64;
+
+/**
+ * Subgroup size is a runtime value of at least 4, so a workgroup splits into at most this many
+ * subgroups. The array of per-subgroup partials is sized for the worst case.
+ *
+ * @type {number}
+ */
+const MAX_SUBGROUPS = BVH_EXTRACT_WORKGROUP_SIZE / 4;
+
+const resources = new ShaderResourceSetDescriptor();
+
+// per-dispatch, 20 bytes, read-only: immediate data rather than a uniform buffer
+resources.setImmediate("settings", BVH_BUILD_SETTINGS_STRUCT);
+
+resources.createGroup()
+    // occupied rows of the scene database's `meshes` table, compacted — dead and reused rows never
+    // reach the build
+    .addStorageBuffer("rows", WebGPUArray.from(u32), false)
+    .addStorageBuffer("scene_database", WebGPUArray.from(u32), false)
+    .addStorageBuffer("leaf_bounds", WebGPUArray.from(f32), true)
+    .addStorageBuffer("leaf_payload", WebGPUArray.from(u32), true)
+    // six words holding plain f32 bit patterns, seeded to +/-inf before this pass runs
+    .addStorageBuffer("scene_bounds", WebGPUArray.from(atomic_u32), true);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const WORKGROUP_SIZE = ${BVH_EXTRACT_WORKGROUP_SIZE}u;
+
+// The scatter sentinels in scene_bounds are true +/-inf, written host-side as u32 bit patterns.
+// Here they cannot be: WGSL will not const-fold bitcast<f32>(0x7F800000u), because the result is
+// not representable as a literal. The largest finite f32 is the identity element in practice —
+// no world-space bound comes within many orders of magnitude of it.
+const FLOAT_MAX = 3.4028234e38;
+
+var<workgroup> wg_low: array<vec3<f32>, ${MAX_SUBGROUPS}>;
+var<workgroup> wg_high: array<vec3<f32>, ${MAX_SUBGROUPS}>;
+
+@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
+fn main(
+    @builtin(global_invocation_id) gid: vec3<u32>,
+    @builtin(local_invocation_index) thread_id: u32,
+    @builtin(subgroup_invocation_id) lane_id: u32,
+    @builtin(subgroup_size) lane_count: u32,
+) {
+    let i = gid.x;
+
+    // Threads past the end contribute the identity element rather than returning: the reduction
+    // below is workgroup-wide and every lane has to reach it.
+    var low = vec3<f32>(FLOAT_MAX);
+    var high = vec3<f32>(-FLOAT_MAX);
+
+    if (i < settings.element_count) {
+        let row = rows[i];
+
+        let mesh = scene_read_mesh(&scene_database, row);
+
+        low = vec3<f32>(mesh.bounding_box[0], mesh.bounding_box[1], mesh.bounding_box[2]);
+        high = vec3<f32>(mesh.bounding_box[3], mesh.bounding_box[4], mesh.bounding_box[5]);
+
+        let destination = i * 6u;
+
+        leaf_bounds[destination] = low.x;
+        leaf_bounds[destination + 1u] = low.y;
+        leaf_bounds[destination + 2u] = low.z;
+        leaf_bounds[destination + 3u] = high.x;
+        leaf_bounds[destination + 4u] = high.y;
+        leaf_bounds[destination + 5u] = high.z;
+
+        // The leaf's payload IS the mesh row — what the traversal hands to scene_read_mesh on a hit.
+        leaf_payload[i] = row;
+    }
+
+    // Subgroups first, workgroup memory only across subgroup boundaries.
+    let subgroup_low = subgroupMin(low);
+    let subgroup_high = subgroupMax(high);
+
+    let subgroup_id = thread_id / lane_count;
+    let subgroup_count = WORKGROUP_SIZE / lane_count;
+
+    if (lane_id == 0u) {
+        wg_low[subgroup_id] = subgroup_low;
+        wg_high[subgroup_id] = subgroup_high;
+    }
+
+    workgroupBarrier();
+
+    // At most MAX_SUBGROUPS entries left; one thread walks them, so nothing here depends on the
+    // subgroup width and no barrier sits under a bound derived from it.
+    if (thread_id == 0u) {
+        var group_low = wg_low[0];
+        var group_high = wg_high[0];
+
+        for (var s = 1u; s < subgroup_count; s += 1u) {
+            group_low = min(group_low, wg_low[s]);
+            group_high = max(group_high, wg_high[s]);
+        }
+
+        aabb_atomic_min_f32(&scene_bounds[0], group_low.x);
+        aabb_atomic_min_f32(&scene_bounds[1], group_low.y);
+        aabb_atomic_min_f32(&scene_bounds[2], group_low.z);
+        aabb_atomic_max_f32(&scene_bounds[3], group_high.x);
+        aabb_atomic_max_f32(&scene_bounds[4], group_high.y);
+        aabb_atomic_max_f32(&scene_bounds[5], group_high.z);
+    }
+}
+`, [
+    chunk_scene_database_access,
+    chunk_aabb_atomic_f32,
+]);
+
+body.addExtension(WebGPUExtensionType.Subgroups);
+
+/**
+ * Turn the TLAS's live instance rows into the flat leaf set {@link graph_bvh_build_lbvh} consumes,
+ * and reduce their union into the scene-bounds cell the Morton pass quantises against.
+ *
+ * World AABBs come from the scene database's `meshes` table rather than from the CPU tree's leaves:
+ * it is the single source of truth, it is refreshed GPU-side for GPU-authority rows (which the CPU
+ * never learns about at all), and reading it removes the build's dependency on CPU-side bounds
+ * bookkeeping.
+ *
+ * This is the only scene-aware pass in the build, which is why it lives here with the scene code
+ * rather than in `gpu_primitive/bvh/` — everything downstream of it takes flat boxes and payloads
+ * and serves geometry just as well as instances.
+ *
+ * `scene_bounds` must be seeded with +/-inf before this runs; a pool-cleared buffer is zeroed, and
+ * zero is a perfectly good coordinate.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_bvh_extract_instance_leaves = ComputeShader.from({
+    label: "BVHBuild/ExtractInstanceLeaves",
+    resources,
+    body,
+});

package/src/shade/renderer/shader/ComputeShader.d.ts

@@ -44,9 +44,9 @@ export class ComputeShader {
      *
      * @param {ShadeGPUCommandContext} encoder
      * @param {Object} bindings
-     * @return {GPUComputePassEncoder}
+     * @return {ShadeGPUComputePassEncoder}
      */
-    constructPass({ encoder, bindings }: ShadeGPUCommandContext): GPUComputePassEncoder;
+    constructPass({ encoder, bindings }: ShadeGPUCommandContext): ShadeGPUComputePassEncoder;
     /**
      * Shortcut to {@link dispatch}, expressed in threads instead of workgroups.
      *

package/src/shade/renderer/shader/ComputeShader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ComputeShader.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/shader/ComputeShader.js"],"names":[],"mappings":"AASA;IA8FI;;;;;;;;;OASG;IACH,sDARW,MAAM,GAMJ,aAAa,CAuBzB;IA9DD;;;OAGG;IACH,wBAFW,gBAAgB,EA2B1B;IAhFD;;;OAGG;IACH,0CAEC;IAaD;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,mCAEC;IAkED;;;;;OAKG;IACH,oFAuBC;IAED;;;;;;;;;;;;;;;OAeG;IACH,sHA6BC;IAED;;;;;;;;;;;OAWG;IACH,mFAmBC;IAED;;;;;;;OAOG;IACH,4GAyCC;IAED;;;;;;OAMG;IACH,+FAsCC;IAGL;;;OAGG;IACH,0BAFU,OAAO,CAEsB;;CANtC;0CAvVyC,gEAAgE;iCACzE,uBAAuB"}
+{"version":3,"file":"ComputeShader.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/shader/ComputeShader.js"],"names":[],"mappings":"AAMA;IA8FI;;;;;;;;;OASG;IACH,sDARW,MAAM,GAMJ,aAAa,CAuBzB;IA3DD;;;OAGG;IACH,wBAFW,gBAAgB,EAwB1B;IAhFD;;;OAGG;IACH,0CAEC;IAgBD;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,mCAEC;IA+DD;;;;;OAKG;IACH,yFAuBC;IAED;;;;;;;;;;;;;;;OAeG;IACH,sHA6BC;IAED;;;;;;;;;;;OAWG;IACH,mFAmBC;IAED;;;;;;;OAOG;IACH,4GAyCC;IAED;;;;;;OAMG;IACH,+FAsCC;IAGL;;;OAGG;IACH,0BAFU,OAAO,CAEsB;;CANtC;0CApVyC,gEAAgE;iCACzE,uBAAuB"}

package/src/shade/renderer/shader/ComputeShader.js

@@ -1,9 +1,6 @@
 import { assert } from "../../../core/assert.js";
 import { ComputePipelineDescriptor } from "../../descriptor/pipeline/compute/ComputePipelineDescriptor.js";
 import { ShaderDescriptor } from "./ShaderDescriptor.js";
-import {
-    compute_infer_workgroup_size_from_source
-} from "./util/compute_infer_workgroup_size_from_source.js";
 
 const VALIDATION_ENABLED = true;
 
@@ -34,7 +31,10 @@ export class ComputeShader {
      * the two to drift. A shader that divides a thread count by a stale copy of this number
      * dispatches the wrong number of workgroups and says nothing about it.
      *
-     * @type {[number, number, number]}
+     * Held by {@link ComputePipelineDescriptor}, which reads it as the code is set, so the profiler
+     * and the dispatch helpers below are looking at the same array rather than at two parses.
+     *
+     * @type {readonly number[]}
      */
     #group_size;
 
@@ -78,20 +78,15 @@ export class ComputeShader {
         this.#descriptor = descriptor;
 
         // compiled once here rather than read twice off the descriptor, so that a failure to
-        // compile stays its own error instead of arriving wrapped in the one below
+        // compile stays its own error instead of arriving wrapped in the one from the pipeline
         const source = descriptor.source;
 
-        try {
-            this.#group_size = compute_infer_workgroup_size_from_source(source);
-        } catch (e) {
-            // the source alone says nothing about which shader it belongs to
-            const error = new Error(`ComputeShader '${descriptor.label}' has no readable workgroup size: ${e.message}`);
-
-            error.cause = e;
-
-            throw error;
-        }
-
+        /*
+         Throws here, at construction, when the source does not state a readable `@workgroup_size` —
+         the pipeline descriptor reads it as the code is set and names this shader in the message.
+         Read from there rather than parsed again: it is the same WGSL, the answer cannot differ,
+         and a second parse is a second thing that can disagree.
+        */
         this.#pipeline = ComputePipelineDescriptor.simplified({
             label: descriptor.label,
             code: source,
@@ -99,6 +94,8 @@ export class ComputeShader {
             immediate_size: descriptor.resources.immediateSize
         });
 
+        this.#group_size = this.#pipeline.workgroup_size;
+
     }
 
     /**
@@ -138,7 +135,7 @@ export class ComputeShader {
      *
      * @param {ShadeGPUCommandContext} encoder
      * @param {Object} bindings
-     * @return {GPUComputePassEncoder}
+     * @return {ShadeGPUComputePassEncoder}
      */
     constructPass({
                       encoder,

package/src/shade/renderer/shader/pass/RenderPassDescriptor.d.ts

@@ -41,9 +41,9 @@ export class RenderPassDescriptor {
      * @param {PrimitiveState} [primitive_state]
      * @param {GPULoadOp} [loadOp="clear"] Used for both color targets and depth target
      * @param {GPUStoreOp} [storeOp="store"] Used for both color targets and depth target
-     * @returns {GPURenderPassEncoder}
+     * @returns {ShadeGPURenderPassEncoder}
      */
-    begin({ encoder, colorTargets, depthTarget, bindings, primitive_state, loadOp, storeOp, }: ShadeGPUCommandContext): GPURenderPassEncoder;
+    begin({ encoder, colorTargets, depthTarget, bindings, primitive_state, loadOp, storeOp, }: ShadeGPUCommandContext): ShadeGPURenderPassEncoder;
     /**
      *
      * @param {ShadeGPUCommandContext} encoder

package/src/shade/renderer/shader/pass/RenderPassDescriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RenderPassDescriptor.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/pass/RenderPassDescriptor.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IACI;;OAEG;IACH,mCAAQ;IAER;;OAEG;IACH,uCAAS;IAET;;;OAGG;IACH,kBAFU,qCAAqC,CAEzB;IAEtB;;;OAGG;IACH,wBAFU,0CAA0C,CAEsB;IAG1E;;;;;;;;;;OAUG;IACH,8GAVW,mBAAmB,2BA+E7B;IAED;;;;;;;;;;OAUG;IACH,yIAkCC;IAED;;;;;;;OAOG;IACH,0GAcC;IAGL;;;OAGG;IACH,iCAFU,OAAO,CAEoC;CANpD;2DArL0D,iDAAiD"}
+{"version":3,"file":"RenderPassDescriptor.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/pass/RenderPassDescriptor.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IACI;;OAEG;IACH,mCAAQ;IAER;;OAEG;IACH,uCAAS;IAET;;;OAGG;IACH,kBAFU,qCAAqC,CAEzB;IAEtB;;;OAGG;IACH,wBAFU,0CAA0C,CAEsB;IAG1E;;;;;;;;;;OAUG;IACH,8GAVW,mBAAmB,2BA+E7B;IAED;;;;;;;;;;OAUG;IACH,8IAkCC;IAED;;;;;;;OAOG;IACH,0GAcC;IAGL;;;OAGG;IACH,iCAFU,OAAO,CAEoC;CANpD;2DArL0D,iDAAiD"}