@woosh/meep-engine 3.60.6 → 3.60.8

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/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;

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

@@ -1 +1 @@
-{"version":3,"file":"CLIPMAP_LEVEL_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js"],"names":[],"mappings":"AAIA;;;GAGG;AACH,kCAFU,MAAM,CAEsB;AAEtC;;;;;;;GAOG;AACH,mCAFU,YAAY,CAeH;AAEnB;;;GAGG;AACH,kCAFU,WAAW,CAE0E;6BAnClE,4BAA4B;4BAD7B,2BAA2B"}
+{"version":3,"file":"CLIPMAP_LEVEL_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js"],"names":[],"mappings":"AAKA;;;;;;;GAOG;AACH,mCAFU,YAAY,CAeH;AAEnB;;;;;GAKG;AACH,kCAFU,MAAM,CAEqH;AAErI;;;GAGG;AACH,kCAFU,WAAW,CAE0E;6BArClE,4BAA4B;4BAD7B,2BAA2B"}

package/src/shade/renderer/shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js

@@ -1,13 +1,8 @@
+import { WEBGPU_GUARANTEED_MAX_UNIFORM_BUFFER_BINDING_SIZE } from "../../../gpu_primitive/WEBGPU_GUARANTEED_MAX_UNIFORM_BUFFER_BINDING_SIZE.js";
 import { f32, vec3i } from "../../type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../../type/WebGPUArray.js";
 import { WebGPUStruct } from "../../type/WebGPUStruct.js";
 
-/**
- * Levels a clipmap table holds at most, and how far `clipmap_select_finest` walks.
- * @type {number}
- */
-export const CLIPMAP_LEVEL_LIMIT = 16;
-
 /**
  * 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}.
@@ -32,7 +27,15 @@ export const CLIPMAP_LEVEL_STRUCT = WebGPUStruct.from({
 }, "ClipmapLevel");
 
 /**
- * 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 = Math.floor(WEBGPU_GUARANTEED_MAX_UNIFORM_BUFFER_BINDING_SIZE / CLIPMAP_LEVEL_STRUCT.aligned_size);
+
+/**
+ * A clipmap's table of levels, a uniform of its own, {@link CLIPMAP_LEVEL_LIMIT} long.
  * @type {WebGPUArray}
  */
 export const CLIPMAP_LEVEL_ARRAY = WebGPUArray.from(CLIPMAP_LEVEL_STRUCT, CLIPMAP_LEVEL_LIMIT);

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

@@ -0,0 +1,16 @@
+/**
+ * Shared key packing/unpacking and stacked 3D indirection texel coordinates for clipmap cascades
+ * of cubic window resolution `resolution`:
+ *
+ * ```wgsl
+ * fn clipmap_key(cascade: u32, storage: vec3<u32>, resolution: u32) -> u32
+ * fn clipmap_key_cascade(key: u32, resolution: u32) -> u32
+ * fn clipmap_key_storage(key: u32, resolution: u32) -> vec3<u32>
+ * fn clipmap_stacked_texel(cascade: u32, storage: vec3<u32>, resolution: u32) -> vec3<u32>
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_clipmap_key: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_clipmap_key.d.ts.map

package/src/shade/renderer/shader/chunk/clipmap/chunk_clipmap_key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_clipmap_key.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/clipmap/chunk_clipmap_key.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,gCAFU,SAAS,CAqBjB;0BAlCwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/clipmap/chunk_clipmap_key.js

@@ -0,0 +1,35 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * Shared key packing/unpacking and stacked 3D indirection texel coordinates for clipmap cascades
+ * of cubic window resolution `resolution`:
+ *
+ * ```wgsl
+ * fn clipmap_key(cascade: u32, storage: vec3<u32>, resolution: u32) -> u32
+ * fn clipmap_key_cascade(key: u32, resolution: u32) -> u32
+ * fn clipmap_key_storage(key: u32, resolution: u32) -> vec3<u32>
+ * fn clipmap_stacked_texel(cascade: u32, storage: vec3<u32>, resolution: u32) -> vec3<u32>
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_clipmap_key = CodeChunk.from(
+    //language=WGSL
+    `
+fn clipmap_key(cascade: u32, storage: vec3<u32>, resolution: u32) -> u32 {
+    return (cascade * resolution + storage.z) * resolution * resolution + storage.y * resolution + storage.x;
+}
+
+fn clipmap_key_cascade(key: u32, resolution: u32) -> u32 {
+    return key / (resolution * resolution * resolution);
+}
+
+fn clipmap_key_storage(key: u32, resolution: u32) -> vec3<u32> {
+    return vec3<u32>(key % resolution, (key / resolution) % resolution, (key / (resolution * resolution)) % resolution);
+}
+
+fn clipmap_stacked_texel(cascade: u32, storage: vec3<u32>, resolution: u32) -> vec3<u32> {
+    return vec3<u32>(storage.x, storage.y, storage.z + cascade * resolution);
+}
+`
+);

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

@@ -2,14 +2,17 @@
  * The finest level of a clipmap whose window holds a world point, and how far into that window's
  * edge band the point is.
  *
- * Walks the first `count` levels of the table, finest first, at most {@link CLIPMAP_LEVEL_LIMIT}; the
- * first whose window holds the cell the point is in answers. Its `edge_weight` is the point's distance
+ * Walks the first `count` levels of the table, finest first; the first whose window holds the cell the
+ * point is in answers. Its `edge_weight` is the point's distance
  * to the window's nearest face, in the level's cells, through a linear ramp: 0 at `band_width` cells
  * or deeper, 1 on the face. It is how much a reader blends toward the next coarser source — the
  * parent level, or whatever stands outside the coarsest. `band_width` is positive.
  *
  * A point no level holds answers `CLIPMAP_LEVEL_NONE`, with a weight of 0.
  *
+ * `clipmap_level_select` is one level's test, for a table that is not a {@link CLIPMAP_LEVEL_ARRAY} of its
+ * own: the edge weight of a point the level's window holds, or a negative one for a point it does not.
+ *
  * The CPU twin is `clipmap_select_finest` in `core/geom/clipmap/`.
  *
  * @type {CodeChunk}

package/src/shade/renderer/shader/chunk/clipmap/chunk_clipmap_select_finest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_clipmap_select_finest.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/clipmap/chunk_clipmap_select_finest.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;GAeG;AACH,0CAFU,SAAS,CAoDjB;0BAtEwB,6BAA6B"}
+{"version":3,"file":"chunk_clipmap_select_finest.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/clipmap/chunk_clipmap_select_finest.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;GAkBG;AACH,0CAFU,SAAS,CA0DjB;0BA/EwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/clipmap/chunk_clipmap_select_finest.js

@@ -6,14 +6,17 @@ import { chunk_clipmap_contains } from "./chunk_clipmap_contains.js";
  * The finest level of a clipmap whose window holds a world point, and how far into that window's
  * edge band the point is.
  *
- * Walks the first `count` levels of the table, finest first, at most {@link CLIPMAP_LEVEL_LIMIT}; the
- * first whose window holds the cell the point is in answers. Its `edge_weight` is the point's distance
+ * Walks the first `count` levels of the table, finest first; the first whose window holds the cell the
+ * point is in answers. Its `edge_weight` is the point's distance
  * to the window's nearest face, in the level's cells, through a linear ramp: 0 at `band_width` cells
  * or deeper, 1 on the face. It is how much a reader blends toward the next coarser source — the
  * parent level, or whatever stands outside the coarsest. `band_width` is positive.
  *
  * A point no level holds answers `CLIPMAP_LEVEL_NONE`, with a weight of 0.
  *
+ * `clipmap_level_select` is one level's test, for a table that is not a {@link CLIPMAP_LEVEL_ARRAY} of its
+ * own: the edge weight of a point the level's window holds, or a negative one for a point it does not.
+ *
  * The CPU twin is `clipmap_select_finest` in `core/geom/clipmap/`.
  *
  * @type {CodeChunk}
@@ -30,6 +33,25 @@ struct ClipmapSelection {
     edge_weight: f32,
 }
 
+fn clipmap_level_select(level: ClipmapLevel, position_ws: vec3f, band_width: f32) -> f32 {
+    // the point in the level's cells
+    let position_cells = position_ws / level.cell_size;
+
+    if (!clipmap_contains(vec3<i32>(floor(position_cells)), level.corner, level.size)) {
+        return -1.0;
+    }
+
+    let from_corner = position_cells - vec3f(level.corner);
+    let to_far_corner = vec3f(level.size) - from_corner;
+
+    let edge = min(
+        min(min(from_corner.x, from_corner.y), from_corner.z),
+        min(min(to_far_corner.x, to_far_corner.y), to_far_corner.z)
+    );
+
+    return saturate(1.0 - edge / band_width);
+}
+
 fn clipmap_select_finest(
     levels: ptr<uniform, ${CLIPMAP_LEVEL_ARRAY.wgsl_ref}>,
     count: u32,
@@ -42,24 +64,11 @@ fn clipmap_select_finest(
             break;
         }
 
-        let level = (*levels)[i];
-
-        // the point in the level's cells
-        let position_cells = position_ws / level.cell_size;
+        let weight = clipmap_level_select((*levels)[i], position_ws, band_width);
 
-        if (!clipmap_contains(vec3<i32>(floor(position_cells)), level.corner, level.size)) {
-            continue;
+        if (weight >= 0.0) {
+            return ClipmapSelection(i, weight);
         }
-
-        let from_corner = position_cells - vec3f(level.corner);
-        let to_far_corner = vec3f(level.size) - from_corner;
-
-        let edge = min(
-            min(min(from_corner.x, from_corner.y), from_corner.z),
-            min(min(to_far_corner.x, to_far_corner.y), to_far_corner.z)
-        );
-
-        return ClipmapSelection(i, saturate(1.0 - edge / band_width));
     }
 
     return ClipmapSelection(CLIPMAP_LEVEL_NONE, 0.0);

package/src/shade/renderer/shader/chunk/spherical_harmonics/chunk_sh2_color_get_irradiance_at.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_sh2_color_get_irradiance_at.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/spherical_harmonics/chunk_sh2_color_get_irradiance_at.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,gDAFU,SAAS,CAqBhB;0BAzBuB,6BAA6B"}
+{"version":3,"file":"chunk_sh2_color_get_irradiance_at.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/spherical_harmonics/chunk_sh2_color_get_irradiance_at.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,gDAFU,SAAS,CAUhB;0BAfuB,6BAA6B"}

package/src/shade/renderer/shader/chunk/spherical_harmonics/chunk_sh2_color_get_irradiance_at.js

@@ -1,4 +1,5 @@
 import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { chunk_sh2_color_irradiance } from "./chunk_sh2_color_irradiance.js";
 
 /**
  * Kernel is cosine convolved
@@ -8,19 +9,8 @@ export const chunk_sh2_color_get_irradiance_at = CodeChunk.from(
     //language=WGSL
     `
 fn sh2_color_get_irradiance_at(normal: vec3<f32>, coefficients: array< vec3<f32>, 4 >) -> vec3<f32>{
-    // normal is assumed to have unit length
-    let x = normal.x;
-    let y = normal.y;
-    let z = normal.z;
-
-    // band 0
-    var result = coefficients[0] * 0.8862269254527579;
-
-    // band 1
-    result += coefficients[1] * 1.0233267079464885 * y;
-    result += coefficients[2] * 1.0233267079464885 * z;
-    result += coefficients[3] * 1.0233267079464885 * x;
-
-    return max(vec3(0),result);
+    return max(vec3(0), sh2_color_irradiance(normal, coefficients));
 }
-`);
+`, [
+    chunk_sh2_color_irradiance,
+]);

package/src/shade/renderer/shader/chunk/spherical_harmonics/chunk_sh3_convolve_with_cosine_kernel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_sh3_convolve_with_cosine_kernel.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/spherical_harmonics/chunk_sh3_convolve_with_cosine_kernel.js"],"names":[],"mappings":"AAMA,8DAuBG;AAEH,oEA4CC;0BA3EyB,6BAA6B"}
+{"version":3,"file":"chunk_sh3_convolve_with_cosine_kernel.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/spherical_harmonics/chunk_sh3_convolve_with_cosine_kernel.js"],"names":[],"mappings":"AAOA,8DAQG;AAEH,oEA4CC;0BA7DyB,6BAA6B"}

package/src/shade/renderer/shader/chunk/spherical_harmonics/chunk_sh3_convolve_with_cosine_kernel.js

@@ -1,4 +1,5 @@
 import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { chunk_sh3_convolve_with_zh } from "./chunk_sh3_convolve_with_zh.js";
 
 const sh_cosineA0 = Math.PI;
 const sh_cosineA1 = (2.0 * Math.PI) / 3.0;
@@ -8,26 +9,11 @@ export const chunk_sh3_convolve_with_cosine_kernel = CodeChunk.from(
     //language=WGSL
     `
 fn sh3_convolve_with_cosine_kernel(sh: array<f32,9>) -> array<f32, 9>{
-    return array<f32,9>(
-    
-        // band 0
-        sh[0]*${sh_cosineA0},
-        
-        // band 1
-        sh[1]*${sh_cosineA1},
-        sh[2]*${sh_cosineA1},
-        sh[3]*${sh_cosineA1},
-        
-        // band 2
-        sh[4]*${sh_cosineA2},
-        sh[5]*${sh_cosineA2},
-        sh[6]*${sh_cosineA2},
-        sh[7]*${sh_cosineA2},
-        sh[8]*${sh_cosineA2},
-        
-    );
+    return sh3_convolve_with_zh(sh, vec3<f32>(${sh_cosineA0}, ${sh_cosineA1}, ${sh_cosineA2}));
 }
-`);
+`, [
+    chunk_sh3_convolve_with_zh,
+]);
 
 export const chunk_sh3_color_convolve_with_cosine_kernel = CodeChunk.from(
     //language=WGSL

package/src/shade/renderer/shader/chunk/spherical_harmonics/dering/chunk_sh3_windowing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_sh3_windowing.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/spherical_harmonics/dering/chunk_sh3_windowing.js"],"names":[],"mappings":"AAIA,4CA4BO;0BAhCmB,gCAAgC"}
+{"version":3,"file":"chunk_sh3_windowing.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/spherical_harmonics/dering/chunk_sh3_windowing.js"],"names":[],"mappings":"AAIA,4CASO;0BAbmB,gCAAgC"}

package/src/shade/renderer/shader/chunk/spherical_harmonics/dering/chunk_sh3_windowing.js

@@ -1,34 +1,15 @@
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
-import { chunk_sh_index } from "../chunk_sh_index.js";
+import { chunk_sh3_convolve_with_zh } from "../chunk_sh3_convolve_with_zh.js";
 import { chunk_sinc_window } from "./chunk_sinc_window.js";
 
 export const chunk_sh3_windowing = CodeChunk.from(
     //language=WGSL
     `
 fn sh3_windowing( f:array<f32, 9>, cutoff:f32 ) -> array<f32, 9>{
-
-    // scale each band individually
-    let w0 = 1.0; //first band is always unchanged
-    let w1 = sinc_window(1, cutoff);
-    let w2 = sinc_window(2, cutoff);
-    
-    return array<f32,9>(
-        // band 0
-        f[0] * w0,
-        // band 1
-        f[1] * w1,
-        f[2] * w1,
-        f[3] * w1,
-        // band 2
-        f[4] * w2,
-        f[5] * w2,
-        f[6] * w2,
-        f[7] * w2,
-        f[8] * w2,
-    );
+    return sh3_convolve_with_zh(f, vec3<f32>(1.0, sinc_window(1, cutoff), sinc_window(2, cutoff)));
 }
 `, [
+        chunk_sh3_convolve_with_zh,
         chunk_sinc_window,
-        chunk_sh_index,
     ]);
 

package/src/shade/renderer/shadow/map/ShadowmapDrawSelector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShadowmapDrawSelector.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/ShadowmapDrawSelector.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IACI;;;;OAIG;IACH,UAFU,WAAW,CAEP;IAEd;;;;OAIG;IACH,aAFU,MAAM,CAEA;IAEhB;;;;;;OAMG;IACH,sBAFU,MAAM,CAES;IAEzB;;;;;OAKG;IACH,sBAFU,OAAO,CAEY;IAsC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,mBALW,WAAW,eAEX,MAAM,gBACN,MAAM,QAkFhB;;CACJ"}
+{"version":3,"file":"ShadowmapDrawSelector.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/ShadowmapDrawSelector.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IACI;;;;OAIG;IACH,UAFU,WAAW,CAEP;IAEd;;;;OAIG;IACH,aAFU,MAAM,CAEA;IAEhB;;;;;;OAMG;IACH,sBAFU,MAAM,CAES;IAEzB;;;;;OAKG;IACH,sBAFU,OAAO,CAEY;IAsC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,mBALW,WAAW,eAEX,MAAM,gBACN,MAAM,QAkFhB;;CACJ"}

package/src/shade/renderer/shadow/map/ShadowmapDrawSelector.js

@@ -1,5 +1,6 @@
 import { IndexedFloatMaxHeap } from "../../../../core/collection/heap/IndexedFloatMaxHeap.js";
 import { compute_shadowmap_update_score } from "./shadowmap_update_score.js";
+import { ceilPowerOfTwo } from "../../../../core/binary/operations/ceilPowerOfTwo.js";
 
 /**
  * Picks which shadowmaps get rasterized this frame, given a view budget.
@@ -92,7 +93,7 @@ export class ShadowmapDrawSelector {
             return;
         }
 
-        const capacity = Math.max(64, 1 << (32 - Math.clz32(count - 1)));
+        const capacity = Math.max(64, ceilPowerOfTwo(count));
 
         this.#heap = new IndexedFloatMaxHeap(capacity);
         this.#heap_capacity = capacity;