@woosh/meep-engine 3.35.0 → 3.37.0

package/src/shade/renderer/light/environment/shader_project_environment_sh.js

@@ -1,3 +1,4 @@
+import { WebGPUExtensionType } from "../../../descriptor/WebGPUExtensionType.js";
 import { chunk_get_ibl_irradiance } from "../../deferred/indirect/chunk_get_ibl_irradiance.js";
 import { PI_DECLARATION } from "../../shader/chunk/math/PI_DECLARATION.js";
 import { chunk_sphere_fibonacci_point } from "../../shader/chunk/geometry/sphere/chunk_sphere_fibonacci_point.js";
@@ -21,12 +22,12 @@ export const ENVIRONMENT_SH_TYPE = WebGPUArray.from(vec4f, 4);
 
 /**
  * Directions the projection samples, spread evenly over the sphere (`sphere_fibonacci_point`).
- * The field is the environment at the roughness diffuse reads it at, so this is far more than its
- * two bands can hold, and it costs nothing that recurs: the pass runs when the environment changes.
+ * The field is already prefiltered at the roughness diffuse reads it at; these samples project
+ * that smooth field into two bands. The pass runs only when the environment changes.
  *
  * @type {number}
  */
-export const ENVIRONMENT_SH_SAMPLE_COUNT = 1024;
+export const ENVIRONMENT_SH_SAMPLE_COUNT = 256;
 
 const resources = new ShaderResourceSetDescriptor();
 
@@ -39,28 +40,56 @@ const body = CodeChunk.from(
     //language=WGSL
     `
 const SAMPLE_COUNT : u32 = ${ENVIRONMENT_SH_SAMPLE_COUNT}u;
+// The minimum subgroup size is four, so this holds every subgroup's partial sum.
+const MAX_SUBGROUP_PARTIALS : u32 = SAMPLE_COUNT / 4u;
+
+var<workgroup> wg_partial_count: atomic<u32>;
+var<workgroup> wg_sh_0: array<vec3<f32>, MAX_SUBGROUP_PARTIALS>;
+var<workgroup> wg_sh_1: array<vec3<f32>, MAX_SUBGROUP_PARTIALS>;
+var<workgroup> wg_sh_2: array<vec3<f32>, MAX_SUBGROUP_PARTIALS>;
+var<workgroup> wg_sh_3: array<vec3<f32>, MAX_SUBGROUP_PARTIALS>;
+
+// One workgroup projects the sphere, with one invocation per sample.
+@compute @workgroup_size(${ENVIRONMENT_SH_SAMPLE_COUNT})
+fn main(@builtin(local_invocation_index) thread_index: u32) {
+    let direction = sphere_fibonacci_point(f32(thread_index), f32(SAMPLE_COUNT));
+
+    // exactly what the forward mesh path takes as a surface's diffuse irradiance under IBL
+    let irradiance = get_ibl_irradiance(direction);
+    let basis = sh2_basis_at(direction);
+
+    let sh_0_partial = subgroupAdd(irradiance * basis[0]);
+    let sh_1_partial = subgroupAdd(irradiance * basis[1]);
+    let sh_2_partial = subgroupAdd(irradiance * basis[2]);
+    let sh_3_partial = subgroupAdd(irradiance * basis[3]);
+
+    // Workgroup variables start zeroed. One elected lane claims a distinct slot per subgroup;
+    // local invocation indices need not map to subgroups in contiguous blocks.
+    if (subgroupElect()) {
+        let slot = atomicAdd(&wg_partial_count, 1u);
+        wg_sh_0[slot] = sh_0_partial;
+        wg_sh_1[slot] = sh_1_partial;
+        wg_sh_2[slot] = sh_2_partial;
+        wg_sh_3[slot] = sh_3_partial;
+    }
+
+    workgroupBarrier();
+
+    if (thread_index != 0u) {
+        return;
+    }
 
-// One invocation: the projection is 1024 reads that happen when the environment changes and never
-// otherwise, and a single lane needs no reduction and runs whole on the emulator.
-@compute @workgroup_size(1)
-fn main() {
     var sh_0 = vec3<f32>(0.0);
     var sh_1 = vec3<f32>(0.0);
     var sh_2 = vec3<f32>(0.0);
     var sh_3 = vec3<f32>(0.0);
+    let partial_count = atomicLoad(&wg_partial_count);
 
-    for (var i = 0u; i < SAMPLE_COUNT; i++) {
-        let direction = sphere_fibonacci_point(f32(i), f32(SAMPLE_COUNT));
-
-        // exactly what the forward mesh path takes as a surface's diffuse irradiance under IBL
-        let irradiance = get_ibl_irradiance(direction);
-
-        let basis = sh2_basis_at(direction);
-
-        sh_0 += irradiance * basis[0];
-        sh_1 += irradiance * basis[1];
-        sh_2 += irradiance * basis[2];
-        sh_3 += irradiance * basis[3];
+    for (var i = 0u; i < partial_count; i++) {
+        sh_0 += wg_sh_0[i];
+        sh_1 += wg_sh_1[i];
+        sh_2 += wg_sh_2[i];
+        sh_3 += wg_sh_3[i];
     }
 
     // each sample stands for an equal share of the sphere
@@ -83,6 +112,8 @@ fn main() {
     PI_DECLARATION,
 ]);
 
+body.addExtension(WebGPUExtensionType.Subgroups);
+
 /**
  * The environment as RGB SH2 of radiance ({@link ENVIRONMENT_SH_TYPE}): the form the renderer's other
  * indirect lighting — Brick4, the light probe volume — already hands over, so the froxel GI stage

package/src/shade/renderer/loader/gltf/tiny-gltf.d.ts

@@ -13,7 +13,7 @@ export class TinyGltf {
      * @readonly
      * @type {TextureFormat}
      */
-    static readonly "__#250@#UNCOMPRESSED_TARGET": TextureFormat;
+    static readonly "__#254@#UNCOMPRESSED_TARGET": TextureFormat;
     /**
      * @param {AssetManager} assetManager
      * @param {AssetRequestScope} [scope]

package/src/shade/renderer/particles/DESIGN.md

@@ -353,7 +353,7 @@ finished appending to the alive list:
   `particle_billboard_radius`, the largest offset `particle_billboard_offset` can produce for that
   size, velocity and projection, over every corner, every roll and any camera. The box has to hold
   the *quads*, not the centres, and it has to be camera-independent, because it is read on a later
-  frame. The merge is `aabb_atomic_min_f32` / `aabb_atomic_max_f32`, the same CAS-spin the
+  frame. The merge is `atomic_min_f32_storage` / `atomic_max_f32_storage`, the same CAS-spin the
   skinned-mesh bounds refresh uses; both load first and return without a CAS once the box holds the
   contribution, so what survives is load traffic, not exchanges. Dispatched indirectly from
   `sim_dispatch_args`, the args the coherence reset wrote from the GPU's own alive count.

package/src/shade/renderer/particles/bounds/chunk_particle_bounds.js

@@ -1,5 +1,6 @@
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { chunk_aabb_atomic_f32 } from "../../animation/skinning/bounds_refresh/chunk_aabb_atomic_f32.js";
+import { chunk_atomic_min_f32_storage } from "../../shader/chunk/atomic/chunk_atomic_min_f32_storage.js";
+import { chunk_atomic_max_f32_storage } from "../../shader/chunk/atomic/chunk_atomic_max_f32_storage.js";
 import { AABB3_STRUCT } from "../../shader/chunk/geometry/aabb3/AABB3_STRUCT.js";
 import {
     PARTICLE_BOUNDS_BASE,
@@ -26,7 +27,7 @@ import { chunk_particle_render_math } from "../shaders/chunk_particle_render_mat
  *
  * ## Why f32 in the buffer, and not an order-preserving encoding
  *
- * `aabb_atomic_min_f32` / `aabb_atomic_max_f32` are the engine's, shared with the skinned-mesh
+ * `atomic_min_f32_storage` / `atomic_max_f32_storage` are the engine's, shared with the skinned-mesh
  * bounds refresh, and they CAS-spin over the plain float so the words are readable as floats at
  * every moment of the frame. The sign-flip encoding that would let `atomicMin` do it in one
  * instruction leaves the buffer in a form only a decoder understands, and the publish pass reads
@@ -71,12 +72,12 @@ fn particle_bounds_contribute(row : u32, center : vec3<f32>, radius : f32) {
     let lo = center - vec3<f32>(radius);
     let hi = center + vec3<f32>(radius);
 
-    aabb_atomic_min_f32(&counters[base + 0u], lo.x);
-    aabb_atomic_min_f32(&counters[base + 1u], lo.y);
-    aabb_atomic_min_f32(&counters[base + 2u], lo.z);
-    aabb_atomic_max_f32(&counters[base + 3u], hi.x);
-    aabb_atomic_max_f32(&counters[base + 4u], hi.y);
-    aabb_atomic_max_f32(&counters[base + 5u], hi.z);
+    atomic_min_f32_storage(&counters[base + 0u], lo.x);
+    atomic_min_f32_storage(&counters[base + 1u], lo.y);
+    atomic_min_f32_storage(&counters[base + 2u], lo.z);
+    atomic_max_f32_storage(&counters[base + 3u], hi.x);
+    atomic_max_f32_storage(&counters[base + 4u], hi.y);
+    atomic_max_f32_storage(&counters[base + 5u], hi.z);
 }
 
 // What the frame accumulated for one row. Empty (see \`particle_bounds_is_empty\`) when nothing
@@ -117,7 +118,7 @@ fn particle_bounds_reset(row : u32) {
 fn particle_bounds_is_empty(box : ${AABB3_STRUCT.wgsl_ref}) -> bool {
     return any(box.min > box.max);
 }
-`, [chunk_aabb_atomic_f32, AABB3_STRUCT.declaration_chunk]);
+`, [chunk_atomic_min_f32_storage, chunk_atomic_max_f32_storage, AABB3_STRUCT.declaration_chunk]);
 
 /**
  * One live particle's contribution to its emitter's box: where its quad is, and how far the quad

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

@@ -1,7 +1,8 @@
 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 { chunk_atomic_min_f32_storage } from "../shader/chunk/atomic/chunk_atomic_min_f32_storage.js";
+import { chunk_atomic_max_f32_storage } from "../shader/chunk/atomic/chunk_atomic_max_f32_storage.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
@@ -107,17 +108,18 @@ fn main(
             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);
+        atomic_min_f32_storage(&scene_bounds[0], group_low.x);
+        atomic_min_f32_storage(&scene_bounds[1], group_low.y);
+        atomic_min_f32_storage(&scene_bounds[2], group_low.z);
+        atomic_max_f32_storage(&scene_bounds[3], group_high.x);
+        atomic_max_f32_storage(&scene_bounds[4], group_high.y);
+        atomic_max_f32_storage(&scene_bounds[5], group_high.z);
     }
 }
 `, [
     chunk_scene_database_access,
-    chunk_aabb_atomic_f32,
+    chunk_atomic_min_f32_storage,
+    chunk_atomic_max_f32_storage,
 ]);
 
 body.addExtension(WebGPUExtensionType.Subgroups);

package/src/shade/renderer/shader/chunk/atomic/chunk_atomic_add_f32_storage.js

@@ -0,0 +1,25 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * Atomic f32 addition over a read-write storage atomic<u32> cell containing f32 bits.
+ *
+ * Each compare-exchange attempt adds to the current float value and writes the sum
+ * as plain f32 bits. Failed or spurious exchanges retry from a fresh atomic load,
+ * so concurrent additions are not lost.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_atomic_add_f32_storage = CodeChunk.from(
+    //language=WGSL
+    `
+fn atomic_add_f32_storage(cell: ptr<storage, atomic<u32>, read_write>, value: f32) {
+    loop {
+        let old_u = atomicLoad(cell);
+        let old_f = bitcast<f32>(old_u);
+        let result = atomicCompareExchangeWeak(cell, old_u, bitcast<u32>(old_f + value));
+        if result.exchanged {
+            break;
+        }
+    }
+}
+`);

package/src/shade/renderer/shader/chunk/atomic/chunk_atomic_max_f32_storage.js

@@ -0,0 +1,28 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * Atomic f32 maximum over a read-write storage atomic<u32> cell containing f32 bits.
+ *
+ * Compare-exchange retries keep the cell in plain f32 representation. If the stored
+ * value already bounds the contribution, the function exits without an exchange.
+ * Infinities are supported; the stored value and contribution must not be NaN.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_atomic_max_f32_storage = CodeChunk.from(
+    //language=WGSL
+    `
+fn atomic_max_f32_storage(cell: ptr<storage, atomic<u32>, read_write>, value: f32) {
+    loop {
+        let old_u = atomicLoad(cell);
+        let old_f = bitcast<f32>(old_u);
+        if value <= old_f {
+            break;
+        }
+        let result = atomicCompareExchangeWeak(cell, old_u, bitcast<u32>(value));
+        if result.exchanged {
+            break;
+        }
+    }
+}
+`);

package/src/shade/renderer/shader/chunk/atomic/chunk_atomic_min_f32_storage.js

@@ -0,0 +1,28 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * Atomic f32 minimum over a read-write storage atomic<u32> cell containing f32 bits.
+ *
+ * Compare-exchange retries keep the cell in plain f32 representation. If the stored
+ * value already bounds the contribution, the function exits without an exchange.
+ * Infinities are supported; the stored value and contribution must not be NaN.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_atomic_min_f32_storage = CodeChunk.from(
+    //language=WGSL
+    `
+fn atomic_min_f32_storage(cell: ptr<storage, atomic<u32>, read_write>, value: f32) {
+    loop {
+        let old_u = atomicLoad(cell);
+        let old_f = bitcast<f32>(old_u);
+        if value >= old_f {
+            break;
+        }
+        let result = atomicCompareExchangeWeak(cell, old_u, bitcast<u32>(value));
+        if result.exchanged {
+            break;
+        }
+    }
+}
+`);

package/src/shade/renderer/shader/chunk/geometry/plane/{plane_ray_raycast.js → chunk_plane_ray_raycast.js}

@@ -4,7 +4,7 @@ import { CodeChunk } from "../../../compiler/CodeChunk.js";
  * Ported from meep
  * @type {CodeChunk}
  */
-export const plane_ray_raycast = CodeChunk.from(
+export const chunk_plane_ray_raycast = CodeChunk.from(
     //language=WGSL
     `
 fn plane_ray_raycast(

package/src/shade/renderer/shadow/map/csm/shader/shader_csm_caster_range.js

@@ -6,7 +6,7 @@ import { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
 import { COMPUTE_SHADER_DEFAULT_GROUP_SIZE } from "../../../../shader/COMPUTE_SHADER_DEFAULT_GROUP_SIZE.js";
 import { ComputeShader } from "../../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../../shader/resource/ShaderResourceSetDescriptor.js";
-import { chunk_aabb_atomic_f32 } from "../../../../animation/skinning/bounds_refresh/chunk_aabb_atomic_f32.js";
+import { chunk_atomic_min_f32_storage } from "../../../../shader/chunk/atomic/chunk_atomic_min_f32_storage.js";
 import { LIGHT_DATABASE_SPEC } from "../../../../light/LIGHT_DATABASE_SPEC.js";
 import { MESHES_TABLE } from "../../../../scene/chunk_scene_database_access.js";
 import { CSM_CASTER_RANGE_UNKNOWN } from "../CSM_CASTER_RANGE_STRUCT.js";
@@ -124,13 +124,13 @@ fn main(
 
         // one atomic per subgroup rather than one per row, and none where no row was inside
         if lane_id == 0u && near < RANGE_UNKNOWN {
-            aabb_atomic_min_f32(&ranges[settings.base + c], near);
+            atomic_min_f32_storage(&ranges[settings.base + c], near);
         }
     }
 }
 `, [
     MESHES_TABLE.chunk_iterate(WG),
-    chunk_aabb_atomic_f32,
+    chunk_atomic_min_f32_storage,
 ]);
 
 accumulate_body.addExtension(WebGPUExtensionType.Subgroups);

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

@@ -1,59 +0,0 @@
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-
-/**
- * Per-element f32 atomic min/max via CAS-spin over a `atomic<u32>`
- * storage cell, bitcast through f32 for comparison.
- *
- * WGSL has native u32/i32 atomics only. For float min/max the
- * sign-bit-flip encoding (cheaper, only `atomicMin`/`atomicMax`
- * needed) is a tempting alternative, but it leaves the buffer in
- * "encoded" form during the dispatch chain — readers in the same
- * frame would need to know whether the value is encoded or decoded.
- * The CAS-spin keeps the storage in plain f32 the whole time, which
- * matches what the rasterizer's meshlet-culling shader already
- * expects in `meshlet.bounds_box`.
- *
- * Contention model: every contributor reads → compares → conditionally
- * writes. When the existing value already bounds the contribution
- * (typical for late contributors as the box settles), the comparison
- * exits early without any CAS. The worst case is many threads
- * hammering the same slot in the first few iterations; the loop is
- * bounded by collisions, not by thread count.
- *
- * `value` is treated as a normal f32 — NaNs are not handled (vertex
- * positions are never NaN in correctly-loaded geometry). +inf / -inf
- * are valid (they're our scatter sentinels).
- *
- * @type {CodeChunk}
- */
-export const chunk_aabb_atomic_f32 = CodeChunk.from(
-    //language=WGSL
-    `
-fn aabb_atomic_min_f32(cell: ptr<storage, atomic<u32>, read_write>, value: f32) {
-    loop {
-        let old_u = atomicLoad(cell);
-        let old_f = bitcast<f32>(old_u);
-        if value >= old_f {
-            break;
-        }
-        let result = atomicCompareExchangeWeak(cell, old_u, bitcast<u32>(value));
-        if result.exchanged {
-            break;
-        }
-    }
-}
-
-fn aabb_atomic_max_f32(cell: ptr<storage, atomic<u32>, read_write>, value: f32) {
-    loop {
-        let old_u = atomicLoad(cell);
-        let old_f = bitcast<f32>(old_u);
-        if value <= old_f {
-            break;
-        }
-        let result = atomicCompareExchangeWeak(cell, old_u, bitcast<u32>(value));
-        if result.exchanged {
-            break;
-        }
-    }
-}
-`);