@woosh/meep-engine 3.60.6 → 3.60.7

package/src/shade/renderer/volumetrics/chunk_volumetrics_sun_shadow_group_list.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_volumetrics_sun_shadow_group_list.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/chunk_volumetrics_sun_shadow_group_list.js"],"names":[],"mappings":"AAQA;;;;;;;GAOG;AACH,oDAFU,YAAY,CAKkB;AAExC;;;;;GAKG;AACH,kDAFU,YAAY,CAKgB;AAEtC;;;;;;;;;;GAUG;AACH,6CAFU,MAAM,CAEgC;AAEhD;;;;;;;;;;GAUG;AACH,2DAFU,MAAM,CAE+C;AAE/D;;;;;GAKG;AACH,uDAFU,MAAM,CAE0C;AAE1D;;;;;;;GAOG;AACH,sDAFU,SAAS,CA8EjB;6BAnJ2B,gCAAgC;0BAFnC,iCAAiC"}
+{"version":3,"file":"chunk_volumetrics_sun_shadow_group_list.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/chunk_volumetrics_sun_shadow_group_list.js"],"names":[],"mappings":"AASA;;;;;;;GAOG;AACH,oDAFU,YAAY,CAKkB;AAExC;;;;;GAKG;AACH,kDAFU,YAAY,CAKgB;AAEtC;;;;;;;;;;GAUG;AACH,6CAFU,MAAM,CAEgC;AAEhD;;;;;;;;;;GAUG;AACH,2DAFU,MAAM,CAE+C;AAE/D;;;;;GAKG;AACH,uDAFU,MAAM,CAE0C;AAE1D;;;;;;;GAOG;AACH,sDAFU,SAAS,CA+EjB;6BApJ2B,gCAAgC;0BAFnC,iCAAiC"}

package/src/shade/renderer/volumetrics/chunk_volumetrics_sun_shadow_group_list.js

@@ -1,152 +1,154 @@
-import { chunk_grid3d_to_index } from "../shader/chunk/grid/chunk_grid3d_to_index.js";
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
-import { u32, vec3u } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
-import { PARTICIPATING_MEDIA_VOLUME_STRUCT } from "./PARTICIPATING_MEDIA_VOLUME_STRUCT.js";
-import { VOLUMETRICS_MEDIA_GROUP_VOLUME_BUDGET } from "./chunk_volumetrics_media_group_list.js";
-import { VOLUMETRICS_SUN_SHADOW_WORKGROUP_RESOLUTION } from "./VOLUMETRICS_SUN_SHADOW_RESOLUTION.js";
-
-/**
- * Which cascade a sun-shadow build dispatch is operating on.
- *
- * Per-dispatch, uniform, read-only and eight bytes, which is the shape immediate data exists for:
- * no pooled buffer, no staging copy, no bind group.
- *
- * @type {WebGPUStruct}
- */
-export const VOLUMETRICS_SUN_SHADOW_BUILD_SETTINGS = WebGPUStruct.from({
-    cascade: u32,
-    sub_steps: u32,
-}, "VolumetricsSunShadowBuildSettings");
-
-/**
- * Which cascade and cascade voxel resolution a sun-shadow cull or brick-bin dispatch is operating on.
- * Packed into 16 bytes of immediate data (`vec3<u32>` + `u32`).
- *
- * @type {WebGPUStruct}
- */
-export const VOLUMETRICS_SUN_SHADOW_BIN_SETTINGS = WebGPUStruct.from({
-    resolution: vec3u,
-    cascade: u32,
-}, "VolumetricsSunShadowBinSettings");
-
-/**
- * Depth of one 3D brick of a sun optical-depth cascade along the sun axis, in voxels.
- *
- * Paired with {@link VOLUMETRICS_SUN_SHADOW_WORKGROUP_RESOLUTION} (`[8, 8]` in xy), each brick is an
- * `8x8x8` cube of cascade voxels. The bin pre-culls the cascade's participating-media volumes into a
- * bitmask per brick, and the column scan walks its column stack brick by brick: an empty brick skips
- * all eight slices in O(1), and a populated brick amortizes each volume's `scene_database` load,
- * local-basis projection and 4-ray slab setup across all eight slices.
- *
- * @type {number}
- */
-export const VOLUMETRICS_SUN_SHADOW_BRICK_Z = 8;
-
-/**
- * Maximum integer-lattice slices immediately upwind of the outermost cascade's `w = 0` entry face
- * (`s in [-VOLUMETRICS_SUN_SHADOW_UPWIND_LATTICE_SLICES, 0)`) integrated at the cascade's own voxel
- * step. Because these slices sit on the exact same world-space voxel lattice as the interior slices
- * `s >= 0`, snapping the cascade origin by whole voxels moves a slice across `s = 0` (`s = 0` <->
- * `s = -1`) without changing its coverage, fade or noise sample point. Any volume extending further
- * upwind (`s < -16`) integrates its deep upwind tail in at most
- * `VOLUMETRICS_SUN_SHADOW_UPWIND_TAIL_STEPS` steps.
- *
- * @type {number}
- */
-export const VOLUMETRICS_SUN_SHADOW_UPWIND_LATTICE_SLICES = 16;
-
-/**
- * Quadrature steps for the deep upwind tail (`s < -VOLUMETRICS_SUN_SHADOW_UPWIND_LATTICE_SLICES`)
- * ahead of the outermost cascade.
- *
- * @type {number}
- */
-export const VOLUMETRICS_SUN_SHADOW_UPWIND_TAIL_STEPS = 8;
-
-/**
- * Brick-grid addressing and 6-axis OBB-vs-cascade-box culling for the sun optical-depth cascades,
- * shared by {@link shader_volumetrics_cull_sun_shadow_media},
- * {@link shader_volumetrics_bin_sun_shadow_media} and
- * {@link shader_volumetrics_build_sun_shadow_volume_outermost}.
- *
- * @type {CodeChunk}
- */
-export const chunk_volumetrics_sun_shadow_group_list = CodeChunk.from(
-    //language=WGSL
-    `
-const VOLUMETRICS_SUN_SHADOW_GROUP_XY = vec2<u32>(${VOLUMETRICS_SUN_SHADOW_WORKGROUP_RESOLUTION[0]}u, ${VOLUMETRICS_SUN_SHADOW_WORKGROUP_RESOLUTION[1]}u);
-const VOLUMETRICS_SUN_SHADOW_BRICK_Z: u32 = ${VOLUMETRICS_SUN_SHADOW_BRICK_Z}u;
-const VOLUMETRICS_SUN_SHADOW_VOLUME_BUDGET: u32 = ${VOLUMETRICS_MEDIA_GROUP_VOLUME_BUDGET}u;
-
-fn volumetrics_sun_shadow_interior_bricks_z(resolution_z: u32) -> u32 {
-    return (resolution_z + VOLUMETRICS_SUN_SHADOW_BRICK_Z - 1u) / VOLUMETRICS_SUN_SHADOW_BRICK_Z;
-}
-
-// Brick grid of one cascade: interior bricks in 0 .. interior_z - 1, plus one upwind layer at
-// z = interior_z for volumes between the sun and the outermost cascade's w = 0 entry face.
-fn volumetrics_sun_shadow_groups(resolution: vec3<u32>) -> vec3<u32> {
-    let xy = (resolution.xy + VOLUMETRICS_SUN_SHADOW_GROUP_XY - vec2<u32>(1u)) / VOLUMETRICS_SUN_SHADOW_GROUP_XY;
-    let z = volumetrics_sun_shadow_interior_bricks_z(resolution.z) + 1u;
-    return vec3<u32>(xy, z);
-}
-
-fn volumetrics_sun_shadow_list_words(volume_count: u32, buffer_words: u32, groups: vec3<u32>) -> u32 {
-    let total_groups = max(1u, groups.x * groups.y * groups.z);
-    return min((volume_count + 31u) / 32u, buffer_words / total_groups);
-}
-
-fn volumetrics_sun_shadow_list_offset(group: vec3<u32>, groups: vec3<u32>, list_words: u32) -> u32 {
-    return grid3d_to_index(group, groups.xy) * list_words;
-}
-
-// 6-axis separating-axis test between an axis-aligned box [uvw_min, uvw_max] in sun-cascade UVW
-// space and a volume's unit box [-0.5, +0.5]^3 in its own local space.
-//
-// First projects the volume's unit box into cascade UVW space to test the 3 sun-cascade axes and
-// clamp [uvw_min, uvw_max] to the volume's own UVW bounds [vol_uvw_min, vol_uvw_max]. That clamp is
-// what keeps a semi-infinite upwind prism (uvw_min.z = -F32_MAX) finite and tight before mapping the
-// intersection box into volume-local space to test the volume's 3 OBB face axes.
-fn volumetrics_volume_in_sun_box(
-    uvw_min: vec3<f32>,
-    uvw_max: vec3<f32>,
-    ws_to_uvw: mat4x4<f32>,
-    uvw_to_ws: mat4x4<f32>,
-    volume: ${PARTICIPATING_MEDIA_VOLUME_STRUCT.wgsl_ref},
-) -> bool {
-    let local_to_uvw = ws_to_uvw * volume.transform;
-    let vol_uvw_center = local_to_uvw[3].xyz;
-    let vol_uvw_half = 0.5 * (
-        abs(local_to_uvw[0].xyz) +
-        abs(local_to_uvw[1].xyz) +
-        abs(local_to_uvw[2].xyz)
-    );
-
-    let vol_uvw_min = vol_uvw_center - vol_uvw_half;
-    let vol_uvw_max = vol_uvw_center + vol_uvw_half;
-
-    let b_min = max(uvw_min, vol_uvw_min);
-    let b_max = min(uvw_max, vol_uvw_max);
-
-    if (any(b_max < b_min)) {
-        return false;
-    }
-
-    let uvw_to_local = volume.transform_inverse * uvw_to_ws;
-    let b_center = (b_min + b_max) * 0.5;
-    let b_half = (b_max - b_min) * 0.5;
-
-    let local_center = (uvw_to_local * vec4<f32>(b_center, 1.0)).xyz;
-    let local_half = abs(uvw_to_local[0].xyz) * b_half.x
-                   + abs(uvw_to_local[1].xyz) * b_half.y
-                   + abs(uvw_to_local[2].xyz) * b_half.z;
-
-    return all(abs(local_center) <= vec3<f32>(0.5005) + local_half);
-}
-    `,
-    [
-        PARTICIPATING_MEDIA_VOLUME_STRUCT.declaration_chunk,
-        chunk_grid3d_to_index,
-    ]
-);
-
+import { chunk_grid3d_to_index } from "../shader/chunk/grid/chunk_grid3d_to_index.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 { u32, vec3u } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+import { PARTICIPATING_MEDIA_VOLUME_STRUCT } from "./PARTICIPATING_MEDIA_VOLUME_STRUCT.js";
+import { VOLUMETRICS_MEDIA_GROUP_VOLUME_BUDGET } from "./chunk_volumetrics_media_group_list.js";
+import { VOLUMETRICS_SUN_SHADOW_WORKGROUP_RESOLUTION } from "./VOLUMETRICS_SUN_SHADOW_RESOLUTION.js";
+
+/**
+ * Which cascade a sun-shadow build dispatch is operating on.
+ *
+ * Per-dispatch, uniform, read-only and eight bytes, which is the shape immediate data exists for:
+ * no pooled buffer, no staging copy, no bind group.
+ *
+ * @type {WebGPUStruct}
+ */
+export const VOLUMETRICS_SUN_SHADOW_BUILD_SETTINGS = WebGPUStruct.from({
+    cascade: u32,
+    sub_steps: u32,
+}, "VolumetricsSunShadowBuildSettings");
+
+/**
+ * Which cascade and cascade voxel resolution a sun-shadow cull or brick-bin dispatch is operating on.
+ * Packed into 16 bytes of immediate data (`vec3<u32>` + `u32`).
+ *
+ * @type {WebGPUStruct}
+ */
+export const VOLUMETRICS_SUN_SHADOW_BIN_SETTINGS = WebGPUStruct.from({
+    resolution: vec3u,
+    cascade: u32,
+}, "VolumetricsSunShadowBinSettings");
+
+/**
+ * Depth of one 3D brick of a sun optical-depth cascade along the sun axis, in voxels.
+ *
+ * Paired with {@link VOLUMETRICS_SUN_SHADOW_WORKGROUP_RESOLUTION} (`[8, 8]` in xy), each brick is an
+ * `8x8x8` cube of cascade voxels. The bin pre-culls the cascade's participating-media volumes into a
+ * bitmask per brick, and the column scan walks its column stack brick by brick: an empty brick skips
+ * all eight slices in O(1), and a populated brick amortizes each volume's `scene_database` load,
+ * local-basis projection and 4-ray slab setup across all eight slices.
+ *
+ * @type {number}
+ */
+export const VOLUMETRICS_SUN_SHADOW_BRICK_Z = 8;
+
+/**
+ * Maximum integer-lattice slices immediately upwind of the outermost cascade's `w = 0` entry face
+ * (`s in [-VOLUMETRICS_SUN_SHADOW_UPWIND_LATTICE_SLICES, 0)`) integrated at the cascade's own voxel
+ * step. Because these slices sit on the exact same world-space voxel lattice as the interior slices
+ * `s >= 0`, snapping the cascade origin by whole voxels moves a slice across `s = 0` (`s = 0` <->
+ * `s = -1`) without changing its coverage, fade or noise sample point. Any volume extending further
+ * upwind (`s < -16`) integrates its deep upwind tail in at most
+ * `VOLUMETRICS_SUN_SHADOW_UPWIND_TAIL_STEPS` steps.
+ *
+ * @type {number}
+ */
+export const VOLUMETRICS_SUN_SHADOW_UPWIND_LATTICE_SLICES = 16;
+
+/**
+ * Quadrature steps for the deep upwind tail (`s < -VOLUMETRICS_SUN_SHADOW_UPWIND_LATTICE_SLICES`)
+ * ahead of the outermost cascade.
+ *
+ * @type {number}
+ */
+export const VOLUMETRICS_SUN_SHADOW_UPWIND_TAIL_STEPS = 8;
+
+/**
+ * Brick-grid addressing and 6-axis OBB-vs-cascade-box culling for the sun optical-depth cascades,
+ * shared by {@link shader_volumetrics_cull_sun_shadow_media},
+ * {@link shader_volumetrics_bin_sun_shadow_media} and
+ * {@link shader_volumetrics_build_sun_shadow_volume_outermost}.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_volumetrics_sun_shadow_group_list = CodeChunk.from(
+    //language=WGSL
+    `
+const VOLUMETRICS_SUN_SHADOW_GROUP_XY = vec2<u32>(${VOLUMETRICS_SUN_SHADOW_WORKGROUP_RESOLUTION[0]}u, ${VOLUMETRICS_SUN_SHADOW_WORKGROUP_RESOLUTION[1]}u);
+const VOLUMETRICS_SUN_SHADOW_BRICK_Z: u32 = ${VOLUMETRICS_SUN_SHADOW_BRICK_Z}u;
+const VOLUMETRICS_SUN_SHADOW_VOLUME_BUDGET: u32 = ${VOLUMETRICS_MEDIA_GROUP_VOLUME_BUDGET}u;
+
+fn volumetrics_sun_shadow_interior_bricks_z(resolution_z: u32) -> u32 {
+    return divide_round_up_u32(resolution_z, VOLUMETRICS_SUN_SHADOW_BRICK_Z);
+}
+
+// Brick grid of one cascade: interior bricks in 0 .. interior_z - 1, plus one upwind layer at
+// z = interior_z for volumes between the sun and the outermost cascade's w = 0 entry face.
+fn volumetrics_sun_shadow_groups(resolution: vec3<u32>) -> vec3<u32> {
+    let xy = (resolution.xy + VOLUMETRICS_SUN_SHADOW_GROUP_XY - vec2<u32>(1u)) / VOLUMETRICS_SUN_SHADOW_GROUP_XY;
+    let z = volumetrics_sun_shadow_interior_bricks_z(resolution.z) + 1u;
+    return vec3<u32>(xy, z);
+}
+
+fn volumetrics_sun_shadow_list_words(volume_count: u32, buffer_words: u32, groups: vec3<u32>) -> u32 {
+    let total_groups = max(1u, groups.x * groups.y * groups.z);
+    return min((volume_count + 31u) / 32u, buffer_words / total_groups);
+}
+
+fn volumetrics_sun_shadow_list_offset(group: vec3<u32>, groups: vec3<u32>, list_words: u32) -> u32 {
+    return grid3d_to_index(group, groups.xy) * list_words;
+}
+
+// 6-axis separating-axis test between an axis-aligned box [uvw_min, uvw_max] in sun-cascade UVW
+// space and a volume's unit box [-0.5, +0.5]^3 in its own local space.
+//
+// First projects the volume's unit box into cascade UVW space to test the 3 sun-cascade axes and
+// clamp [uvw_min, uvw_max] to the volume's own UVW bounds [vol_uvw_min, vol_uvw_max]. That clamp is
+// what keeps a semi-infinite upwind prism (uvw_min.z = -F32_MAX) finite and tight before mapping the
+// intersection box into volume-local space to test the volume's 3 OBB face axes.
+fn volumetrics_volume_in_sun_box(
+    uvw_min: vec3<f32>,
+    uvw_max: vec3<f32>,
+    ws_to_uvw: mat4x4<f32>,
+    uvw_to_ws: mat4x4<f32>,
+    volume: ${PARTICIPATING_MEDIA_VOLUME_STRUCT.wgsl_ref},
+) -> bool {
+    let local_to_uvw = ws_to_uvw * volume.transform;
+    let vol_uvw_center = local_to_uvw[3].xyz;
+    let vol_uvw_half = 0.5 * (
+        abs(local_to_uvw[0].xyz) +
+        abs(local_to_uvw[1].xyz) +
+        abs(local_to_uvw[2].xyz)
+    );
+
+    let vol_uvw_min = vol_uvw_center - vol_uvw_half;
+    let vol_uvw_max = vol_uvw_center + vol_uvw_half;
+
+    let b_min = max(uvw_min, vol_uvw_min);
+    let b_max = min(uvw_max, vol_uvw_max);
+
+    if (any(b_max < b_min)) {
+        return false;
+    }
+
+    let uvw_to_local = volume.transform_inverse * uvw_to_ws;
+    let b_center = (b_min + b_max) * 0.5;
+    let b_half = (b_max - b_min) * 0.5;
+
+    let local_center = (uvw_to_local * vec4<f32>(b_center, 1.0)).xyz;
+    let local_half = abs(uvw_to_local[0].xyz) * b_half.x
+                   + abs(uvw_to_local[1].xyz) * b_half.y
+                   + abs(uvw_to_local[2].xyz) * b_half.z;
+
+    return all(abs(local_center) <= vec3<f32>(0.5005) + local_half);
+}
+    `,
+    [
+        PARTICIPATING_MEDIA_VOLUME_STRUCT.declaration_chunk,
+        chunk_divide_round_up_u32,
+        chunk_grid3d_to_index,
+    ]
+);
+

package/src/shade/renderer/volumetrics/irradiance_clipmap/GPUIrradianceClipmap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUIrradianceClipmap.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/irradiance_clipmap/GPUIrradianceClipmap.js"],"names":[],"mappings":"AA6CA;;;;;;;;;;;;;GAaG;AACH;IA2CI;;;;;;;OAOG;IACH;QAL4B,aAAa,GAA9B,MAAM;QAC6B,UAAU,GAA7C,MAAM,GAAC,UAAU,MAAM,CAAC;QACP,SAAS,GAA1B,MAAM;QACW,WAAW,GAA5B,MAAM;OA8DhB;IAED;;OAEG;IACH,4BAEC;IAED;;OAEG;IACH,mCAEC;IAED;;OAEG;IACH,sCAEC;IAED;;OAEG;IACH,yBAEC;IAED;;OAEG;IACH,4BAEC;IAED;;;OAGG;IACH,0BAEC;IAED;;OAEG;IACH,4CAEC;IAED;;OAEG;IACH,uBAEC;IAED;;;;;;;;OAQG;IACH,oBALW,MAAM,KACN,MAAM,KACN,MAAM,oBACN,eAAe,QAgFzB;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH;QAZsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;QACZ,MAAM,EAA3E,OAAO,kCAAkC,EAAE,gBAAgB;QACO,SAAS,EAA3E,OAAO,gCAAgC,EAAE,eAAe;QACxC,eAAe,EAA/B,MAAM;QACoB,eAAe,GAAzC,eAAe;QACuE,MAAM,GAA5F,OAAO,oDAAoD,EAAE,cAAc;QACkB,GAAG,GAAhG,OAAO,sDAAsD,EAAE,mBAAmB;QACgB,MAAM,EAAxG,OAAO,8DAA8D,EAAE,iBAAiB;QAErE,YAAY;QAC7B;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,CAkJtD;IAED;;OAEG;IACH,gBAQC;;CACJ;+BAve8B,uCAAuC;2CAe3B,iCAAiC;gCApB5C,0CAA0C"}
+{"version":3,"file":"GPUIrradianceClipmap.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/irradiance_clipmap/GPUIrradianceClipmap.js"],"names":[],"mappings":"AA6CA;;;;;;;;;;;;;GAaG;AACH;IA2CI;;;;;;;OAOG;IACH;QAL4B,aAAa,GAA9B,MAAM;QAC6B,UAAU,GAA7C,MAAM,GAAC,UAAU,MAAM,CAAC;QACP,SAAS,GAA1B,MAAM;QACW,WAAW,GAA5B,MAAM;OA+DhB;IAED;;OAEG;IACH,4BAEC;IAED;;OAEG;IACH,mCAEC;IAED;;OAEG;IACH,sCAEC;IAED;;OAEG;IACH,yBAEC;IAED;;OAEG;IACH,4BAEC;IAED;;;OAGG;IACH,0BAEC;IAED;;OAEG;IACH,4CAEC;IAED;;OAEG;IACH,uBAEC;IAED;;;;;;;;OAQG;IACH,oBALW,MAAM,KACN,MAAM,KACN,MAAM,oBACN,eAAe,QAgFzB;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH;QAZsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;QACZ,MAAM,EAA3E,OAAO,kCAAkC,EAAE,gBAAgB;QACO,SAAS,EAA3E,OAAO,gCAAgC,EAAE,eAAe;QACxC,eAAe,EAA/B,MAAM;QACoB,eAAe,GAAzC,eAAe;QACuE,MAAM,GAA5F,OAAO,oDAAoD,EAAE,cAAc;QACkB,GAAG,GAAhG,OAAO,sDAAsD,EAAE,mBAAmB;QACgB,MAAM,EAAxG,OAAO,8DAA8D,EAAE,iBAAiB;QAErE,YAAY;QAC7B;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,CAkJtD;IAED;;OAEG;IACH,gBAQC;;CACJ;+BAxe8B,uCAAuC;2CAe3B,iCAAiC;gCApB5C,0CAA0C"}

package/src/shade/renderer/volumetrics/irradiance_clipmap/GPUIrradianceClipmap.js

@@ -166,7 +166,8 @@ export class GPUIrradianceClipmap {
         this.#uniform = device.createBuffer({
             label: "GPUIrradianceClipmap/table",
             size: IRRADIANCE_CLIPMAP_STRUCT.size,
-            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+            // the world light clusters read the windows from its front as storage
+            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
         });
     }
 

package/src/shade/renderer/volumetrics/irradiance_clipmap/IRRADIANCE_CLIPMAP.d.ts

@@ -5,7 +5,9 @@
  */
 export const IRRADIANCE_CLIPMAP_DEFAULT_CASCADE_COUNT: number;
 /**
- * Maximum number of cascades supported by the irradiance clipmap table.
+ * Cascades the irradiance clipmap holds at most: the rows of its windows and its atlas records, which
+ * sit in `IRRADIANCE_CLIPMAP_STRUCT`, the one uniform its readers bind and it writes whole each frame.
+ * The irradiance clipmap's own figure, not the shared clipmap table's, which is a uniform of its own.
  * @type {number}
  */
 export const IRRADIANCE_CLIPMAP_CASCADE_LIMIT: number;

package/src/shade/renderer/volumetrics/irradiance_clipmap/IRRADIANCE_CLIPMAP.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IRRADIANCE_CLIPMAP.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/irradiance_clipmap/IRRADIANCE_CLIPMAP.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,uDAFU,MAAM,CAE0C;AAE1D;;;GAGG;AACH,+CAFU,MAAM,CAEoD;AAEpE;;;GAGG;AACH,oDAFU,MAAM,CAEwC;AAExD;;;GAGG;AACH,mDAFU,MAAM,CAEyC;AAEzD;;;;GAIG;AACH,6CAFU,MAAM,CAEgC;AAEhD;;;;;;GAMG;AACH,qDAFU,MAAM,CAEwC;AAExD;;;GAGG;AACH,8DAA4D;AAE5D;;GAEG;AACH,2IAA4E;AAE5E;;;GAGG;AACH,8CAFU,MAAM,CAEkC"}
+{"version":3,"file":"IRRADIANCE_CLIPMAP.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/irradiance_clipmap/IRRADIANCE_CLIPMAP.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,uDAFU,MAAM,CAE0C;AAE1D;;;;;GAKG;AACH,+CAFU,MAAM,CAEmC;AAEnD;;;GAGG;AACH,oDAFU,MAAM,CAEwC;AAExD;;;GAGG;AACH,mDAFU,MAAM,CAEyC;AAEzD;;;;GAIG;AACH,6CAFU,MAAM,CAEgC;AAEhD;;;;;;GAMG;AACH,qDAFU,MAAM,CAEwC;AAExD;;;GAGG;AACH,8DAA4D;AAE5D;;GAEG;AACH,2IAA4E;AAE5E;;;GAGG;AACH,8CAFU,MAAM,CAEkC"}

package/src/shade/renderer/volumetrics/irradiance_clipmap/IRRADIANCE_CLIPMAP.js

@@ -1,4 +1,3 @@
-import { CLIPMAP_LEVEL_LIMIT } from "../../shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js";
 import { SAMPLER_LINEAR_UPSCALE } from "../../texture/SAMPLER_LINEAR_UPSCALE.js";
 
 /**
@@ -9,10 +8,12 @@ import { SAMPLER_LINEAR_UPSCALE } from "../../texture/SAMPLER_LINEAR_UPSCALE.js"
 export const IRRADIANCE_CLIPMAP_DEFAULT_CASCADE_COUNT = 6;
 
 /**
- * Maximum number of cascades supported by the irradiance clipmap table.
+ * Cascades the irradiance clipmap holds at most: the rows of its windows and its atlas records, which
+ * sit in `IRRADIANCE_CLIPMAP_STRUCT`, the one uniform its readers bind and it writes whole each frame.
+ * The irradiance clipmap's own figure, not the shared clipmap table's, which is a uniform of its own.
  * @type {number}
  */
-export const IRRADIANCE_CLIPMAP_CASCADE_LIMIT = CLIPMAP_LEVEL_LIMIT;
+export const IRRADIANCE_CLIPMAP_CASCADE_LIMIT = 16;
 
 /**
  * Default resolution (cells per axis) of each irradiance clipmap cascade (Decision 6.3).

package/src/shade/renderer/volumetrics/irradiance_clipmap/IRRADIANCE_CLIPMAP_STRUCT.d.ts

@@ -3,13 +3,19 @@
  * @type {WebGPUStruct}
  */
 export const IRRADIANCE_CASCADE_STRUCT: WebGPUStruct;
+/**
+ * The cascades' windows, finest first, as a field of {@link IRRADIANCE_CLIPMAP_STRUCT}: clipmap levels.
+ * @type {WebGPUArray}
+ */
+export const IRRADIANCE_LEVEL_ARRAY: WebGPUArray;
 /**
  * @type {WebGPUArray}
  */
 export const IRRADIANCE_CASCADE_ARRAY: WebGPUArray;
 /**
  * Uniform buffer layout for the world-space irradiance clipmap (`irradiance_clipmap`).
- * Mirrors {@link WIND_FIELD_STRUCT} so `clipmap_select_finest` operates directly on `levels`.
+ * Mirrors {@link WIND_FIELD_STRUCT}: `levels` first, so the world light clusters read its windows from
+ * the front of the buffer.
  *
  * - `anchor`: continuous world-space camera/placement anchor (`[x, y, z]` in metres), used for
  *   continuous spherical cascade selection so blend weights never stair-step when integer cascade

package/src/shade/renderer/volumetrics/irradiance_clipmap/IRRADIANCE_CLIPMAP_STRUCT.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IRRADIANCE_CLIPMAP_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/irradiance_clipmap/IRRADIANCE_CLIPMAP_STRUCT.js"],"names":[],"mappings":"AAMA;;;GAGG;AACH,wCAFU,YAAY,CASE;AAExB;;GAEG;AACH,uCAFU,WAAW,CAKnB;AAEF;;;;;;;;;;;GAWG;AACH,wCAFU,YAAY,CASE;6BA3CK,mCAAmC;4BADpC,kCAAkC"}
+{"version":3,"file":"IRRADIANCE_CLIPMAP_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/irradiance_clipmap/IRRADIANCE_CLIPMAP_STRUCT.js"],"names":[],"mappings":"AAMA;;;GAGG;AACH,wCAFU,YAAY,CASE;AAExB;;;GAGG;AACH,qCAFU,WAAW,CAE0F;AAE/G;;GAEG;AACH,uCAFU,WAAW,CAKnB;AAEF;;;;;;;;;;;;GAYG;AACH,wCAFU,YAAY,CASE;6BAlDK,mCAAmC;4BADpC,kCAAkC"}

package/src/shade/renderer/volumetrics/irradiance_clipmap/IRRADIANCE_CLIPMAP_STRUCT.js

@@ -1,47 +1,54 @@
-import { CLIPMAP_LEVEL_ARRAY } from "../../shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js";
-import { f32, u32, vec3f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
-import { IRRADIANCE_CLIPMAP_CASCADE_LIMIT } from "./IRRADIANCE_CLIPMAP.js";
-
-/**
- * Per-cascade atlas placement metadata for the world-space irradiance clipmap. 16 bytes.
- * @type {WebGPUStruct}
- */
-export const IRRADIANCE_CASCADE_STRUCT = WebGPUStruct.from({
-    /**
-     * The atlas texel coordinate of window-local cell 0 (`slot_origin + border`). Window-local
-     * cell `c` has its centre at `content_origin + c + 0.5`.
-     */
-    content_origin: vec3f,
-    pad0: f32,
-}, "IrradianceCascade");
-
-/**
- * @type {WebGPUArray}
- */
-export const IRRADIANCE_CASCADE_ARRAY = WebGPUArray.from(
-    IRRADIANCE_CASCADE_STRUCT,
-    IRRADIANCE_CLIPMAP_CASCADE_LIMIT
-);
-
-/**
- * Uniform buffer layout for the world-space irradiance clipmap (`irradiance_clipmap`).
- * Mirrors {@link WIND_FIELD_STRUCT} so `clipmap_select_finest` operates directly on `levels`.
- *
- * - `anchor`: continuous world-space camera/placement anchor (`[x, y, z]` in metres), used for
- *   continuous spherical cascade selection so blend weights never stair-step when integer cascade
- *   corners step by 1 voxel.
- * - `blend_skirt`: number of voxels at each cascade window's outer boundary where blending toward
- *   the parent cascade (or far field) takes place.
- *
- * @type {WebGPUStruct}
- */
-export const IRRADIANCE_CLIPMAP_STRUCT = WebGPUStruct.from({
-    levels: CLIPMAP_LEVEL_ARRAY,
-    cascades: IRRADIANCE_CASCADE_ARRAY,
-    inverse_atlas_size: vec3f,
-    cascade_count: u32,
-    anchor: vec3f,
-    blend_skirt: f32,
-}, "IrradianceClipmap");
+import { CLIPMAP_LEVEL_STRUCT } from "../../shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js";
+import { f32, u32, vec3f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { IRRADIANCE_CLIPMAP_CASCADE_LIMIT } from "./IRRADIANCE_CLIPMAP.js";
+
+/**
+ * Per-cascade atlas placement metadata for the world-space irradiance clipmap. 16 bytes.
+ * @type {WebGPUStruct}
+ */
+export const IRRADIANCE_CASCADE_STRUCT = WebGPUStruct.from({
+    /**
+     * The atlas texel coordinate of window-local cell 0 (`slot_origin + border`). Window-local
+     * cell `c` has its centre at `content_origin + c + 0.5`.
+     */
+    content_origin: vec3f,
+    pad0: f32,
+}, "IrradianceCascade");
+
+/**
+ * The cascades' windows, finest first, as a field of {@link IRRADIANCE_CLIPMAP_STRUCT}: clipmap levels.
+ * @type {WebGPUArray}
+ */
+export const IRRADIANCE_LEVEL_ARRAY = WebGPUArray.from(CLIPMAP_LEVEL_STRUCT, IRRADIANCE_CLIPMAP_CASCADE_LIMIT);
+
+/**
+ * @type {WebGPUArray}
+ */
+export const IRRADIANCE_CASCADE_ARRAY = WebGPUArray.from(
+    IRRADIANCE_CASCADE_STRUCT,
+    IRRADIANCE_CLIPMAP_CASCADE_LIMIT
+);
+
+/**
+ * Uniform buffer layout for the world-space irradiance clipmap (`irradiance_clipmap`).
+ * Mirrors {@link WIND_FIELD_STRUCT}: `levels` first, so the world light clusters read its windows from
+ * the front of the buffer.
+ *
+ * - `anchor`: continuous world-space camera/placement anchor (`[x, y, z]` in metres), used for
+ *   continuous spherical cascade selection so blend weights never stair-step when integer cascade
+ *   corners step by 1 voxel.
+ * - `blend_skirt`: number of voxels at each cascade window's outer boundary where blending toward
+ *   the parent cascade (or far field) takes place.
+ *
+ * @type {WebGPUStruct}
+ */
+export const IRRADIANCE_CLIPMAP_STRUCT = WebGPUStruct.from({
+    levels: IRRADIANCE_LEVEL_ARRAY,
+    cascades: IRRADIANCE_CASCADE_ARRAY,
+    inverse_atlas_size: vec3f,
+    cascade_count: u32,
+    anchor: vec3f,
+    blend_skirt: f32,
+}, "IrradianceClipmap");

package/src/shade/renderer/volumetrics/irradiance_clipmap/chunk_irradiance_clipmap_sample.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_irradiance_clipmap_sample.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/irradiance_clipmap/chunk_irradiance_clipmap_sample.js"],"names":[],"mappings":"AAsDA;;;;;;;GAOG;AACH,wDALW,OAAO,wDAAwD,EAAE,6BAA6B;IAE5E,iBAAiB,GAAnC,OAAO;IACL,OAAO,wDAAwD,EAAE,6BAA6B,CAc1G;AA3DD;;;GAGG;AACH,kDAFU,wBAAwB,CAKhC;AAEF;;;GAGG;AACH,kDAFU,wBAAwB,CAMhC;AAEF;;;GAGG;AACH,qDAFU,wBAAwB,CAMhC;AAEF;;;GAGG;AACH,kDAFU,wBAAwB,CAMhC;AAwBF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqEG;AACH,8CAFU,SAAS,CAsKjB;AAOF;;;;;;;;;;;;;;GAcG;AACH,6DAFU,SAAS,CAoCjB;yCAtWuC,mDAAmD;0BADlE,oCAAoC"}
+{"version":3,"file":"chunk_irradiance_clipmap_sample.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/irradiance_clipmap/chunk_irradiance_clipmap_sample.js"],"names":[],"mappings":"AAuDA;;;;;;;GAOG;AACH,wDALW,OAAO,wDAAwD,EAAE,6BAA6B;IAE5E,iBAAiB,GAAnC,OAAO;IACL,OAAO,wDAAwD,EAAE,6BAA6B,CAc1G;AA3DD;;;GAGG;AACH,kDAFU,wBAAwB,CAKhC;AAEF;;;GAGG;AACH,kDAFU,wBAAwB,CAMhC;AAEF;;;GAGG;AACH,qDAFU,wBAAwB,CAMhC;AAEF;;;GAGG;AACH,kDAFU,wBAAwB,CAMhC;AAwBF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqEG;AACH,8CAFU,SAAS,CAsKjB;AAOF;;;;;;;;;;;;;;GAcG;AACH,6DAFU,SAAS,CAoCjB;yCAvWuC,mDAAmD;0BADlE,oCAAoC"}