@woosh/meep-engine 3.60.6 → 3.60.7

package/src/shade/renderer/gpu_primitive/indirect/IndirectComputeCommandBuildPass.js

@@ -5,10 +5,10 @@ import { invokeObjectHash } from "../../../../core/model/object/invokeObjectHash
 import { BufferBindingLayout } from "../../../descriptor/binding/BufferBindingLayout.js";
 import { ComputePipelineDescriptor } from "../../../descriptor/pipeline/compute/ComputePipelineDescriptor.js";
 import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
+import { chunk_divide_round_up_u32 } from "../../shader/chunk/math/chunk_divide_round_up_u32.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_folded_dispatch } from "./chunk_folded_dispatch.js";
 import { STRUCT_DISPATCH_COMPUTE_COMMAND } from "./STRUCT_DISPATCH_COMPUTE_COMMAND.js";
-import {
-    WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION
-} from "./WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION.js";
 
 /**
  * How a workgroup count that does not fit one dimension is spread over three.
@@ -78,39 +78,30 @@ function create_pipeline(key) {
 
     //language=WGSL
     const folded_dispatch = `
-    // the width chunk_folded_workgroup_index strides by, which is why it is not this device's figure
-    const LIMIT = ${WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION}u;
-
-    // x to the limit, what is left of it in rows of x, what is left of those in slices of x*y
-    let rows = divide_round_up(desired_groups, LIMIT);
-    let slices = divide_round_up(rows, LIMIT);
+    let folded = folded_dispatch(desired_groups);
 
     // field by field, as shader_prefix_sum_to_command writes it: the WGSL emulator drops a whole-struct
     // store into a storage variable, and this is the text folded_dispatch_width.spec.js runs
-    command.workgroupCountX = min( desired_groups, LIMIT );
-    command.workgroupCountY = min( max( rows, 1u ), LIMIT );
-    command.workgroupCountZ = max( slices, 1u );`;
+    command.workgroupCountX = folded.x;
+    command.workgroupCountY = folded.y;
+    command.workgroupCountZ = folded.z;`;
 
 //language=WGSL
-    const shader_code = `
+    const shader_code = CodeChunk.from(`
         ${STRUCT_DISPATCH_COMPUTE_COMMAND.wgsl_declaration}
         
 @group(0) @binding(0) var<storage, read> input : u32;
 @group(0) @binding(1) var<storage, read_write> command : ${STRUCT_DISPATCH_COMPUTE_COMMAND.wgsl_ref};
 
-fn divide_round_up(value: u32, divisor: u32) -> u32 {
-    return (value + divisor - 1u) / divisor;
-}
-
 @compute @workgroup_size(1, 1, 1)
 fn main(){
 
     let elements_per_group = ${key.elements_per_workgroup}u;
-    let desired_groups = divide_round_up(input, elements_per_group);
+    let desired_groups = divide_round_up_u32(input, elements_per_group);
 ${key.fold ? folded_dispatch : clamped_dispatch}
 
 }
-        `;
+        `, key.fold ? [chunk_divide_round_up_u32, chunk_folded_dispatch] : [chunk_divide_round_up_u32]).compile().text;
 
     return ComputePipelineDescriptor.simplified({
         label: key.fold ? "IndirectComputeCommandBuildPass/folded" : "IndirectComputeCommandBuildPass",

package/src/shade/renderer/gpu_primitive/indirect/chunk_folded_dispatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_folded_dispatch.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/indirect/chunk_folded_dispatch.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AACH,oCAFU,SAAS,CAahB;0BA9BuB,oCAAoC"}
+{"version":3,"file":"chunk_folded_dispatch.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/indirect/chunk_folded_dispatch.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;GAeG;AACH,oCAFU,SAAS,CAehB;0BAhCuB,oCAAoC"}

package/src/shade/renderer/gpu_primitive/indirect/chunk_folded_dispatch.js

@@ -1,3 +1,4 @@
+import { chunk_divide_round_up_u32 } from "../../shader/chunk/math/chunk_divide_round_up_u32.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION } from "./WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION.js";
 
@@ -23,9 +24,11 @@ export const chunk_folded_dispatch = CodeChunk.from(
 fn folded_dispatch(groups: u32) -> vec3<u32> {
     const LIMIT = ${WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION}u;
 
-    let rows = (groups + LIMIT - 1u) / LIMIT;
-    let slices = (rows + LIMIT - 1u) / LIMIT;
+    let rows = divide_round_up_u32(groups, LIMIT);
+    let slices = divide_round_up_u32(rows, LIMIT);
 
     return vec3<u32>(min(groups, LIMIT), min(max(rows, 1u), LIMIT), max(slices, 1u));
 }
-`);
+`, [
+    chunk_divide_round_up_u32,
+]);

package/src/shade/renderer/hiz/hzb_pick_alignment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hzb_pick_alignment.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/hiz/hzb_pick_alignment.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;GAYG;AACH,6CALW,MAAM,YACN,MAAM,cACN,MAAM,GACJ,CAAC,MAAM,EAAE,MAAM,CAAC,CAoI5B"}
+{"version":3,"file":"hzb_pick_alignment.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/hiz/hzb_pick_alignment.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;GAYG;AACH,6CALW,MAAM,YACN,MAAM,cACN,MAAM,GACJ,CAAC,MAAM,EAAE,MAAM,CAAC,CAoI5B"}

package/src/shade/renderer/hiz/hzb_pick_alignment.js

@@ -1,148 +1,149 @@
-import { assert } from "../../../core/assert.js";
-import { msb_32 } from "../../../core/binary/msb_32.js";
-import { bitCount } from "../../../core/binary/operations/bitCount.js";
-
-/**
- * Picks power-of-two alignments `[align_w, align_h]` for HZB mip 0 within the allowed area bloat.
- *
- * Starting from the largest shared power-of-two alignment that fits within `max_bloat`, chases
- * lowest set bits (`d += d & -d`) along each axis to minimize reduction dispatches, maximize
- * SPD-covered mips and exact 2:1 (`2x2`) transitions, and push any remaining odd polyphase
- * transitions to coarser mip levels.
- *
- * @param {number} source_w - Source width in pixels.
- * @param {number} source_h - Source height in pixels.
- * @param {number} [max_bloat=1.05] - Maximum area multiplier relative to unaligned half-res.
- * @returns {[number, number]} Power-of-two alignment factors `[align_w, align_h]`.
- */
-export function hzb_pick_alignment(source_w, source_h, max_bloat = 1.05) {
-    assert.greaterThan(max_bloat, 1, 'max_bloat must be greater than 1');
-    assert.isNonNegativeInteger(source_w, 'source_w');
-    assert.isNonNegativeInteger(source_h, 'source_h');
-
-    const half_w = source_w >>> 1;
-    const half_h = source_h >>> 1;
-
-    if (half_w === 0 || half_h === 0) {
-        return [1, 1];
-    }
-
-    const max_area = half_w * half_h * max_bloat;
-
-    let base_align = 1;
-
-    while (base_align < half_w && base_align < half_h) {
-        const next_align = base_align << 1;
-        const mask = next_align - 1;
-
-        const w = (half_w + mask) & ~mask;
-        const h = (half_h + mask) & ~mask;
-
-        if (w * h > max_area) {
-            break;
-        }
-
-        base_align = next_align;
-    }
-
-    const base_mask = base_align - 1;
-    const w0 = (half_w + base_mask) & ~base_mask;
-    const h0 = (half_h + base_mask) & ~base_mask;
-
-    let best_w = w0;
-    let best_h = h0;
-    let best_steps = Infinity;
-    let best_spd_mips = -1;
-    let best_2x2 = -1;
-    let best_odd_axes = Infinity;
-    let best_odd_work = Infinity;
-    let best_area = Infinity;
-
-    for (let w = w0; w * h0 <= max_area; w += (w & -w)) {
-        const msb_w = msb_32(w);
-        const odd_w = w ^ (1 << msb_w);
-
-        for (let h = h0; ; h += (h & -h)) {
-            const area = w * h;
-            if (area > max_area) {
-                break;
-            }
-
-            const msb_h = msb_32(h);
-            const odd_h = h ^ (1 << msb_h);
-            const total_transitions = msb_w > msb_h ? msb_w : msb_h;
-            const odd_any = odd_w | odd_h;
-
-            let steps = 0;
-            let spd_mips = 0;
-            let mip = 0;
-
-            while (mip < total_transitions) {
-                let count = 0;
-                while (count < 4 && (mip + count) < total_transitions && ((odd_any >>> (mip + count)) & 1) === 0) {
-                    count++;
-                }
-                steps++;
-                if (count >= 2) {
-                    spd_mips += count;
-                    mip += count;
-                } else {
-                    mip += 1;
-                }
-            }
-
-            const count_2x2 = total_transitions - bitCount(odd_any);
-            const count_odd_axes = bitCount(odd_w) + bitCount(odd_h);
-
-            let odd_work = 0;
-            let rem = odd_any;
-            while (rem !== 0) {
-                const lsb = rem & -rem;
-                const m = msb_32(lsb);
-                const taps_x = ((odd_w >>> m) & 1) + 2;
-                const taps_y = ((odd_h >>> m) & 1) + 2;
-                const out_w = (w >>> (m + 1)) || 1;
-                const out_h = (h >>> (m + 1)) || 1;
-                odd_work += out_w * out_h * (taps_x * taps_y - 4);
-                rem ^= lsb;
-            }
-
-            const is_better =
-                steps < best_steps ||
-                (steps === best_steps && (
-                    spd_mips > best_spd_mips ||
-                    (spd_mips === best_spd_mips && (
-                        count_2x2 > best_2x2 ||
-                        (count_2x2 === best_2x2 && (
-                            count_odd_axes < best_odd_axes ||
-                            (count_odd_axes === best_odd_axes && (
-                                odd_work < best_odd_work ||
-                                (odd_work === best_odd_work && area < best_area)
-                            ))
-                        ))
-                    ))
-                ));
-
-            if (is_better) {
-                best_w = w;
-                best_h = h;
-                best_steps = steps;
-                best_spd_mips = spd_mips;
-                best_2x2 = count_2x2;
-                best_odd_axes = count_odd_axes;
-                best_odd_work = odd_work;
-                best_area = area;
-            }
-
-            if ((h & (h - 1)) === 0) {
-                break;
-            }
-        }
-
-        if ((w & (w - 1)) === 0) {
-            break;
-        }
-    }
-
-    return [best_w & -best_w, best_h & -best_h];
-}
+import { assert } from "../../../core/assert.js";
+import { msb_32 } from "../../../core/binary/msb_32.js";
+import { bitCount } from "../../../core/binary/operations/bitCount.js";
+import { isPowerOfTwo } from "../../../core/math/isPowerOfTwo.js";
+
+/**
+ * Picks power-of-two alignments `[align_w, align_h]` for HZB mip 0 within the allowed area bloat.
+ *
+ * Starting from the largest shared power-of-two alignment that fits within `max_bloat`, chases
+ * lowest set bits (`d += d & -d`) along each axis to minimize reduction dispatches, maximize
+ * SPD-covered mips and exact 2:1 (`2x2`) transitions, and push any remaining odd polyphase
+ * transitions to coarser mip levels.
+ *
+ * @param {number} source_w - Source width in pixels.
+ * @param {number} source_h - Source height in pixels.
+ * @param {number} [max_bloat=1.05] - Maximum area multiplier relative to unaligned half-res.
+ * @returns {[number, number]} Power-of-two alignment factors `[align_w, align_h]`.
+ */
+export function hzb_pick_alignment(source_w, source_h, max_bloat = 1.05) {
+    assert.greaterThan(max_bloat, 1, 'max_bloat must be greater than 1');
+    assert.isNonNegativeInteger(source_w, 'source_w');
+    assert.isNonNegativeInteger(source_h, 'source_h');
+
+    const half_w = source_w >>> 1;
+    const half_h = source_h >>> 1;
+
+    if (half_w === 0 || half_h === 0) {
+        return [1, 1];
+    }
+
+    const max_area = half_w * half_h * max_bloat;
+
+    let base_align = 1;
+
+    while (base_align < half_w && base_align < half_h) {
+        const next_align = base_align << 1;
+        const mask = next_align - 1;
+
+        const w = (half_w + mask) & ~mask;
+        const h = (half_h + mask) & ~mask;
+
+        if (w * h > max_area) {
+            break;
+        }
+
+        base_align = next_align;
+    }
+
+    const base_mask = base_align - 1;
+    const w0 = (half_w + base_mask) & ~base_mask;
+    const h0 = (half_h + base_mask) & ~base_mask;
+
+    let best_w = w0;
+    let best_h = h0;
+    let best_steps = Infinity;
+    let best_spd_mips = -1;
+    let best_2x2 = -1;
+    let best_odd_axes = Infinity;
+    let best_odd_work = Infinity;
+    let best_area = Infinity;
+
+    for (let w = w0; w * h0 <= max_area; w += (w & -w)) {
+        const msb_w = msb_32(w);
+        const odd_w = w ^ (1 << msb_w);
+
+        for (let h = h0; ; h += (h & -h)) {
+            const area = w * h;
+            if (area > max_area) {
+                break;
+            }
+
+            const msb_h = msb_32(h);
+            const odd_h = h ^ (1 << msb_h);
+            const total_transitions = msb_w > msb_h ? msb_w : msb_h;
+            const odd_any = odd_w | odd_h;
+
+            let steps = 0;
+            let spd_mips = 0;
+            let mip = 0;
+
+            while (mip < total_transitions) {
+                let count = 0;
+                while (count < 4 && (mip + count) < total_transitions && ((odd_any >>> (mip + count)) & 1) === 0) {
+                    count++;
+                }
+                steps++;
+                if (count >= 2) {
+                    spd_mips += count;
+                    mip += count;
+                } else {
+                    mip += 1;
+                }
+            }
+
+            const count_2x2 = total_transitions - bitCount(odd_any);
+            const count_odd_axes = bitCount(odd_w) + bitCount(odd_h);
+
+            let odd_work = 0;
+            let rem = odd_any;
+            while (rem !== 0) {
+                const lsb = rem & -rem;
+                const m = msb_32(lsb);
+                const taps_x = ((odd_w >>> m) & 1) + 2;
+                const taps_y = ((odd_h >>> m) & 1) + 2;
+                const out_w = (w >>> (m + 1)) || 1;
+                const out_h = (h >>> (m + 1)) || 1;
+                odd_work += out_w * out_h * (taps_x * taps_y - 4);
+                rem ^= lsb;
+            }
+
+            const is_better =
+                steps < best_steps ||
+                (steps === best_steps && (
+                    spd_mips > best_spd_mips ||
+                    (spd_mips === best_spd_mips && (
+                        count_2x2 > best_2x2 ||
+                        (count_2x2 === best_2x2 && (
+                            count_odd_axes < best_odd_axes ||
+                            (count_odd_axes === best_odd_axes && (
+                                odd_work < best_odd_work ||
+                                (odd_work === best_odd_work && area < best_area)
+                            ))
+                        ))
+                    ))
+                ));
+
+            if (is_better) {
+                best_w = w;
+                best_h = h;
+                best_steps = steps;
+                best_spd_mips = spd_mips;
+                best_2x2 = count_2x2;
+                best_odd_axes = count_odd_axes;
+                best_odd_work = odd_work;
+                best_area = area;
+            }
+
+            if (isPowerOfTwo(h)) {
+                break;
+            }
+        }
+
+        if (isPowerOfTwo(w)) {
+            break;
+        }
+    }
+
+    return [best_w & -best_w, best_h & -best_h];
+}

package/src/shade/renderer/light/environment/sh_exponential/shader_sh_exp_environment_cells.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_sh_exp_environment_cells.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/light/environment/sh_exponential/shader_sh_exp_environment_cells.js"],"names":[],"mappings":"AAUA;;;;;;;;;GASG;AACH,8CAFU,MAAM,CAEkC;AA2GlD;;;;;;;;;;;;;;;GAeG;AACH,8CAFU,aAAa,CAMpB;8BAhJ2B,kCAAkC"}
+{"version":3,"file":"shader_sh_exp_environment_cells.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/light/environment/sh_exponential/shader_sh_exp_environment_cells.js"],"names":[],"mappings":"AAWA;;;;;;;;;GASG;AACH,8CAFU,MAAM,CAEkC;AA4GlD;;;;;;;;;;;;;;;GAeG;AACH,8CAFU,aAAa,CAMpB;8BAjJ2B,kCAAkC"}

package/src/shade/renderer/light/environment/sh_exponential/shader_sh_exp_environment_cells.js

@@ -1,5 +1,6 @@
 import { chunk_octahedral_solid_angle } from "../../../shader/chunk/geometry/octahedron/chunk_octahedral_solid_angle.js";
 import { chunk_uv_octahedral_unit_decode } from "../../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_decode.js";
+import { chunk_divide_round_up_u32 } from "../../../shader/chunk/math/chunk_divide_round_up_u32.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
@@ -75,12 +76,12 @@ fn main(
     hi = select(hi, under_centre + 1u, empty);
 
     let span = hi - lo;
-    let stride = (max(span.x, span.y) + MAX_TEXELS_PER_SIDE - 1u) / MAX_TEXELS_PER_SIDE;
+    let stride = divide_round_up_u32(max(span.x, span.y), MAX_TEXELS_PER_SIDE);
     let blocks = (span + stride - 1u) / stride;
     let block_count = blocks.x * blocks.y;
 
     // A cell's bounds come from the workgroup id, so this trip count is uniform; at most 16.
-    let iterations = (block_count + WORKGROUP_SIZE - 1u) / WORKGROUP_SIZE;
+    let iterations = divide_round_up_u32(block_count, WORKGROUP_SIZE);
 
     // radiance times solid angle, and solid angle
     var accumulated = vec4<f32>(0.0);
@@ -120,6 +121,7 @@ fn main(
     cells[2u * cell + 1u] = vec4<f32>(radiance * cell_solid_angle, cell_solid_angle);
 }
 `, [
+    chunk_divide_round_up_u32,
     chunk_octahedral_solid_angle,
     chunk_uv_octahedral_unit_decode,
     chunk_sh_exp_workgroup_sum,

package/src/shade/renderer/light/environment/sh_exponential/shader_sh_exp_log_floor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_sh_exp_log_floor.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/light/environment/sh_exponential/shader_sh_exp_log_floor.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,uCAFU,MAAM,CAE8B;AA8C9C;;;;;;;;;;;;;GAaG;AACH,sCAFU,aAAa,CAMpB;8BA7E2B,kCAAkC"}
+{"version":3,"file":"shader_sh_exp_log_floor.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/light/environment/sh_exponential/shader_sh_exp_log_floor.js"],"names":[],"mappings":"AAUA;;;;;GAKG;AACH,uCAFU,MAAM,CAE8B;AA6C9C;;;;;;;;;;;;;GAaG;AACH,sCAFU,aAAa,CAMpB;8BA5E2B,kCAAkC"}

package/src/shade/renderer/light/environment/sh_exponential/shader_sh_exp_log_floor.js

@@ -1,3 +1,5 @@
+import { chunk_rgb_to_luminance } from "../../../shader/chunk/color/chunk_rgb_to_luminance.js";
+import { chunk_divide_round_up_u32 } from "../../../shader/chunk/math/chunk_divide_round_up_u32.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
@@ -26,15 +28,12 @@ const body = CodeChunk.from(
     `
 const WORKGROUP_SIZE : u32 = ${SH_EXP_WORKGROUP_SIZE}u;
 
-// Rec. 709 luminance, the weighting the floor is relative to
-const LUMINANCE = vec3<f32>(0.2126, 0.7152, 0.0722);
-
 @compute @workgroup_size(${SH_EXP_WORKGROUP_SIZE})
 fn main(@builtin(local_invocation_index) local_index: u32) {
     let sample_count = parameters.sample_count;
 
     // sixteen steps at the default 4096 samples
-    let iterations = (sample_count + WORKGROUP_SIZE - 1u) / WORKGROUP_SIZE;
+    let iterations = divide_round_up_u32(sample_count, WORKGROUP_SIZE);
 
     var luminance = 0.0;
 
@@ -42,7 +41,7 @@ fn main(@builtin(local_invocation_index) local_index: u32) {
         let sample_index = k * WORKGROUP_SIZE + local_index;
 
         if (sample_index < sample_count) {
-            luminance += dot(reflectance[sample_index].xyz, LUMINANCE);
+            luminance += rgb_to_luminance(reflectance[sample_index].xyz);
         }
     }
 
@@ -55,6 +54,8 @@ fn main(@builtin(local_invocation_index) local_index: u32) {
     }
 }
 `, [
+    chunk_divide_round_up_u32,
+    chunk_rgb_to_luminance,
     chunk_sh_exp_workgroup_sum,
 ]);
 

package/src/shade/renderer/light/environment/sh_exponential/shader_sh_exp_project.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_sh_exp_project.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/light/environment/sh_exponential/shader_sh_exp_project.js"],"names":[],"mappings":"AAgFA;;;;;;;;;;;;;GAaG;AACH,oCAFU,aAAa,CAMpB;8BA9F2B,kCAAkC"}
+{"version":3,"file":"shader_sh_exp_project.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/light/environment/sh_exponential/shader_sh_exp_project.js"],"names":[],"mappings":"AAkFA;;;;;;;;;;;;;GAaG;AACH,oCAFU,aAAa,CAMpB;8BA/F2B,kCAAkC"}

package/src/shade/renderer/light/environment/sh_exponential/shader_sh_exp_project.js

@@ -1,6 +1,7 @@
 import { chunk_sh_band_of_index } from "../../../shader/chunk/spherical_harmonics/chunk_sh_band_of_index.js";
 import { chunk_sh_basis_function } from "../../../shader/chunk/spherical_harmonics/chunk_sh_basis_function.js";
 import { chunk_sh_vmf_window } from "../../../shader/chunk/spherical_harmonics/chunk_sh_vmf_window.js";
+import { chunk_divide_round_up_u32 } from "../../../shader/chunk/math/chunk_divide_round_up_u32.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
@@ -43,7 +44,7 @@ fn main(
     let sample_count = parameters.sample_count;
 
     // sixteen steps at the default 4096 samples
-    let iterations = (sample_count + WORKGROUP_SIZE - 1u) / WORKGROUP_SIZE;
+    let iterations = divide_round_up_u32(sample_count, WORKGROUP_SIZE);
 
     var accumulated = vec3<f32>(0.0);
 
@@ -75,6 +76,7 @@ fn main(
     chunk_sh_band_of_index,
     chunk_sh_basis_function,
     chunk_sh_vmf_window,
+    chunk_divide_round_up_u32,
     chunk_sh_exp_workgroup_sum,
 ]);
 

package/src/shade/renderer/light/environment/sh_exponential/shader_sh_exp_reference_reflectance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_sh_exp_reference_reflectance.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/light/environment/sh_exponential/shader_sh_exp_reference_reflectance.js"],"names":[],"mappings":"AA8EA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,kDAFU,aAAa,CAMpB;8BApG2B,kCAAkC"}
+{"version":3,"file":"shader_sh_exp_reference_reflectance.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/light/environment/sh_exponential/shader_sh_exp_reference_reflectance.js"],"names":[],"mappings":"AAgFA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,kDAFU,aAAa,CAMpB;8BArG2B,kCAAkC"}

package/src/shade/renderer/light/environment/sh_exponential/shader_sh_exp_reference_reflectance.js

@@ -1,5 +1,6 @@
 import { chunk_D_GGX } from "../../../shader/chunk/brdf/chunk_D_GGX.js";
 import { chunk_V_GGX_SmithCorrelated } from "../../../shader/chunk/brdf/chunk_V_GGX_SmithCorrelated.js";
+import { chunk_divide_round_up_u32 } from "../../../shader/chunk/math/chunk_divide_round_up_u32.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
@@ -41,7 +42,7 @@ fn main(
     let cell_count = parameters.cell_resolution * parameters.cell_resolution;
 
     // sixteen steps at the 64-cell grid
-    let iterations = (cell_count + WORKGROUP_SIZE - 1u) / WORKGROUP_SIZE;
+    let iterations = divide_round_up_u32(cell_count, WORKGROUP_SIZE);
 
     var reflected = vec3<f32>(0.0);
 
@@ -73,6 +74,7 @@ fn main(
 `, [
     chunk_D_GGX,
     chunk_V_GGX_SmithCorrelated,
+    chunk_divide_round_up_u32,
     chunk_sh_exp_workgroup_sum,
 ]);
 

package/src/shade/renderer/light/environment/sh_exponential/shader_sh_exp_solve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_sh_exp_solve.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/light/environment/sh_exponential/shader_sh_exp_solve.js"],"names":[],"mappings":"AA+EA;;;;;;;;GAQG;AACH,kCAFU,aAAa,CAMpB;8BA3F2B,kCAAkC"}
+{"version":3,"file":"shader_sh_exp_solve.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/light/environment/sh_exponential/shader_sh_exp_solve.js"],"names":[],"mappings":"AAiFA;;;;;;;;GAQG;AACH,kCAFU,aAAa,CAMpB;8BA5F2B,kCAAkC"}

package/src/shade/renderer/light/environment/sh_exponential/shader_sh_exp_solve.js

@@ -1,3 +1,4 @@
+import { chunk_divide_round_up_u32 } from "../../../shader/chunk/math/chunk_divide_round_up_u32.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
@@ -35,7 +36,7 @@ fn main(
     let coefficient = workgroup_id.x;
     let coefficient_count = parameters.coefficient_count;
 
-    let iterations = (coefficient_count + WORKGROUP_SIZE - 1u) / WORKGROUP_SIZE;
+    let iterations = divide_round_up_u32(coefficient_count, WORKGROUP_SIZE);
 
     var accumulated = vec3<f32>(0.0);
 
@@ -74,6 +75,7 @@ fn main(
     }
 }
 `, [
+    chunk_divide_round_up_u32,
     chunk_sh_exp_workgroup_sum,
 ]);
 

package/src/shade/renderer/light/world_cluster/WORLD_LIGHT_CLUSTER.d.ts

@@ -8,11 +8,6 @@ export const WORLD_LIGHT_CLUSTER_GRID_SIZE: number;
  * @type {number}
  */
 export const WORLD_LIGHT_CLUSTER_CELLS_PER_CASCADE: number;
-/**
- * Maximum number of cascades supported by the world-space light cluster clipmap.
- * @type {number}
- */
-export const WORLD_LIGHT_CLUSTER_MAX_CASCADES: number;
 /**
  * Maximum number of lights (point + spot) assigned to a single world-space cluster cell.
  * @type {number}

package/src/shade/renderer/light/world_cluster/WORLD_LIGHT_CLUSTER.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WORLD_LIGHT_CLUSTER.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/world_cluster/WORLD_LIGHT_CLUSTER.js"],"names":[],"mappings":"AAOA;;;GAGG;AACH,4CAFU,MAAM,CAE+B;AAE/C;;;GAGG;AACH,oDAFU,MAAM,CAEwE;AAExF;;;GAGG;AACH,+CAFU,MAAM,CAEiE;AAEjF;;;GAGG;AACH,sDAFU,MAAM,CAE2C;AAE3D;;;GAGG;AACH,iDAFU,MAAM,CAEuC;AAEvD;;;;GAIG;AACH,gDAFU,YAAY,CAOc;AAEpC;;;GAGG;AACH,uCAFU,SAAS,CAsCjB;6BAtF2B,mCAAmC;0BAFtC,oCAAoC"}
+{"version":3,"file":"WORLD_LIGHT_CLUSTER.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/world_cluster/WORLD_LIGHT_CLUSTER.js"],"names":[],"mappings":"AAMA;;;GAGG;AACH,4CAFU,MAAM,CAE+B;AAE/C;;;GAGG;AACH,oDAFU,MAAM,CAEwE;AAExF;;;GAGG;AACH,sDAFU,MAAM,CAE2C;AAE3D;;;GAGG;AACH,iDAFU,MAAM,CAEuC;AAEvD;;;;GAIG;AACH,gDAFU,YAAY,CAOc;AAEpC;;;GAGG;AACH,uCAFU,SAAS,CAsCjB;6BA/E2B,mCAAmC;0BAFtC,oCAAoC"}

package/src/shade/renderer/light/world_cluster/WORLD_LIGHT_CLUSTER.js

@@ -2,7 +2,6 @@ import { chunk_cone_intersects_sphere } from "../../shader/chunk/geometry/cone/c
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { u32, vec3f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
-import { IRRADIANCE_CLIPMAP_CASCADE_LIMIT } from "../../volumetrics/irradiance_clipmap/IRRADIANCE_CLIPMAP.js";
 import { CLUSTER_LIGHT_PROXY } from "../cluster/CLUSTER_LIGHT_PROXY.js";
 
 /**
@@ -17,12 +16,6 @@ export const WORLD_LIGHT_CLUSTER_GRID_SIZE = 8;
  */
 export const WORLD_LIGHT_CLUSTER_CELLS_PER_CASCADE = WORLD_LIGHT_CLUSTER_GRID_SIZE ** 3;
 
-/**
- * Maximum number of cascades supported by the world-space light cluster clipmap.
- * @type {number}
- */
-export const WORLD_LIGHT_CLUSTER_MAX_CASCADES = IRRADIANCE_CLIPMAP_CASCADE_LIMIT;
-
 /**
  * Maximum number of lights (point + spot) assigned to a single world-space cluster cell.
  * @type {number}

package/src/shade/renderer/light/world_cluster/graph_build_world_light_clusters.d.ts

@@ -1,3 +1,16 @@
+/**
+ * Bytes of the cluster lookup over a clipmap of so many cascades.
+ * @param {number} cascade_count
+ * @returns {number}
+ */
+export function world_light_clusters_lookup_size(cascade_count: number): number;
+/**
+ * Bytes of the cluster data over a clipmap of so many cascades: the larger of the two, which a host
+ * checks against the device's `maxStorageBufferBindingSize` for the cascades it builds.
+ * @param {number} cascade_count
+ * @returns {number}
+ */
+export function world_light_clusters_data_size(cascade_count: number): number;
 /**
  * Offer the pipelines {@link graph_build_world_light_clusters} dispatches — see {@link PipelineEnquiry}.
  *
@@ -11,8 +24,8 @@ export function enquire_build_world_light_clusters_pipelines(enquiry: PipelineEn
  * @param {object} options
  * @param {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} options.graph
  * @param {import("../GPULightCollection.js").GPULightCollection} options.lights
- * @param {number} options.levels graph handle of a uniform that starts with the clipmap's cascade windows,
- *   a `CLIPMAP_LEVEL_ARRAY`
+ * @param {number} options.levels graph handle of a buffer that starts with the clipmap's cascade windows,
+ *   `cascade_count` `CLIPMAP_LEVEL_STRUCT`s, finest first, read as storage
  * @param {number} options.cascade_count active cascade count
  * @param {number} options.border cells of its own past each face of a cascade's window that its cluster
  *   cells cover too