@woosh/meep-engine 3.12.0 → 3.13.0

package/src/shade/renderer/gpu_primitive/sort/shader_radix_sort_scatter.js

@@ -1,191 +1,194 @@
-import { WebGPUExtensionType } from "../../../descriptor/WebGPUExtensionType.js";
-import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import { chunk_sort_digit } from "./chunk_sort_digit.js";
-import { chunk_sort_rank } from "./chunk_sort_rank.js";
-import { chunk_sort_workgroup_scan } from "./chunk_sort_workgroup_scan.js";
-import { RADIX, RADIX_LOG, SORT_KEYS_PER_THREAD, SORT_TILE_SIZE, SORT_WORKGROUP_SIZE } from "./defs.js";
-import { SORT_PASS_SETTINGS_STRUCT } from "./SORT_PASS_SETTINGS_STRUCT.js";
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addUniform("settings", SORT_PASS_SETTINGS_STRUCT)
-    .addStorageBuffer("in_keys", WebGPUArray.from(u32), false)
-    .addStorageBuffer("in_values", WebGPUArray.from(u32), false)
-    .addStorageBuffer("out_keys", WebGPUArray.from(u32), true)
-    .addStorageBuffer("out_values", WebGPUArray.from(u32), true)
-    // scanned spine, read flat past its `{count, elements}` header
-    .addStorageBuffer("spine", WebGPUArray.from(u32), false);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-const WORKGROUP_SIZE = ${SORT_WORKGROUP_SIZE}u;
-const KEYS_PER_THREAD = ${SORT_KEYS_PER_THREAD}u;
-const TILE_SIZE = ${SORT_TILE_SIZE}u;
-const RADIX = ${RADIX}u;
-const RADIX_LOG = ${RADIX_LOG}u;
-
-/**
- * The key a slot past the end of the input is filled with. It is the largest u32, so its digit is
- * the largest in every pass and the stable in-tile sort parks every one of them behind every real
- * key — which is what makes "sorted position < the tile's real key count" a sufficient test for
- * whether a slot holds a real key.
- */
-const PADDING_KEY = 0xffffffffu;
-
-var<workgroup> wg_keys: array<u32, TILE_SIZE>;
-var<workgroup> wg_values: array<u32, TILE_SIZE>;
-// one bin per thread; RADIX == WORKGROUP_SIZE
-var<workgroup> wg_histogram: array<atomic<u32>, RADIX>;
-var<workgroup> wg_base: array<u32, RADIX>;
-
-@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
-fn main(
-    @builtin(local_invocation_index) thread_id: u32,
-    @builtin(workgroup_id) workgroup_id: vec3<u32>,
-    @builtin(subgroup_invocation_id) lane_id: u32,
-    @builtin(subgroup_size) lane_count: u32,
-) {
-    let tile = workgroup_id.x;
-    let tile_base = tile * TILE_SIZE;
-    let shift = settings.shift;
-
-    atomicStore(&wg_histogram[thread_id], 0u);
-
-    // Striped load, so neighbouring threads read neighbouring addresses.
-    for (var k = 0u; k < KEYS_PER_THREAD; k += 1u) {
-        let slot = k * WORKGROUP_SIZE + thread_id;
-        let source = tile_base + slot;
-
-        var key = PADDING_KEY;
-        var value = 0u;
-
-        if (source < settings.element_count) {
-            key = in_keys[source];
-            value = in_values[source];
-        }
-
-        wg_keys[slot] = key;
-        wg_values[slot] = value;
-    }
-
-    workgroupBarrier();
-
-    // Local histogram over the real keys only — it has to agree with what the histogram pass
-    // counted, because the spine value this tile reads back was built from that count.
-    for (var k = 0u; k < KEYS_PER_THREAD; k += 1u) {
-        let slot = k * WORKGROUP_SIZE + thread_id;
-
-        if (tile_base + slot < settings.element_count) {
-            atomicAdd(&wg_histogram[sort_extract_digit(wg_keys[slot], shift)], 1u);
-        }
-    }
-
-    workgroupBarrier();
-
-    // this thread's bin, captured before the in-tile sort touches anything
-    let local_count = atomicLoad(&wg_histogram[thread_id]);
-
-    // Order the tile by this pass's digit, one bit at a time, least significant first. Eight stable
-    // binary splits are a sort by the whole 8-bit digit; ranking a key against its same-digit peers
-    // then costs nothing, because the rank IS the sorted position, and the device writes that
-    // follow come out contiguous per bin.
-    for (var bit_index = 0u; bit_index < RADIX_LOG; bit_index += 1u) {
-        let bit = shift + bit_index;
-
-        // Blocked ownership for the permutation: thread t owns the tile's slots
-        // [t*KEYS_PER_THREAD, (t+1)*KEYS_PER_THREAD), so the offsets a thread hands its own keys
-        // are consecutive and the scan below only has to run over one value per thread.
-        var keys: array<u32, KEYS_PER_THREAD>;
-        var values: array<u32, KEYS_PER_THREAD>;
-        var ones = 0u;
-
-        for (var j = 0u; j < KEYS_PER_THREAD; j += 1u) {
-            let slot = thread_id * KEYS_PER_THREAD + j;
-
-            keys[j] = wg_keys[slot];
-            values[j] = wg_values[slot];
-            ones += (keys[j] >> bit) & 1u;
-        }
-
-        // The scan's first barrier is what fences every thread's reads above against the writes
-        // below — by the time it returns, no read of wg_keys/wg_values is outstanding.
-        let scan = sort_workgroup_exclusive_scan(ones, thread_id, lane_id, lane_count);
-
-        let total_zeros = TILE_SIZE - scan.y;
-
-        var ones_before = scan.x;
-        var zeros_before = thread_id * KEYS_PER_THREAD - scan.x;
-
-        for (var j = 0u; j < KEYS_PER_THREAD; j += 1u) {
-            let is_one = ((keys[j] >> bit) & 1u) != 0u;
-            let destination = sort_split_destination(is_one, zeros_before, ones_before, total_zeros);
-
-            if (is_one) {
-                ones_before += 1u;
-            } else {
-                zeros_before += 1u;
-            }
-
-            wg_keys[destination] = keys[j];
-            wg_values[destination] = values[j];
-        }
-
-        workgroupBarrier();
-    }
-
-    // Exclusive prefix of the local histogram — for a tile now sorted by digit this is exactly the
-    // slot each bin's run begins at, and the total is the tile's real key count, because the
-    // padding was never counted.
-    let histogram_scan = sort_workgroup_exclusive_scan(local_count, thread_id, lane_id, lane_count);
-
-    let bin_start = histogram_scan.x;
-    let valid_count = histogram_scan.y;
-
-    let spine_inclusive = spine[sort_spine_index(thread_id, tile, settings.tile_count)];
-
-    wg_base[thread_id] = sort_scatter_base(spine_inclusive, local_count, bin_start);
-
-    workgroupBarrier();
-
-    for (var k = 0u; k < KEYS_PER_THREAD; k += 1u) {
-        let slot = k * WORKGROUP_SIZE + thread_id;
-
-        if (slot < valid_count) {
-            let key = wg_keys[slot];
-            let destination = wg_base[sort_extract_digit(key, shift)] + slot;
-
-            out_keys[destination] = key;
-            out_values[destination] = wg_values[slot];
-        }
-    }
-}
-`, [
-    chunk_sort_digit,
-    chunk_sort_rank,
-    chunk_sort_workgroup_scan,
-]);
-
-body.addExtension(WebGPUExtensionType.Subgroups);
-
-/**
- * Rank-and-scatter — stage (c) of one digit pass of {@link graph_radix_sort}.
- *
- * One workgroup per tile. The tile is sorted by the current digit in workgroup memory (stability is
- * what an LSD radix sort's correctness rests on, and it is also what lets the tail tile's padding
- * be identified by position), the tile's own histogram is re-derived rather than carried over from
- * the histogram pass — the scan is inclusive-only, and re-counting is cheaper than preserving
- * pre-scan counts — and each key is written to
- * `spine_inclusive[bin] - local_count[bin] - bin_start[bin] + sorted_position`.
- *
- * @type {ComputeShader}
- */
-export const shader_radix_sort_scatter = ComputeShader.from({
-    label: "RadixSort/Scatter",
-    resources,
-    body,
-});
+import { WebGPUExtensionType } from "../../../descriptor/WebGPUExtensionType.js";
+import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { chunk_sort_digit } from "./chunk_sort_digit.js";
+import { chunk_sort_rank } from "./chunk_sort_rank.js";
+import { chunk_sort_workgroup_scan } from "./chunk_sort_workgroup_scan.js";
+import { RADIX, RADIX_LOG, SORT_KEYS_PER_THREAD, SORT_TILE_SIZE, SORT_WORKGROUP_SIZE } from "./defs.js";
+import { SORT_PASS_SETTINGS_STRUCT } from "./SORT_PASS_SETTINGS_STRUCT.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+// see shader_radix_sort_histogram — the same per-pass settings, carried as immediate data
+resources.setImmediate("settings", SORT_PASS_SETTINGS_STRUCT);
+
+resources.createGroup()
+    .addStorageBuffer("in_keys", WebGPUArray.from(u32), false)
+    .addStorageBuffer("in_values", WebGPUArray.from(u32), false)
+    .addStorageBuffer("out_keys", WebGPUArray.from(u32), true)
+    .addStorageBuffer("out_values", WebGPUArray.from(u32), true)
+    // scanned spine, read flat past its `{count, elements}` header
+    .addStorageBuffer("spine", WebGPUArray.from(u32), false);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const WORKGROUP_SIZE = ${SORT_WORKGROUP_SIZE}u;
+const KEYS_PER_THREAD = ${SORT_KEYS_PER_THREAD}u;
+const TILE_SIZE = ${SORT_TILE_SIZE}u;
+const RADIX = ${RADIX}u;
+const RADIX_LOG = ${RADIX_LOG}u;
+
+/**
+ * The key a slot past the end of the input is filled with. It is the largest u32, so its digit is
+ * the largest in every pass and the stable in-tile sort parks every one of them behind every real
+ * key — which is what makes "sorted position < the tile's real key count" a sufficient test for
+ * whether a slot holds a real key.
+ */
+const PADDING_KEY = 0xffffffffu;
+
+var<workgroup> wg_keys: array<u32, TILE_SIZE>;
+var<workgroup> wg_values: array<u32, TILE_SIZE>;
+// one bin per thread; RADIX == WORKGROUP_SIZE
+var<workgroup> wg_histogram: array<atomic<u32>, RADIX>;
+var<workgroup> wg_base: array<u32, RADIX>;
+
+@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
+fn main(
+    @builtin(local_invocation_index) thread_id: u32,
+    @builtin(workgroup_id) workgroup_id: vec3<u32>,
+    @builtin(subgroup_invocation_id) lane_id: u32,
+    @builtin(subgroup_size) lane_count: u32,
+) {
+    let tile = workgroup_id.x;
+    let tile_base = tile * TILE_SIZE;
+    let shift = settings.shift;
+
+    atomicStore(&wg_histogram[thread_id], 0u);
+
+    // Striped load, so neighbouring threads read neighbouring addresses.
+    for (var k = 0u; k < KEYS_PER_THREAD; k += 1u) {
+        let slot = k * WORKGROUP_SIZE + thread_id;
+        let source = tile_base + slot;
+
+        var key = PADDING_KEY;
+        var value = 0u;
+
+        if (source < settings.element_count) {
+            key = in_keys[source];
+            value = in_values[source];
+        }
+
+        wg_keys[slot] = key;
+        wg_values[slot] = value;
+    }
+
+    workgroupBarrier();
+
+    // Local histogram over the real keys only — it has to agree with what the histogram pass
+    // counted, because the spine value this tile reads back was built from that count.
+    for (var k = 0u; k < KEYS_PER_THREAD; k += 1u) {
+        let slot = k * WORKGROUP_SIZE + thread_id;
+
+        if (tile_base + slot < settings.element_count) {
+            atomicAdd(&wg_histogram[sort_extract_digit(wg_keys[slot], shift)], 1u);
+        }
+    }
+
+    workgroupBarrier();
+
+    // this thread's bin, captured before the in-tile sort touches anything
+    let local_count = atomicLoad(&wg_histogram[thread_id]);
+
+    // Order the tile by this pass's digit, one bit at a time, least significant first. Eight stable
+    // binary splits are a sort by the whole 8-bit digit; ranking a key against its same-digit peers
+    // then costs nothing, because the rank IS the sorted position, and the device writes that
+    // follow come out contiguous per bin.
+    for (var bit_index = 0u; bit_index < RADIX_LOG; bit_index += 1u) {
+        let bit = shift + bit_index;
+
+        // Blocked ownership for the permutation: thread t owns the tile's slots
+        // [t*KEYS_PER_THREAD, (t+1)*KEYS_PER_THREAD), so the offsets a thread hands its own keys
+        // are consecutive and the scan below only has to run over one value per thread.
+        var keys: array<u32, KEYS_PER_THREAD>;
+        var values: array<u32, KEYS_PER_THREAD>;
+        var ones = 0u;
+
+        for (var j = 0u; j < KEYS_PER_THREAD; j += 1u) {
+            let slot = thread_id * KEYS_PER_THREAD + j;
+
+            keys[j] = wg_keys[slot];
+            values[j] = wg_values[slot];
+            ones += (keys[j] >> bit) & 1u;
+        }
+
+        // The scan's first barrier is what fences every thread's reads above against the writes
+        // below — by the time it returns, no read of wg_keys/wg_values is outstanding.
+        let scan = sort_workgroup_exclusive_scan(ones, thread_id, lane_id, lane_count);
+
+        let total_zeros = TILE_SIZE - scan.y;
+
+        var ones_before = scan.x;
+        var zeros_before = thread_id * KEYS_PER_THREAD - scan.x;
+
+        for (var j = 0u; j < KEYS_PER_THREAD; j += 1u) {
+            let is_one = ((keys[j] >> bit) & 1u) != 0u;
+            let destination = sort_split_destination(is_one, zeros_before, ones_before, total_zeros);
+
+            if (is_one) {
+                ones_before += 1u;
+            } else {
+                zeros_before += 1u;
+            }
+
+            wg_keys[destination] = keys[j];
+            wg_values[destination] = values[j];
+        }
+
+        workgroupBarrier();
+    }
+
+    // Exclusive prefix of the local histogram — for a tile now sorted by digit this is exactly the
+    // slot each bin's run begins at, and the total is the tile's real key count, because the
+    // padding was never counted.
+    let histogram_scan = sort_workgroup_exclusive_scan(local_count, thread_id, lane_id, lane_count);
+
+    let bin_start = histogram_scan.x;
+    let valid_count = histogram_scan.y;
+
+    let spine_inclusive = spine[sort_spine_index(thread_id, tile, settings.tile_count)];
+
+    wg_base[thread_id] = sort_scatter_base(spine_inclusive, local_count, bin_start);
+
+    workgroupBarrier();
+
+    for (var k = 0u; k < KEYS_PER_THREAD; k += 1u) {
+        let slot = k * WORKGROUP_SIZE + thread_id;
+
+        if (slot < valid_count) {
+            let key = wg_keys[slot];
+            let destination = wg_base[sort_extract_digit(key, shift)] + slot;
+
+            out_keys[destination] = key;
+            out_values[destination] = wg_values[slot];
+        }
+    }
+}
+`, [
+    chunk_sort_digit,
+    chunk_sort_rank,
+    chunk_sort_workgroup_scan,
+]);
+
+body.addExtension(WebGPUExtensionType.Subgroups);
+
+/**
+ * Rank-and-scatter — stage (c) of one digit pass of {@link graph_radix_sort}.
+ *
+ * One workgroup per tile. The tile is sorted by the current digit in workgroup memory (stability is
+ * what an LSD radix sort's correctness rests on, and it is also what lets the tail tile's padding
+ * be identified by position), the tile's own histogram is re-derived rather than carried over from
+ * the histogram pass — the scan is inclusive-only, and re-counting is cheaper than preserving
+ * pre-scan counts — and each key is written to
+ * `spine_inclusive[bin] - local_count[bin] - bin_start[bin] + sorted_position`.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_radix_sort_scatter = ComputeShader.from({
+    label: "RadixSort/Scatter",
+    resources,
+    body,
+});

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

@@ -1 +1 @@
-{"version":3,"file":"HierarchicalZBuffer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/hiz/HierarchicalZBuffer.js"],"names":[],"mappings":"AAcA;IAqCI;;;OAGG;IACH,uCAYC;IAzCD;;;OAGG;IACH,iCAEC;IAqCD;;;;;OAKG;IACH,kFAFW,MAAM,EAAE,QAqGlB;IAmDD;;;;OAIG;IACH,mBAHW,MAAM,KACN,MAAM,QAahB;IAgED,gBAGC;;CACJ"}
+{"version":3,"file":"HierarchicalZBuffer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/hiz/HierarchicalZBuffer.js"],"names":[],"mappings":"AASA;IAgCI;;;OAGG;IACH,uCAYC;IApCD;;;OAGG;IACH,iCAEC;IAgCD;;;;;OAKG;IACH,kFAFW,MAAM,EAAE,QAiGlB;IAmED;;;;OAIG;IACH,mBAHW,MAAM,KACN,MAAM,QAahB;IA2BD,gBAEC;;CACJ"}

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

@@ -1,17 +1,12 @@
 import { assert } from "../../../core/assert.js";
 import { max2 } from "../../../core/math/max2.js";
-import { round_up } from "../../../core/math/round_up.js";
 import { TextureDescriptor } from "../../descriptor/texture/TextureDescriptor.js";
 import { TextureViewDescriptor } from "../../descriptor/texture/TextureViewDescriptor.js";
-import { vec4u } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { compute_max_mip_count } from "../../util/compute_max_mip_count.js";
 import { HZB_TEXTURE_FORMAT } from "./HZB_TEXTURE_FORMAT.js";
 import { shader_hzb_reduce_any, shader_hzb_reduce_mip0 } from "./shader_hzb_reduce_any.js";
 import { shader_hzb_reduce_mip0_clip } from "./shader_hzb_reduce_mip0_clip.js";
 
-const VEC2_UINT_SIZE = 2 * Uint32Array.BYTES_PER_ELEMENT;
-
-
 export class HierarchicalZBuffer {
 
     /**
@@ -38,11 +33,6 @@ export class HierarchicalZBuffer {
      */
     #graphics;
 
-    /**
-     * @type {GPUBuffer}
-     */
-    #buffer_resolution;
-
     /**
      *
      * @type {number[]}
@@ -128,20 +118,16 @@ export class HierarchicalZBuffer {
         if (is_clipped_variant) {
             // special case for clip region
 
-            const clip_region = encoder.allocateTransientValueBuffer(vec4u, [
-                source_offset[0], source_offset[1],
-                viewport_size[0], viewport_size[1],
-            ]);
-
             shader_hzb_reduce_mip0_clip.draw({
                 encoder,
                 bindings: {
                     tInput: source_view,
-                    clip_region,
-                    output_resolution: {
-                        buffer: this.#buffer_resolution,
-                        offset: 0,
-                        size: VEC2_UINT_SIZE
+                    settings: {
+                        clip_region: [
+                            source_offset[0], source_offset[1],
+                            viewport_size[0], viewport_size[1],
+                        ],
+                        output_resolution: this.#mip_resolution(0),
                     },
                 },
                 colorAttachments: [{
@@ -192,17 +178,11 @@ export class HierarchicalZBuffer {
         viewport
     ) {
 
-        const align_vec2u = this.#get_aligned_vec2u_size();
-
         shader.draw({
             encoder,
             bindings: {
                 tInput: source_view,
-                output_resolution: {
-                    buffer: this.#buffer_resolution,
-                    offset: index * align_vec2u,
-                    size: VEC2_UINT_SIZE
-                },
+                output_resolution: this.#mip_resolution(index),
             },
             colorAttachments: [
                 {
@@ -216,11 +196,33 @@ export class HierarchicalZBuffer {
 
     }
 
-    #get_aligned_vec2u_size() {
-        const device = this.#graphics.device;
-        const limits = device.limits;
+    /**
+     * Scratch for {@link #mip_resolution}. The value is serialised into the pass's immediate bytes
+     * before the next call, so one array can serve every mip.
+     *
+     * @type {number[]}
+     */
+    #mip_resolution_scratch = [1, 1];
 
-        return round_up(VEC2_UINT_SIZE, limits.minUniformBufferOffsetAlignment);
+    /**
+     * Size of mip `index` of the HZB, which is what the reduction pass writing into it needs to know.
+     *
+     * Each mip halves the one above it, floored at one texel — the same walk that used to be
+     * precomputed into a uniform buffer of every mip's resolution and bound at a per-mip dynamic
+     * offset. As immediate data there is nothing to precompute into.
+     *
+     * @param {number} index
+     * @returns {number[]}
+     */
+    #mip_resolution(index) {
+        const size = this.#texture.size;
+
+        const out = this.#mip_resolution_scratch;
+
+        out[0] = max2(1, size[0] >>> index);
+        out[1] = max2(1, size[1] >>> index);
+
+        return out;
     }
 
     /**
@@ -264,47 +266,9 @@ export class HierarchicalZBuffer {
         texture.descriptor.mipLevelCount = mip_count;
 
         texture.resize(x, y);
-
-        const aligned_vec2u_size = this.#get_aligned_vec2u_size();
-
-        const required_resolution_buffer_size = (mip_count + 1) * aligned_vec2u_size;
-
-        if (this.#buffer_resolution !== undefined) {
-            this.#buffer_resolution.destroy();
-        }
-
-        // build destination resolution buffer for reduction shader
-        this.#buffer_resolution = this.#graphics.device.createBuffer({
-            label: "HZB Destination Resolution",
-            size: required_resolution_buffer_size,
-            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
-            mappedAtCreation: true
-        });
-
-        const res_buffer = this.#buffer_resolution.getMappedRange();
-
-        // write all mip resolutions into the buffer
-        // TODO can get away with just the mip index, can deduce the resolution through bitshift
-        const res_32 = new Uint32Array(res_buffer);
-
-        let res_x = x;
-        let res_y = y;
-
-        const vec2_align4 = aligned_vec2u_size >> 2;
-
-        for (let i = 0; i < mip_count; i++) {
-            res_32[i * vec2_align4] = res_x;
-            res_32[i * vec2_align4 + 1] = res_y;
-
-            res_x = max2(1, res_x >>> 1);
-            res_y = max2(1, res_y >>> 1);
-        }
-
-        this.#buffer_resolution.unmap();
     }
 
     destroy() {
         this.#texture.destroy();
-        this.#buffer_resolution.destroy();
     }
 }

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

@@ -1 +1 @@
-{"version":3,"file":"shader_hzb_reduce_any.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/hiz/shader_hzb_reduce_any.js"],"names":[],"mappings":"AAeA;;;GAGG;AACH,qCAFU,WAAW,CAoBlB;AAGH;;;GAGG;AACH,oCAFU,WAAW,CAmBnB;4BA5D0B,0BAA0B"}
+{"version":3,"file":"shader_hzb_reduce_any.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/hiz/shader_hzb_reduce_any.js"],"names":[],"mappings":"AAoBA;;;GAGG;AACH,qCAFU,WAAW,CAoBlB;AAGH;;;GAGG;AACH,oCAFU,WAAW,CAmBnB;4BAjE0B,0BAA0B"}

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

@@ -7,8 +7,13 @@ import { generate_downsampler_code } from "./generate_downsampler_code.js";
 import { HZB_TEXTURE_FORMAT } from "./HZB_TEXTURE_FORMAT.js";
 
 const resources = new ShaderResourceSetDescriptor();
+
+// per-pass, eight bytes, read-only: immediate data rather than a uniform buffer. The reduction
+// walks the mip chain a pass at a time and every pass wants a different resolution, which used to
+// mean a persistent table of them bound at a per-mip dynamic offset.
+resources.setImmediate("output_resolution", vec2u);
+
 resources.createGroup()
-    .addUniform("output_resolution", vec2u)
     .addTexture("tInput", "unfilterable-float")
 ;
 

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

@@ -1 +1 @@
-{"version":3,"file":"shader_hzb_reduce_mip0_clip.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/hiz/shader_hzb_reduce_mip0_clip.js"],"names":[],"mappings":"AAiFA;;;;GAIG;AACH,0CAFU,WAAW,CAWlB;4BA7FyB,0BAA0B"}
+{"version":3,"file":"shader_hzb_reduce_mip0_clip.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/hiz/shader_hzb_reduce_mip0_clip.js"],"names":[],"mappings":"AAiGA;;;;GAIG;AACH,0CAFU,WAAW,CAWlB;4BA5GyB,0BAA0B"}

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

@@ -1,14 +1,30 @@
 import { vec2u, vec4u } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 import { ImageShader } from "../shader/ImageShader.js";
 import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
 import { ShaderDescriptor } from "../shader/ShaderDescriptor.js";
 import { HZB_TEXTURE_FORMAT } from "./HZB_TEXTURE_FORMAT.js";
 
+/**
+ * Per-pass, 24 bytes, read-only.
+ *
+ * `clip_region` and `output_resolution` were two uniforms, so two buffers per pass. WGSL allows one
+ * immediate per entry point, so carrying them as immediate data means carrying them together.
+ *
+ * @type {WebGPUStruct}
+ */
+const HZB_CLIP_SETTINGS = WebGPUStruct.from({
+    // x, y, width, height
+    clip_region: vec4u,
+    output_resolution: vec2u,
+}, 'HzbClipSettings');
+
 const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", HZB_CLIP_SETTINGS);
+
 resources.createGroup()
-    .addUniform("clip_region", vec4u) //x,y, width, height
-    .addUniform("output_resolution", vec2u)
     .addTexture("tInput", "unfilterable-float")
 ;
 
@@ -23,7 +39,7 @@ fn main(
     
     // 1. Calculate the UV bounds of the current *output* pixel.
     //    We use the output resolution to determine how wide one pixel is in UV space.
-    let output_pixel_size2 = 0.5 / vec2<f32>(output_resolution);
+    let output_pixel_size2 = 0.5 / vec2<f32>(settings.output_resolution);
     let uv_min = uv - output_pixel_size2;
     let uv_max = uv + output_pixel_size2; 
 
@@ -36,7 +52,7 @@ fn main(
     
     // 2. Convert UV bounds to Source Texel coordinates (float).
     //    We map the 0..1 UVs to the size of the source clip region.
-    let source_size = vec2<f32>(clip_region.zw);
+    let source_size = vec2<f32>(settings.clip_region.zw);
     let texel_min_f = safe_uv_min * source_size;
     let texel_max_f = safe_uv_max * source_size;
 
@@ -52,10 +68,10 @@ fn main(
     let bound_max = vec2<i32>(ceil(texel_max_f));
 
     // 4. Clamp bounds to the clip region size to be safe.
-    let limit = vec2<i32>(clip_region.zw);
+    let limit = vec2<i32>(settings.clip_region.zw);
     
-    let start = max(bound_min, vec2<i32>(0)) + vec2<i32>(clip_region.xy);
-    let end   = min(bound_max, limit) + vec2<i32>(clip_region.xy);
+    let start = max(bound_min, vec2<i32>(0)) + vec2<i32>(settings.clip_region.xy);
+    let end   = min(bound_max, limit) + vec2<i32>(settings.clip_region.xy);
 
     var output = vec2<f32>(1.0, 0.0); // Initialize min/max