@woosh/meep-engine 3.60.5 → 3.60.7

package/src/shade/renderer/postprocess/gtao/shader_gtao_spatial_denoise.d.ts

@@ -0,0 +1,16 @@
+/**
+ * GTAO's own spatial filter: one 3x3 edge-stopped pass over visibility and the bend.
+ *
+ * Its input and output are `rgba16float`: visibility in `x`, and in `yzw` the world-space bend, the bent normal
+ * minus the shading normal. The bend is what is filtered, never the bent normal, so an unoccluded texel, whose
+ * bend is zero, keeps the normal map's detail exactly however much its neighbours are averaged in.
+ *
+ * Visibility is filtered as `fragment_shader_denoise_ao` filters it — the A-trous step, its edge-stopping
+ * weights and phi values — with the variance taken from visibility alone, since the input carries no second
+ * moment. That shader stays as it is: it is shared with denoisers that do keep moments.
+ *
+ * @type {ImageShader}
+ */
+export const shader_gtao_spatial_denoise: ImageShader;
+import { ImageShader } from "../../shader/ImageShader.js";
+//# sourceMappingURL=shader_gtao_spatial_denoise.d.ts.map

package/src/shade/renderer/postprocess/gtao/shader_gtao_spatial_denoise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_gtao_spatial_denoise.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/shader_gtao_spatial_denoise.js"],"names":[],"mappings":"AA+HA;;;;;;;;;;;;GAYG;AACH,0CAFU,WAAW,CAiBlB;4BAvJyB,6BAA6B"}

package/src/shade/renderer/postprocess/gtao/shader_gtao_spatial_denoise.js

@@ -0,0 +1,156 @@
+import { DEPTH_STENCIL_FOREGROUND_ONLY } from "../../depth/DEPTH_STENCIL_FOREGROUND_ONLY.js";
+import { chunk_compute_edge_stopping_weight } from "../../shader/chunk/filter/chunk_compute_edge_stopping_weight.js";
+import { chunk_decode_g_buffer_normal } from "../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.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";
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .addTexture("tInput")
+    .addTexture("tDepth")
+    .addTexture("tNormal", "uint");
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const phi_visibility = 4.0;
+const phi_normal = 128.0;
+const sigma_depth = 1.0;
+
+const offsets = array< vec2<i32>, 8 >(
+    vec2( -1, -1 ),
+    vec2(  0, -1 ),
+    vec2(  1, -1 ),
+    vec2( -1,  0 ),
+    vec2(  1,  0 ),
+    vec2( -1,  1 ),
+    vec2(  0,  1 ),
+    vec2(  1,  1 ),
+);
+
+// Visibility's spatial variance over a 3x3 Gaussian. The input carries visibility alone, so its second moment
+// is the square of each texel's.
+fn gtao_visibility_variance(ipos: vec2<i32>) -> f32 {
+    let kernel = array<f32, 3>(0.25, 0.125, 0.0625);
+
+    var moments = vec2<f32>(0.0);
+
+    for (var yy = -1; yy <= 1; yy++) {
+        for (var xx = -1; xx <= 1; xx++) {
+            let v = textureLoad(tInput, ipos + vec2<i32>(xx, yy), 0).x;
+
+            moments += vec2(v, v * v) * kernel[ abs(xx) + abs(yy) ];
+        }
+    }
+
+    return max(moments.y - moments.x * moments.x, 0.0);
+}
+
+@fragment
+fn main(
+    @builtin(position) coord: vec4<f32>,
+) -> @location(0) vec4<f32> {
+    let ipos = vec2<i32>(coord.xy);
+    let screen_size = vec2<i32>(textureDimensions(tInput));
+
+    const eps_variance = 1e-10;
+    const kernel_weights = array<f32,3>( 1.0, 2.0 / 3.0, 1.0 / 6.0 );
+
+    let center = textureLoad(tInput, ipos, 0);
+
+    let std_dev = sqrt(max(0.0, eps_variance + gtao_visibility_variance(ipos)));
+
+    let phi_luma = phi_visibility * std_dev;
+
+    let current_normal = decode_g_buffer_normal(textureLoad(tNormal, ipos, 0).xy);
+    let center_depth   = textureLoad(tDepth, ipos, 0).r;
+
+    // the centre at weight 1, so the edge-stopping functions cannot leave nothing
+    var sum_w_visibility = 1.0;
+    var sum_visibility   = center.x;
+
+    // The bend is averaged weighted by visibility as well. A bent normal stands for the visible directions;
+    // the bent normal of several texels together is the sum of each one's scaled by how much it sees,
+    // normalized, and with neighbours whose normals agree that is the shading normal plus this average.
+    var sum_w_bend = center.x;
+    var sum_bend   = center.yzw * center.x;
+
+    for (var i = 0; i < 8; i++) {
+        let offset = offsets[i];
+
+        let p = ipos + offset;
+
+        if (any(p < vec2(0)) || any(p >= screen_size)) {
+            continue;
+        }
+
+        let kernel = kernel_weights[ abs(offset.x) ] * kernel_weights[ abs(offset.y) ];
+
+        let texel = textureLoad(tInput, p, 0);
+
+        let sample_normal = decode_g_buffer_normal(textureLoad(tNormal, p, 0).xy);
+        let sample_depth  = textureLoad(tDepth, p, 0).r;
+
+        let w = compute_edge_stopping_weight(
+            center_depth,
+            sample_depth,
+            sigma_depth,
+
+            current_normal,
+            sample_normal,
+            phi_normal,
+
+            center.x,
+            texel.x,
+            phi_luma
+        ) * kernel;
+
+        sum_w_visibility += w;
+        sum_visibility   += w * texel.x;
+
+        let w_bend = w * texel.x;
+
+        sum_w_bend += w_bend;
+        sum_bend   += w_bend * texel.yzw;
+    }
+
+    return vec4(sum_visibility / sum_w_visibility, sum_bend / sum_w_bend);
+}
+    `,
+    [
+        chunk_decode_g_buffer_normal,
+        chunk_compute_edge_stopping_weight,
+    ]);
+
+/**
+ * GTAO's own spatial filter: one 3x3 edge-stopped pass over visibility and the bend.
+ *
+ * Its input and output are `rgba16float`: visibility in `x`, and in `yzw` the world-space bend, the bent normal
+ * minus the shading normal. The bend is what is filtered, never the bent normal, so an unoccluded texel, whose
+ * bend is zero, keeps the normal map's detail exactly however much its neighbours are averaged in.
+ *
+ * Visibility is filtered as `fragment_shader_denoise_ao` filters it — the A-trous step, its edge-stopping
+ * weights and phi values — with the variance taken from visibility alone, since the input carries no second
+ * moment. That shader stays as it is: it is shared with denoisers that do keep moments.
+ *
+ * @type {ImageShader}
+ */
+export const shader_gtao_spatial_denoise = ImageShader.from({
+    descriptor: ShaderDescriptor.from({
+        label: "GTAO Spatial Denoise",
+        resources,
+        body
+    }),
+    depthStencil: DEPTH_STENCIL_FOREGROUND_ONLY,
+    targets: [
+        {
+            format: "rgba16float",
+            // Background is skipped, so it keeps the clear: not occluded, not bent. Downstream neighbourhoods
+            // read across silhouettes and must see background as unoccluded.
+            clearValue: [1, 0, 0, 0],
+        }
+    ]
+});

package/src/shade/renderer/postprocess/nss/NSS.d.ts

@@ -51,7 +51,7 @@ export class NSS {
      * @returns {number}
      */
     static recommended_jitter_sequence_size(upscale_ratio: number): number;
-    static "__#210@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
+    static "__#212@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
     /**
      * @param {GraphicsContext} graphics
      */

package/src/shade/renderer/postprocess/nss/chunk_nss_luma_derivative.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_nss_luma_derivative.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/nss/chunk_nss_luma_derivative.js"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,kDAoBE;0BAhCwB,oCAAoC"}
+{"version":3,"file":"chunk_nss_luma_derivative.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/nss/chunk_nss_luma_derivative.js"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,kDAkBE;0BA/BwB,oCAAoC"}

package/src/shade/renderer/postprocess/nss/chunk_nss_luma_derivative.js

@@ -1,6 +1,6 @@
-import { chunk_rgb_to_luminance } from "../../shader/chunk/color/chunk_rgb_to_luminance.js";
-import { F16_MAX_DEFINITION } from "../../shader/chunk/math/F16_MAX_DEFINITION.js";
+import { chunk_rgb_to_luminance } from "../../shader/chunk/color/chunk_rgb_to_luminance.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_nss_tonemap } from "./chunk_nss_tonemap.js";
 
 /**
  * Computes a per-pixel "luminance derivative" — the delta between the
@@ -16,10 +16,8 @@ export const chunk_nss_luma_derivative = CodeChunk.from(
     //language=WGSL
     `
 fn nss_luma_derivative(current_rgb: vec3<f32>, history_rgb: vec3<f32>) -> f32 {
-    let current_finite = select(vec3<f32>(0.0), clamp(current_rgb, vec3<f32>(0.0), vec3<f32>(F16_MAX)), current_rgb == current_rgb);
-    let lc = rgb_to_luminance(current_finite);
-    let history_finite = select(vec3<f32>(0.0), clamp(history_rgb, vec3<f32>(0.0), vec3<f32>(F16_MAX)), history_rgb == history_rgb);
-    let lh = rgb_to_luminance(history_finite);
+    let lc = rgb_to_luminance(nss_sanitize_hdr(current_rgb));
+    let lh = rgb_to_luminance(nss_sanitize_hdr(history_rgb));
 
     // tonemap the luma to compress HDR before differencing — same trick TAA
     // uses to keep specular highlights from saturating the variance metric.
@@ -29,7 +27,7 @@ fn nss_luma_derivative(current_rgb: vec3<f32>, history_rgb: vec3<f32>) -> f32 {
     return saturate(abs(lc_t - lh_t) * 4.0);
 }
     `, [
-        F16_MAX_DEFINITION,
+        chunk_nss_tonemap,
         chunk_rgb_to_luminance,
     ]
 );

package/src/shade/renderer/postprocess/nss/chunk_nss_tonemap.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Shared HDR sanitization and max-channel Karis tonemapping (`c / (1 + max(r, g, b))`) and its
+ * inverse for Neural Super Sampling (NSS).
+ *
+ * ```wgsl
+ * const NSS_EXPOSURE: f32 = 7.38905609893;
+ * fn nss_sanitize_hdr(rgb: vec3<f32>) -> vec3<f32>
+ * fn nss_tonemap(rgb: vec3<f32>) -> vec3<f32>
+ * fn nss_tonemap_exposure(rgb: vec3<f32>) -> vec3<f32>
+ * fn nss_tonemap_inv(rgb: vec3<f32>) -> vec3<f32>
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_nss_tonemap: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_nss_tonemap.d.ts.map

package/src/shade/renderer/postprocess/nss/chunk_nss_tonemap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_nss_tonemap.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/nss/chunk_nss_tonemap.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH,gCAFU,SAAS,CAwCjB;0BAtDwB,oCAAoC"}

package/src/shade/renderer/postprocess/nss/chunk_nss_tonemap.js

@@ -0,0 +1,56 @@
+import { F16_MAX_DEFINITION } from "../../shader/chunk/math/F16_MAX_DEFINITION.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * Shared HDR sanitization and max-channel Karis tonemapping (`c / (1 + max(r, g, b))`) and its
+ * inverse for Neural Super Sampling (NSS).
+ *
+ * ```wgsl
+ * const NSS_EXPOSURE: f32 = 7.38905609893;
+ * fn nss_sanitize_hdr(rgb: vec3<f32>) -> vec3<f32>
+ * fn nss_tonemap(rgb: vec3<f32>) -> vec3<f32>
+ * fn nss_tonemap_exposure(rgb: vec3<f32>) -> vec3<f32>
+ * fn nss_tonemap_inv(rgb: vec3<f32>) -> vec3<f32>
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_nss_tonemap = CodeChunk.from(
+    //language=WGSL
+    `
+const NSS_EXPOSURE: f32 = 7.38905609893; // e^2
+
+fn nss_sanitize_hdr(rgb: vec3<f32>) -> vec3<f32> {
+    return select(vec3<f32>(0.0), clamp(rgb, vec3<f32>(0.0), vec3<f32>(F16_MAX)), rgb == rgb);
+}
+
+// Karis tonemap (max-of-channels).
+// The guard is a FINITE clamp, not just a non-negative one: this target is rgba16float, so shading
+// above its range stores as +Inf and rgb / (1.0 + m) is Inf/Inf = NaN, which goes straight into the
+// next frame's history and stays there. NaN fails every comparison including with itself, which is
+// what the componentwise test in nss_sanitize_hdr is.
+fn nss_tonemap(rgb: vec3<f32>) -> vec3<f32> {
+    let finite = nss_sanitize_hdr(rgb);
+    let m = max(max(finite.r, finite.g), finite.b);
+    return finite / (1.0 + m);
+}
+
+// Karis tonemap (max-of-channels), applied to EXPOSURE-scaled colour.
+// ARM's training distribution: Tonemap(EXPOSURE * raw) -> network input.
+fn nss_tonemap_exposure(rgb: vec3<f32>) -> vec3<f32> {
+    let scaled = nss_sanitize_hdr(rgb) * NSS_EXPOSURE;
+    let m = max(max(scaled.r, scaled.g), scaled.b);
+    return scaled / (1.0 + m);
+}
+
+// Karis inverse — clamp to dodge the inf at m == 1.0.
+fn nss_tonemap_inv(rgb: vec3<f32>) -> vec3<f32> {
+    let c = clamp(rgb, vec3<f32>(0.0), vec3<f32>(0.99999));
+    let m = max(max(c.r, c.g), c.b);
+    return c / (1.0 - m);
+}
+`,
+    [
+        F16_MAX_DEFINITION,
+    ]
+);

package/src/shade/renderer/postprocess/nss/shader_nss_postprocess.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_nss_postprocess.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/nss/shader_nss_postprocess.js"],"names":[],"mappings":"AAiSA,mDAIG;8BAnS2B,+BAA+B"}
+{"version":3,"file":"shader_nss_postprocess.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/nss/shader_nss_postprocess.js"],"names":[],"mappings":"AA6QA,mDAIG;8BAhR2B,+BAA+B"}

package/src/shade/renderer/postprocess/nss/shader_nss_postprocess.js

@@ -1,8 +1,8 @@
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { F16_MAX_DEFINITION } from "../../shader/chunk/math/F16_MAX_DEFINITION.js";
 import { ComputeShader } from "../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
 import { SAMPLER_LINEAR_UPSCALE } from "../../texture/SAMPLER_LINEAR_UPSCALE.js";
+import { chunk_nss_tonemap } from "./chunk_nss_tonemap.js";
 import { NSS_WORKGROUP_SIZE } from "./NSS_CONSTANTS.js";
 import { NSS_SETTINGS_STRUCT } from "./NSS_SETTINGS_STRUCT.js";
 
@@ -50,26 +50,6 @@ resources.createGroup()
 const body = CodeChunk.from(
     //language=WGSL
     `
-const NSS_EXPOSURE: f32 = 7.38905609893; // e^2
-
-// Karis tonemap (max-of-channels).
-// The guard is a FINITE clamp, not just a non-negative one: this target is rgba16float, so shading
-// above its range stores as +Inf and rgb / (1.0 + m) is Inf/Inf = NaN, which goes straight into the
-// next frame's history and stays there. NaN fails every comparison including with itself, which is
-// what the componentwise test below is.
-fn nss_tonemap(rgb: vec3<f32>) -> vec3<f32> {
-    let finite = select(vec3<f32>(0.0), min(rgb, vec3<f32>(F16_MAX)), rgb == rgb);
-    let m = max(max(finite.r, finite.g), finite.b);
-    return finite / (1.0 + m);
-}
-
-// Karis inverse — clamp to dodge the inf at m == 1.0.
-fn nss_tonemap_inv(rgb: vec3<f32>) -> vec3<f32> {
-    let c = clamp(rgb, vec3<f32>(0.0), vec3<f32>(0.99999));
-    let m = max(max(c.r, c.g), c.b);
-    return c / (1.0 - m);
-}
-
 fn nss_warped_history(prev_uv: vec2<f32>) -> vec3<f32> {
     let on_screen = all(prev_uv >= vec2<f32>(0.0)) && all(prev_uv <= vec2<f32>(1.0));
     if (!on_screen) {
@@ -282,7 +262,7 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
     textureStore(tOutput, out_st, vec4<f32>(final_rgb, theta));
 }
     `, [
-        F16_MAX_DEFINITION,
+        chunk_nss_tonemap,
         NSS_SETTINGS_STRUCT.declaration_chunk,
     ]
 );

package/src/shade/renderer/postprocess/nss/shader_nss_preprocess.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_nss_preprocess.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/nss/shader_nss_preprocess.js"],"names":[],"mappings":"AAiPA,kDAIG;8BAnP2B,+BAA+B"}
+{"version":3,"file":"shader_nss_preprocess.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/nss/shader_nss_preprocess.js"],"names":[],"mappings":"AAsOA,kDAIG;8BAzO2B,+BAA+B"}

package/src/shade/renderer/postprocess/nss/shader_nss_preprocess.js

@@ -1,10 +1,10 @@
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { F16_MAX_DEFINITION } from "../../shader/chunk/math/F16_MAX_DEFINITION.js";
 import { ComputeShader } from "../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
 import { SAMPLER_LINEAR_UPSCALE } from "../../texture/SAMPLER_LINEAR_UPSCALE.js";
 import { chunk_nss_find_nearest_depth } from "./chunk_nss_find_nearest_depth.js";
 import { chunk_nss_luma_derivative } from "./chunk_nss_luma_derivative.js";
+import { chunk_nss_tonemap } from "./chunk_nss_tonemap.js";
 import { NSS_WORKGROUP_SIZE } from "./NSS_CONSTANTS.js";
 import { NSS_SETTINGS_STRUCT } from "./NSS_SETTINGS_STRUCT.js";
 
@@ -68,17 +68,6 @@ resources.createGroup()
 const body = CodeChunk.from(
     //language=WGSL
     `
-const NSS_EXPOSURE: f32 = 7.38905609893; // e^2
-
-// Karis tonemap (max-of-channels), applied to EXPOSURE-scaled colour.
-// ARM's training distribution: Tonemap(EXPOSURE * raw) -> network input.
-fn nss_tonemap_exposure(rgb: vec3<f32>) -> vec3<f32> {
-    let finite = select(vec3<f32>(0.0), clamp(rgb, vec3<f32>(0.0), vec3<f32>(F16_MAX)), rgb == rgb);
-    let scaled = finite * NSS_EXPOSURE;
-    let m = max(max(scaled.r, scaled.g), scaled.b);
-    return scaled / (1.0 + m);
-}
-
 // ARM's network was trained against inputs that go through their Quantize
 // formula: int8 = round(fp * 255 - 128). The conv then sees (uint8 - 128)
 // = signed int8 in [-128, 127] - i.e. fp 0 -> -128, fp 0.5 -> 0, fp 1 -> 127.
@@ -232,9 +221,9 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
     textureStore(tNearestOffset, st, vec4<f32>(nearest_packed, 0.0, 0.0));
 }
     `, [
-        F16_MAX_DEFINITION,
         chunk_nss_find_nearest_depth,
         chunk_nss_luma_derivative,
+        chunk_nss_tonemap,
         NSS_SETTINGS_STRUCT.declaration_chunk,
     ]
 );

package/src/shade/renderer/rasterize/bucket/prepare_meshlet_draw_commands_by_material.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prepare_meshlet_draw_commands_by_material.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/bucket/prepare_meshlet_draw_commands_by_material.js"],"names":[],"mappings":"AA+BA;;;;;;;;;;;;;;;GAeG;AACH,uKAJa;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,kBAAkB,EAAE,MAAM,CAAC;IAAC,wBAAwB,EAAE,MAAM,CAAA;CAAC,CA2VnH"}
+{"version":3,"file":"prepare_meshlet_draw_commands_by_material.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/bucket/prepare_meshlet_draw_commands_by_material.js"],"names":[],"mappings":"AAiCA;;;;;;;;;;;;;;;GAeG;AACH,uKAJa;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,kBAAkB,EAAE,MAAM,CAAC;IAAC,wBAAwB,EAAE,MAAM,CAAA;CAAC,CAsVnH"}

package/src/shade/renderer/rasterize/bucket/prepare_meshlet_draw_commands_by_material.js

@@ -1,10 +1,12 @@
 import { assert } from "../../../../core/assert.js";
-import { ceilPowerOfTwo } from "../../../../core/binary/operations/ceilPowerOfTwo.js";
 import { round_up } from "../../../../core/math/round_up.js";
 import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
 import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { STRUCT_UNINDEXED_DRAW_COMMAND } from "../../gpu_primitive/indirect/STRUCT_UNINDEXED_DRAW_COMMAND.js";
-import { cpu_build_hash_table } from "../../gpu_primitive/hash_table/cpu_build_hash_table.js";
+import {
+    cpu_hash_table_create,
+    cpu_hash_table_word_count
+} from "../../gpu_primitive/hash_table/cpu_build_hash_table.js";
 import {
     graph_prefix_scan_csdldf,
     prefix_scan_csdldf_output_descriptor
@@ -215,21 +217,16 @@ export function graph_prepare_meshlet_draw_commands_by_material({
     // 2. build material lookup table
     const material_ids = materials.map(m => m.id);
     const material_count = material_ids.length;
-    const HASH_TABLE_SLACK = 1.3;
-    const material_table_size = ceilPowerOfTwo(Math.max(1, material_count * HASH_TABLE_SLACK));
-    const material_lookup_data = new ArrayBuffer((material_table_size * 2 + 2) * 4)
-    const material_lookup = new Uint32Array(material_lookup_data);
-    cpu_build_hash_table(
-        material_lookup, 0,
-        material_table_size,
-        material_ids,
-        material_count,
-    );
+    let material_lookup = new Uint32Array(cpu_hash_table_word_count(material_count));
+
+    while (!cpu_hash_table_create(material_lookup, material_ids, material_count)) {
+        material_lookup = new Uint32Array(material_lookup.length * 2);
+    }
 
     // TODO build the table on the GPU
     const gr_material_lookup = graph_import_raw_buffer({
         graph,
-        value: material_lookup_data,
+        value: material_lookup.buffer,
         usage: GPUBufferUsage.STORAGE,
     });
 

package/src/shade/renderer/rasterize/expand/bucket/RASTERIZATION_BUCKET_LIMIT.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RASTERIZATION_BUCKET_LIMIT.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/expand/bucket/RASTERIZATION_BUCKET_LIMIT.js"],"names":[],"mappings":"AAkBA,+DAA0F;AAC1F,8DAAsF;AAEtF;;;;;;;;GAQG;AACH,0DAFU,MAAM,CAE6C;AAE7D;;;;GAIG;AACH,yCAFU,MAAM,CAEsK"}
+{"version":3,"file":"RASTERIZATION_BUCKET_LIMIT.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/expand/bucket/RASTERIZATION_BUCKET_LIMIT.js"],"names":[],"mappings":"AAmBA,+DAA0F;AAC1F,8DAAsF;AAEtF;;;;;;;;GAQG;AACH,0DAFU,MAAM,CAE6C;AAE7D;;;;GAIG;AACH,yCAFU,MAAM,CAEsK"}

package/src/shade/renderer/rasterize/expand/bucket/RASTERIZATION_BUCKET_LIMIT.js

@@ -1,38 +1,39 @@
-import { assert } from "../../../../../core/assert.js";
-import { ShadeDrawMode } from "../../../material/ShadeDrawMode.js";
-import { TransparencyMode } from "../../../material/TransparencyMode.js";
-
-/**
- *
- * @param {Object} e enum
- * @return {number} number of bits required to represent it
- */
-function enum_bit_count(e) {
-    const max = Math.max.apply(null, Object.values(e));
-
-    assert.isNonNegativeInteger(max, 'max');
-    assert.lessThanOrEqual(max, 5, "the bucket count is going to be absurd");
-
-    return 32 - Math.clz32(max);
-}
-
-export const RASTERIZATION_BUCKET_BIT_COUNT_ALPHA_MODE = enum_bit_count(TransparencyMode);
-export const RASTERIZATION_BUCKET_BIT_COUNT_DRAW_MODE = enum_bit_count(ShadeDrawMode);
-
-/**
- * One bit, not the two {@link ShadeDrawSide} would need. Only double-sided geometry needs a
- * pipeline of its own — `cullMode: 'none'` has no winding equivalent. `Front` and `Back` share
- * one: a back-sided material is a front-sided one drawn with its winding reversed, and the
- * vertex shader does the reversing.
- *
- * @see rasterization_material_bucket
- * @type {number}
- */
-export const RASTERIZATION_BUCKET_BIT_COUNT_DOUBLE_SIDED = 1;
-
-/**
- * Maximum number of rasterization buckets. This is a number of permutations of different alpha and draw modes.
- * See Northlight talk on "Alan Wake 2" meshlet shading.
- * @type {number}
- */
-export const RASTERIZATION_BUCKET_LIMIT = (1 << (RASTERIZATION_BUCKET_BIT_COUNT_ALPHA_MODE + RASTERIZATION_BUCKET_BIT_COUNT_DRAW_MODE + RASTERIZATION_BUCKET_BIT_COUNT_DOUBLE_SIDED));
+import { assert } from "../../../../../core/assert.js";
+import { ShadeDrawMode } from "../../../material/ShadeDrawMode.js";
+import { TransparencyMode } from "../../../material/TransparencyMode.js";
+import { ceil_log2 } from "../../../../../core/binary/operations/ceil_log2.js";
+
+/**
+ *
+ * @param {Object} e enum
+ * @return {number} number of bits required to represent it
+ */
+function enum_bit_count(e) {
+    const max = Math.max.apply(null, Object.values(e));
+
+    assert.isNonNegativeInteger(max, 'max');
+    assert.lessThanOrEqual(max, 5, "the bucket count is going to be absurd");
+
+    return ceil_log2(max + 1);
+}
+
+export const RASTERIZATION_BUCKET_BIT_COUNT_ALPHA_MODE = enum_bit_count(TransparencyMode);
+export const RASTERIZATION_BUCKET_BIT_COUNT_DRAW_MODE = enum_bit_count(ShadeDrawMode);
+
+/**
+ * One bit, not the two {@link ShadeDrawSide} would need. Only double-sided geometry needs a
+ * pipeline of its own — `cullMode: 'none'` has no winding equivalent. `Front` and `Back` share
+ * one: a back-sided material is a front-sided one drawn with its winding reversed, and the
+ * vertex shader does the reversing.
+ *
+ * @see rasterization_material_bucket
+ * @type {number}
+ */
+export const RASTERIZATION_BUCKET_BIT_COUNT_DOUBLE_SIDED = 1;
+
+/**
+ * Maximum number of rasterization buckets. This is a number of permutations of different alpha and draw modes.
+ * See Northlight talk on "Alan Wake 2" meshlet shading.
+ * @type {number}
+ */
+export const RASTERIZATION_BUCKET_LIMIT = (1 << (RASTERIZATION_BUCKET_BIT_COUNT_ALPHA_MODE + RASTERIZATION_BUCKET_BIT_COUNT_DRAW_MODE + RASTERIZATION_BUCKET_BIT_COUNT_DOUBLE_SIDED));

package/src/shade/renderer/rasterize/expand/mesh/shader_prefix_sum_to_command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_prefix_sum_to_command.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/expand/mesh/shader_prefix_sum_to_command.js"],"names":[],"mappings":"AA8DA,yDAIG;8BA1D2B,kCAAkC"}
+{"version":3,"file":"shader_prefix_sum_to_command.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/expand/mesh/shader_prefix_sum_to_command.js"],"names":[],"mappings":"AAyDA,yDAIG;8BAvD2B,kCAAkC"}

package/src/shade/renderer/rasterize/expand/mesh/shader_prefix_sum_to_command.js

@@ -1,6 +1,4 @@
-import {
-    WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION
-} from "../../../gpu_primitive/indirect/WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION.js";
+import { chunk_folded_dispatch } from "../../../gpu_primitive/indirect/chunk_folded_dispatch.js";
 import { STRUCT_DISPATCH_COMPUTE_COMMAND } from "../../../gpu_primitive/indirect/STRUCT_DISPATCH_COMPUTE_COMMAND.js";
 import { COLLECTION_U32_STRUCT_READ } from "../../../gpu_primitive/COLLECTION_U32_STRUCT_READ.js";
 import { chunk_divide_round_up_u32 } from "../../../shader/chunk/math/chunk_divide_round_up_u32.js";
@@ -43,20 +41,17 @@ fn main(){
      It is also the stride folded_workgroup_index flattens by, so the two builders have to agree on
      it: a row of x shorter than that would leave a gap in the index.
     */
-    const LIMIT = ${WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION}u;
-
     let desired_groups = divide_round_up_u32(total_count, TARGET_GROUP_SIZE);
+    let folded = folded_dispatch(desired_groups);
 
-    let rows = divide_round_up_u32(desired_groups, LIMIT);
-    let slices = divide_round_up_u32(rows, LIMIT);
-
-    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;
 
 }
     `, [
-        chunk_divide_round_up_u32
+        chunk_divide_round_up_u32,
+        chunk_folded_dispatch,
     ]
 )
 

package/src/shade/renderer/scene/GPUSceneContext.d.ts

@@ -105,8 +105,8 @@ export class GPUSceneContext {
      * (REVIEW_LEDGER U1): `register` a container with {@link virtual_geometry_residency}, and every
      * page after the root arrives because a cut asked for it. The renderer opens and closes each
      * frame and schedules each reading, and {@link destroy} releases all of it; a host touches none
-     * of it. With them, the source of its geometries' caches ({@link VGeoSDFProxies}): a cache asked
-     * of a virtual geometry is baked from a proxy cut from it.
+     * of it. With them, the source of its geometries' caches and cards ({@link VGeoSDFProxies}): a virtual
+     * geometry whose cache is asked for stands in through its proxy.
      *
      * @param {Object} [options] passed to {@link GPUVirtualGeometryPool} and
      *     {@link GPUVirtualGeometryRuntime}, except for `residency`

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

@@ -399,8 +399,8 @@ export class GPUSceneContext {
      * (REVIEW_LEDGER U1): `register` a container with {@link virtual_geometry_residency}, and every
      * page after the root arrives because a cut asked for it. The renderer opens and closes each
      * frame and schedules each reading, and {@link destroy} releases all of it; a host touches none
-     * of it. With them, the source of its geometries' caches ({@link VGeoSDFProxies}): a cache asked
-     * of a virtual geometry is baked from a proxy cut from it.
+     * of it. With them, the source of its geometries' caches and cards ({@link VGeoSDFProxies}): a virtual
+     * geometry whose cache is asked for stands in through its proxy.
      *
      * @param {Object} [options] passed to {@link GPUVirtualGeometryPool} and
      *     {@link GPUVirtualGeometryRuntime}, except for `residency`
@@ -448,8 +448,8 @@ export class GPUSceneContext {
 
             feedback = new VGeoFeedbackLoop({ runtime, residency: tiers });
 
-            // last: it makes its buffers and subscribes to the caches as it is made
-            proxies = new VGeoSDFProxies({ device: this.#device, runtime, geometries: this.geometries });
+            // last: it subscribes to the caches as it is made
+            proxies = new VGeoSDFProxies({ geometries: this.geometries });
         } catch (error) {
             // the pool is the only one holding anything yet: the fetcher spawns its workers on its
             // first fetch, and the runtime makes its buffer on its first frame
@@ -874,7 +874,7 @@ export class GPUSceneContext {
             return;
         }
 
-        // its proxies out of the geometry manager, and its cut's buffers, ahead of the runtime's
+        // it hears no more of the caches; its proxies stay with the geometry manager, destroyed with it
         this.#virtual_geometry_proxies.destroy();
 
         this.#virtual_geometry_feedback.destroy();

package/src/shade/renderer/shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.d.ts

@@ -1,8 +1,3 @@
-/**
- * Levels a clipmap table holds at most, and how far `clipmap_select_finest` walks.
- * @type {number}
- */
-export const CLIPMAP_LEVEL_LIMIT: number;
 /**
  * One level of a clipmap as a shader reads it: the level's window, and how big its cell is. Levels
  * sit finest first in a {@link CLIPMAP_LEVEL_ARRAY}.
@@ -13,7 +8,14 @@ export const CLIPMAP_LEVEL_LIMIT: number;
  */
 export const CLIPMAP_LEVEL_STRUCT: WebGPUStruct;
 /**
- * A clipmap's table of levels, as a field of the uniform that carries it.
+ * Levels a clipmap table holds: as many as fill the uniform binding every device allows, 2,048. The
+ * table is a uniform, whose length its type fixes, so this is the most levels any clipmap can have;
+ * a walk over it stops at the clipmap's own count, and a writer uploads only the levels it has.
+ * @type {number}
+ */
+export const CLIPMAP_LEVEL_LIMIT: number;
+/**
+ * A clipmap's table of levels, a uniform of its own, {@link CLIPMAP_LEVEL_LIMIT} long.
  * @type {WebGPUArray}
  */
 export const CLIPMAP_LEVEL_ARRAY: WebGPUArray;