@woosh/meep-engine 3.49.0 → 3.51.0

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

@@ -0,0 +1,110 @@
+import { CAMERA_UNIFORM_STRUCT } from "../camera/CAMERA_UNIFORM_STRUCT.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
+import { atomic_u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../shader/type/WebGPUArray.js";
+import { chunk_participating_media_volumes_iterate } from "./chunk_participating_media_volumes_iterate.js";
+import { chunk_volumetrics_media_group_list } from "./chunk_volumetrics_media_group_list.js";
+import { VOLUMETRICS_MEDIA_VOLUME_LIST } from "./shader_volumetrics_split_participating_media.js";
+import { VOLUMETRICS_METADATA_STRUCT } from "./VOLUMETRICS_METADATA_STRUCT.js";
+
+/**
+ * Lanes of a bin workgroup. Small on purpose: a lane tests one volume at a time, so at a handful of
+ * volumes most lanes of any group idle, and the fewer there are the less the bin launches for
+ * nothing.
+ * @type {number}
+ */
+export const VOLUMETRICS_MEDIA_BIN_LANES = 64;
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .addUniform("volumetrics_metadata", VOLUMETRICS_METADATA_STRUCT)
+    .addStorageBuffer("scene_database", WebGPUArray.u32)
+    .addStorageBuffer("near_field", VOLUMETRICS_MEDIA_VOLUME_LIST)
+    .addStorageBuffer("group_lists", WebGPUArray.from(atomic_u32), true)
+;
+
+/**
+ * Pre-culls the scene's participating-media volumes for each workgroup of the participating-media
+ * build: one workgroup per build group, which tests every volume of the near field (see
+ * {@link shader_volumetrics_split_participating_media}) against the group's slab of froxels and
+ * sets the bit of each one it keeps in that group's list (see {@link chunk_volumetrics_media_group_list}).
+ * The lists start zeroed; the graph clears them.
+ *
+ * The slab is the union of every froxel of the group as the build slices it, widened so that
+ * rounding can never make the group stricter than a froxel. In xy that is a quarter of a froxel
+ * past the group's columns and rows. In z it is the column jitter, which moves a froxel's slab by
+ * up to half a slice either way, and a quarter of a slice beyond that. A volume a froxel would
+ * cover therefore never misses its group's list, and the build reads, through the list, exactly
+ * what it read walking every volume.
+ *
+ * Budget: a lane tests ⌈near-field volumes / 64⌉ volumes. Nothing is past it.
+ */
+export const shader_volumetrics_bin_participating_media = ComputeShader.from({
+    label: "Volumetrics / bin participating media",
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(${VOLUMETRICS_MEDIA_BIN_LANES})
+fn main(
+    @builtin(workgroup_id) group: vec3<u32>,
+    @builtin(local_invocation_index) lane: u32,
+) {
+    let resolution = volumetrics_metadata.resolution;
+    let groups = volumetrics_media_groups(resolution);
+
+    if (any(group >= groups)) {
+        return;
+    }
+
+    let volume_count = participating_media_volumes_count(&scene_database);
+    let list_words = volumetrics_media_list_words(volume_count, arrayLength(&group_lists), groups);
+    let listed_count = min(volume_count, list_words * 32u);
+    let near_count = min(near_field.count, arrayLength(&near_field.indices));
+
+    if (lane >= near_count) {
+        return;
+    }
+
+    let near_far = camera.clip_near_far;
+
+    let column_0 = group.xy * VOLUMETRICS_MEDIA_GROUP_XY;
+    let column_1 = min(column_0 + VOLUMETRICS_MEDIA_GROUP_XY, resolution.xy);
+
+    let slab = volumetrics_froxel_slab(
+        volumetrics_froxel_planes(volumetrics_metadata.frustum),
+        (vec2<f32>(column_0) - 0.25) / vec2<f32>(resolution.xy),
+        (vec2<f32>(column_1) + 0.25) / vec2<f32>(resolution.xy),
+        f32(group.z) - 0.75,
+        f32(group.z + 1u) + 0.75,
+        near_far,
+        volumetrics_metadata.froxel_cluster_parameters,
+        f32(resolution.z),
+    );
+
+    let list = volumetrics_media_list_offset(group, groups, list_words);
+
+    for (var i = lane; i < near_count; i += ${VOLUMETRICS_MEDIA_BIN_LANES}u) {
+        let v = near_field.indices[i];
+
+        if (v >= listed_count) {
+            continue;
+        }
+
+        let volume = participating_media_volume_read(&scene_database, v);
+
+        if (volumetrics_volume_in_slab(slab, volume)) {
+            atomicOr(&group_lists[list + (v >> 5u)], 1u << (v & 31u));
+        }
+    }
+}
+        `, [
+            chunk_participating_media_volumes_iterate,
+            chunk_volumetrics_media_group_list,
+        ]
+    ),
+});

package/src/shade/renderer/volumetrics/shader_volumetrics_build_irradiance.d.ts

@@ -7,6 +7,12 @@
  * @type {number[]}
  */
 export const VOLUMETRICS_IRRADIANCE_WORKGROUP_RESOLUTION: number[];
+/**
+ * The most point lights, and separately spot lights, of a froxel's cluster cell this pass adds, each with
+ * its shadow tap. Chosen, not derived. Past it the rest of that type's list in the cell goes unshaded: the highest ids, except within one 32-light window where the GPU's lane order decides (PROPOSAL_HIERARCHICAL, I.6).
+ * @type {number}
+ */
+export const VOLUMETRICS_IRRADIANCE_LIGHT_BUDGET: number;
 /**
  * The froxel irradiance volume (`chunk_volumetrics_irradiance_sh`): what a lit particle standing in a
  * froxel is lit by. Starts from the froxel GI stage's volume and adds every directional, point and

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

@@ -1 +1 @@
-{"version":3,"file":"shader_volumetrics_build_irradiance.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_build_irradiance.js"],"names":[],"mappings":"AAqCA;;;;;;;GAOG;AACH,0DAFU,MAAM,EAAE,CAEmD;AAwKrE;;;;;;;;;GASG;AACH,kDAFU,aAAa,CAMpB;8BA3M2B,4BAA4B"}
+{"version":3,"file":"shader_volumetrics_build_irradiance.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_build_irradiance.js"],"names":[],"mappings":"AAqCA;;;;;;;GAOG;AACH,0DAFU,MAAM,EAAE,CAEmD;AAErE;;;;GAIG;AACH,kDAFU,MAAM,CAEsC;AA0KtD;;;;;;;;;GASG;AACH,kDAFU,aAAa,CAMpB;8BApN2B,4BAA4B"}

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

@@ -45,6 +45,13 @@ import { VOLUMETRICS_METADATA_STRUCT } from "./VOLUMETRICS_METADATA_STRUCT.js";
  */
 export const VOLUMETRICS_IRRADIANCE_WORKGROUP_RESOLUTION = [8, 8, 1];
 
+/**
+ * The most point lights, and separately spot lights, of a froxel's cluster cell this pass adds, each with
+ * its shadow tap. Chosen, not derived. Past it the rest of that type's list in the cell goes unshaded: the highest ids, except within one 32-light window where the GPU's lane order decides (PROPOSAL_HIERARCHICAL, I.6).
+ * @type {number}
+ */
+export const VOLUMETRICS_IRRADIANCE_LIGHT_BUDGET = 32;
+
 const resources = new ShaderResourceSetDescriptor();
 
 // The froxel irradiance volume (chunk_volumetrics_irradiance_sh): luma SH2 in one, chroma in the .rg
@@ -151,7 +158,8 @@ fn main(
     let point_count = light_cluster_count_point(cluster_metadata.counts);
     let spot_count = light_cluster_count_spot(cluster_metadata.counts);
 
-    for (var j = 0u; j < point_count; j++) {
+    // Budget: VOLUMETRICS_IRRADIANCE_LIGHT_BUDGET
+    for (var j = 0u; j < min(point_count, ${VOLUMETRICS_IRRADIANCE_LIGHT_BUDGET}u); j++) {
         let light_index = cluster_data[cluster_offset + j];
         let direct_light = get_point_light_info_by_index(&light_data, light_index, position_ws);
 
@@ -164,7 +172,8 @@ fn main(
         irradiance = volumetrics_irradiance_sh_add(irradiance, shadow_term * direct_light.color, direct_light.direction);
     }
 
-    for (var k = 0u; k < spot_count; k++) {
+    // Budget: VOLUMETRICS_IRRADIANCE_LIGHT_BUDGET
+    for (var k = 0u; k < min(spot_count, ${VOLUMETRICS_IRRADIANCE_LIGHT_BUDGET}u); k++) {
         let light_index = cluster_data[cluster_offset + point_count + k];
         let direct_light = get_spot_light_info_by_index(&light_data, light_index, position_ws);
 

package/src/shade/renderer/volumetrics/shader_volumetrics_build_lighting.d.ts

@@ -15,6 +15,13 @@
  * @type {number[]}
  */
 export const VOLUMETRICS_LIGHTING_WORKGROUP_RESOLUTION: number[];
+/**
+ * The most point lights, and separately spot lights, of a froxel's cluster cell the fog's in-scatter adds.
+ * Each one marches the medium toward the light and takes a shadow tap, the dearest per-light work here.
+ * Chosen, not derived. Past it the rest of that type's list in the cell goes unshaded: the highest ids, except within one 32-light window where the GPU's lane order decides (PROPOSAL_HIERARCHICAL, I.6).
+ * @type {number}
+ */
+export const VOLUMETRICS_LIGHTING_LIGHT_BUDGET: number;
 export const shader_volumetrics_build_lighting: ComputeShader;
 import { ComputeShader } from "../shader/ComputeShader.js";
 //# sourceMappingURL=shader_volumetrics_build_lighting.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"shader_volumetrics_build_lighting.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_build_lighting.js"],"names":[],"mappings":"AA6CA;;;;;;;;;;;;;;;GAeG;AACH,wDAFU,MAAM,EAAE,CAEiD;AAiXnE,8DAIE;8BA9Z4B,4BAA4B"}
+{"version":3,"file":"shader_volumetrics_build_lighting.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_build_lighting.js"],"names":[],"mappings":"AA6CA;;;;;;;;;;;;;;;GAeG;AACH,wDAFU,MAAM,EAAE,CAEiD;AAEnE;;;;;GAKG;AACH,gDAFU,MAAM,CAEoC;AAmXpD,8DAIE;8BAxa4B,4BAA4B"}

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

@@ -36,7 +36,7 @@ import { chunk_volumetrics_froxel_content_offset } from "./chunk_volumetrics_fro
 import { chunk_integrate_optical_depth } from "./chunk_integrate_optical_depth.js";
 import {
     chunk_volumetrics_sun_optical_depth,
-    volumetrics_sun_shadow_texture_name
+    VOLUMETRICS_SUN_SHADOW_CASCADE_RESOURCES
 } from "./chunk_volumetrics_sun_optical_depth.js";
 import { VOLUMETRICS_SUN_SHADOW_CASCADE_COUNT } from "./VOLUMETRICS_SUN_SHADOW_RESOLUTION.js";
 import { chunk_volumetrics_column_jitter } from "./chunk_volumetrics_column_jitter.js";
@@ -61,6 +61,14 @@ import { VOLUMETRICS_METADATA_STRUCT } from "./VOLUMETRICS_METADATA_STRUCT.js";
  */
 export const VOLUMETRICS_LIGHTING_WORKGROUP_RESOLUTION = [8, 8, 1];
 
+/**
+ * The most point lights, and separately spot lights, of a froxel's cluster cell the fog's in-scatter adds.
+ * Each one marches the medium toward the light and takes a shadow tap, the dearest per-light work here.
+ * Chosen, not derived. Past it the rest of that type's list in the cell goes unshaded: the highest ids, except within one 32-light window where the GPU's lane order decides (PROPOSAL_HIERARCHICAL, I.6).
+ * @type {number}
+ */
+export const VOLUMETRICS_LIGHTING_LIGHT_BUDGET = 16;
+
 const resources = new ShaderResourceSetDescriptor();
 
 const primary_group = resources.createGroup()
@@ -78,7 +86,7 @@ const primary_group = resources.createGroup()
 // shader_volumetrics_build_sun_shadow_volume, one cascade per texture and innermost first.
 // Sampled, not marched.
 for (let cascade = 0; cascade < VOLUMETRICS_SUN_SHADOW_CASCADE_COUNT; cascade++) {
-    primary_group.addTexture(volumetrics_sun_shadow_texture_name(cascade), "float", "3d");
+    primary_group.add(VOLUMETRICS_SUN_SHADOW_CASCADE_RESOURCES[cascade]);
 }
 
 primary_group.addStorageTexture("tLighting", "rgba16float", "3d", "write-only")
@@ -309,7 +317,8 @@ fn main(
         let point_count = light_cluster_count_point(cluster_metadata.counts);
         let spot_count = light_cluster_count_spot(cluster_metadata.counts);
 
-        for (var j = 0u; j < point_count; j++) {
+        // Budget: VOLUMETRICS_LIGHTING_LIGHT_BUDGET
+        for (var j = 0u; j < min(point_count, ${VOLUMETRICS_LIGHTING_LIGHT_BUDGET}u); j++) {
             let light_index = cluster_data[cluster_offset + j];
             var direct_light = get_point_light_info_by_index(&light_data, light_index, position_ws);
 
@@ -350,7 +359,8 @@ fn main(
             inScatteringSum += shadow_term * ms * direct_light.color;
         }
 
-        for (var k = 0u; k < spot_count; k++) {
+        // Budget: VOLUMETRICS_LIGHTING_LIGHT_BUDGET
+        for (var k = 0u; k < min(spot_count, ${VOLUMETRICS_LIGHTING_LIGHT_BUDGET}u); k++) {
             let light_index = cluster_data[cluster_offset + point_count + k];
             var direct_light = get_spot_light_info_by_index(&light_data, light_index, position_ws);
 

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

@@ -1 +1 @@
-{"version":3,"file":"shader_volumetrics_build_participating_media.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_build_participating_media.js"],"names":[],"mappings":"AAwOA,yEAIE;8BArN4B,4BAA4B"}
+{"version":3,"file":"shader_volumetrics_build_participating_media.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_build_participating_media.js"],"names":[],"mappings":"AA8QA,yEAIE;8BA3P4B,4BAA4B"}

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

@@ -28,14 +28,21 @@ import { chunk_cluster_depth_from_z_slice } from "../light/cluster/chunk_cluster
 import { chunk_compute_volume_fade_factor } from "./chunk_compute_volume_fade_factor.js";
 import { chunk_frustum_unit_box_coverage_multisample } from "./chunk_frustum_unit_box_coverage_multisample.js";
 import { chunk_volumetrics_column_jitter } from "./chunk_volumetrics_column_jitter.js";
+import {
+    chunk_volumetrics_media_group_list,
+    VOLUMETRICS_MEDIA_WORKGROUP_RESOLUTION
+} from "./chunk_volumetrics_media_group_list.js";
 import { chunk_participating_media_volumes_iterate } from "./chunk_participating_media_volumes_iterate.js";
 import { chunk_participating_media_noise } from "./noise/chunk_participating_media_noise.js";
 import { PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR } from "./noise/PARTICIPATING_MEDIA_NOISE.js";
 import { VOLUMETRICS_METADATA_STRUCT } from "./VOLUMETRICS_METADATA_STRUCT.js";
+import { chunk_wind_field_sample } from "../wind/chunk_wind_field_sample.js";
+import { wind_field_add_resources } from "../wind/wind_field_add_resources.js";
 
 const resources = new ShaderResourceSetDescriptor();
 
-resources.createGroup()
+// the scene's wind, which carries the noise: one uniform, one texture, one sampler
+wind_field_add_resources(resources.createGroup()
     .addUniform("camera", CAMERA_UNIFORM_STRUCT)
     .addUniform("view", VIEW_UNIFORM_STRUCT)
     .addUniform("volumetrics_metadata", VOLUMETRICS_METADATA_STRUCT)
@@ -45,11 +52,12 @@ resources.createGroup()
     .addSampler("sParticipatingMediaNoise", "filtering", PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR)
     .addStorageTexture("tOutput0", "rgba16float", "3d", "write-only")
     .addStorageTexture("tOutput1", "rgba16float", "3d", "write-only")
+    .addStorageBuffer("group_lists", WebGPUArray.u32));
 
 const body = CodeChunk.from(
     //language=WGSL
     `
-@compute @workgroup_size(16,16)
+@compute @workgroup_size(${VOLUMETRICS_MEDIA_WORKGROUP_RESOLUTION.join(",")})
 fn main(
     @builtin(global_invocation_id) voxel_coord : vec3<u32>
 ){
@@ -83,22 +91,17 @@ fn main(
     let z1_norm = (z1 - near_far.x) / (near_far.y - near_far.x);
          
     // Frustum planes are [LEFT, RIGHT, BOTTOM, TOP, NEAR, FAR] (see Camera.construct_frustum_planes).
-    // Only the Y plane pair needs flipping: screen-Y is top-down but world-Y is bottom-up (the
-    // visible "above/below" swap). X already matches (screen-left -> LEFT plane). Z must NOT be
+    // Only the Y plane pair changes: screen-Y is top-down but world-Y is bottom-up (the visible
+    // "above/below" swap), so the pair trades places and keeps facing in, as the bin's slabs do.
+    // Negated as well, the pair faced out, and the box test below kept a volume only where it
+    // spanned the froxel's whole row. X already matches (screen-left -> LEFT plane). Z must NOT be
     // flipped: we slice the metadata frustum, which has a real FINITE far plane (rebuilt at the
     // logical far, since the camera's infinite projection zeroes its own far plane). With a real
     // far plane the near/far slab maps to z0_norm/z1_norm directly; swapping it inverts and
     // far-skews the slab depth (frustum_slice would place froxels near far - z*(far-near)),
     // which made fog density depend on camera.far and miss the actual volume.
-    var input_planes = volumetrics_metadata.frustum;
-    {
-        var t = input_planes[2];
-        input_planes[2] = -input_planes[3];
-        input_planes[3] = -t;
-    }
-
     let froxel_frustum = frustum_slice(
-        input_planes,
+        volumetrics_froxel_planes(volumetrics_metadata.frustum),
         vec3(vec2f(voxel_coord.xy + 0u) / vec2f(resolution.xy), z0_norm),
         vec3(vec2f(voxel_coord.xy + 1u) / vec2f(resolution.xy), z1_norm),
     );
@@ -124,9 +127,37 @@ fn main(
     var scattering_luma_sum = 0.0;
     var anisotropic_g = 0.0;
 
-    let volume_count = participating_media_volumes_count(&scene_database);
+    // the wind at the noise point, sampled once a froxel by the first volume that feels it: every
+    // volume reads its noise at the same point
+    var noise_wind = wind_field.far_velocity;
+    var noise_wind_read = false;
+
+    // The volumes the bin kept for this froxel's workgroup, in row order: the order the walk over
+    // every volume had, so the sums below add up exactly as they did. The list is the group's, so
+    // every lane of a workgroup walks the same one.
+    let groups = volumetrics_media_groups(resolution);
+    let list_words = volumetrics_media_list_words(participating_media_volumes_count(&scene_database), arrayLength(&group_lists), groups);
+    let list = volumetrics_media_list_offset(vec3<u32>(voxel_coord.xy / VOLUMETRICS_MEDIA_GROUP_XY, voxel_coord.z), groups, list_words);
+
+    var bits = 0u;
+    var word = 0u;
+
+    // Budget: VOLUMETRICS_MEDIA_GROUP_VOLUME_BUDGET listed volumes, and a load for each of the
+    // list's words, ⌈volumes / 32⌉, an empty word costing the one load. Past the budget the group's
+    // highest-indexed volumes are dropped.
+    for (var listed = 0u; listed < VOLUMETRICS_MEDIA_GROUP_VOLUME_BUDGET; listed++) {
+        while (bits == 0u && word < list_words) {
+            bits = group_lists[list + word];
+            word++;
+        }
+
+        if (bits == 0u) {
+            break;
+        }
+
+        let v = (word - 1u) * 32u + countTrailingZeros(bits);
+        bits &= bits - 1u;
 
-    for (var v = 0u; v < volume_count; v++) {
         let volume = participating_media_volume_read(&scene_database, v);
 
         // Transform froxel into volume's coordinate space. Points go world -> local through
@@ -178,7 +209,12 @@ fn main(
         var noise = 1.0;
 
         if (volume.noise_strength > 0.0) {
-            noise = participating_media_noise_multiplier(volume, noise_position_ws);
+            if (volume.noise_wind_factor != 0.0 && !noise_wind_read) {
+                noise_wind = wind_field_sample(noise_position_ws);
+                noise_wind_read = true;
+            }
+
+            noise = participating_media_noise_multiplier_in_wind(volume, noise_position_ws, noise_wind);
         }
 
         let weight = volume.density * volume_coverage * edge_fade_factor * noise;
@@ -226,7 +262,9 @@ fn main(
         chunk_participating_media_volumes_iterate,
         chunk_frustum_sample_point,
         chunk_stbn_sample_vec3,
+        chunk_wind_field_sample,
         chunk_participating_media_noise,
+        chunk_volumetrics_media_group_list,
     ]
 )
 

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

@@ -1 +1 @@
-{"version":3,"file":"shader_volumetrics_build_scattering_lut.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_build_scattering_lut.js"],"names":[],"mappings":"AA4QA,oEAIG;8BAvQ2B,4BAA4B"}
+{"version":3,"file":"shader_volumetrics_build_scattering_lut.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_build_scattering_lut.js"],"names":[],"mappings":"AAiRA,oEAIG;8BA5Q2B,4BAA4B"}

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

@@ -21,6 +21,7 @@ import { chunk_sky_lut_compute_uv } from "../atmosphere/chunk_sky_lut_compute_uv
 import { chunk_calculate_multiscattering } from "./chunk_calculate_multiscattering.js";
 import { chunk_camera_ray_planar_depth_scale } from "./chunk_camera_ray_planar_depth_scale.js";
 import { chunk_participating_media_volumes_iterate } from "./chunk_participating_media_volumes_iterate.js";
+import { VOLUMETRICS_MEDIA_VOLUME_LIST } from "./shader_volumetrics_split_participating_media.js";
 
 const resources = new ShaderResourceSetDescriptor();
 
@@ -35,6 +36,8 @@ resources.createGroup()
     // RDR2-style far field: beyond froxel_far the pass ray-marches the scene volumes directly,
     // lit by the directional sun + atmosphere (single scattering, no self-shadow).
     .addStorageBuffer("scene_database", WebGPUArray.u32)
+    // the volumes any part of which lies beyond froxel_far, as the split lists them
+    .addStorageBuffer("far_field", VOLUMETRICS_MEDIA_VOLUME_LIST)
     .addStorageBuffer("light_data", WebGPUArray.u32)
     .addTexture("tSunTransmittance", "float", "2d")
     .addSampler("sLinear")
@@ -56,17 +59,19 @@ struct FarVolumeSample {
 }
 
 // Point-sample the scene participating-media volumes (coarse: full density inside the box, no edge
-// fade — that is a near-field nicety). Used only beyond the froxel grid.
+// fade — that is a near-field nicety). Used only beyond the froxel grid, so only the far field's
+// volumes are walked. The split lists them in no particular order, so the sums below round
+// differently from frame to frame; the volumetric TAA and the final image's TAA absorb that.
 fn far_sample_volumes(world_pos: vec3<f32>) -> FarVolumeSample {
     var scattering = vec3<f32>(0.0);
     var extinction = vec3<f32>(0.0);
     var g_weighted = 0.0;
     var scattering_luma = 0.0;
 
-    let volume_count = participating_media_volumes_count(&scene_database);
+    let far_count = min(far_field.count, arrayLength(&far_field.indices));
 
-    for (var v = 0u; v < volume_count; v++) {
-        let volume = participating_media_volume_read(&scene_database, v);
+    for (var i = 0u; i < far_count; i++) {
+        let volume = participating_media_volume_read(&scene_database, far_field.indices[i]);
         let local = (volume.transform_inverse * vec4<f32>(world_pos, 1.0)).xyz;
         if (any(abs(local) > vec3<f32>(0.5))) {
             continue;

package/src/shade/renderer/volumetrics/shader_volumetrics_split_participating_media.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Some of the scene's participating-media volumes, as their rows in the scene database: `indices[0,
+ * count)`, in no particular order.
+ */
+export const VOLUMETRICS_MEDIA_VOLUME_LIST: WebGPUStruct;
+/**
+ * Threads of a split workgroup, each taking one volume.
+ * @type {number}
+ */
+export const VOLUMETRICS_MEDIA_SPLIT_LANES: number;
+/**
+ * Splits the scene's participating-media volumes between the near field, the froxel grid's depths
+ * up to `froxel_far`, and the far field beyond it, where the aerial pass reads the volumes
+ * themselves. One thread a volume. A volume outside any of the grid's four side planes or its near
+ * plane goes to neither. Of the rest, a volume any part of which is nearer than `froxel_far` goes to
+ * the near field, and one any part of which is beyond goes to the far field, so a volume across
+ * `froxel_far` goes to both.
+ *
+ * The side planes are the grid's, widened a quarter froxel as the bin widens its groups'. The near
+ * plane is the one the bin's first groups start at. With `froxel_far` at its default, the camera's
+ * far, the discriminator is where the bin's last groups end, so any volume a group of the bin
+ * would keep is in the near field, and the bin reads only the near field. With `froxel_far` pulled
+ * nearer, the grid's last slice still reaches the camera's far. A volume wholly between the two then
+ * belongs to the far field alone and stops reaching that slice.
+ *
+ * The lists start at a count of zero; the graph clears them. Budget: one volume a thread.
+ */
+export const shader_volumetrics_split_participating_media: ComputeShader;
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+import { ComputeShader } from "../shader/ComputeShader.js";
+//# sourceMappingURL=shader_volumetrics_split_participating_media.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_volumetrics_split_participating_media.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_split_participating_media.js"],"names":[],"mappings":"AAgBA;;;GAGG;AACH,yDAGiC;AAUjC;;;GAGG;AACH,4CAFU,MAAM,CAEgC;AAYhD;;;;;;;;;;;;;;;;GAgBG;AACH,yEAwEG;6BA/H0B,gCAAgC;8BAJ/B,4BAA4B"}

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

@@ -0,0 +1,139 @@
+import { CAMERA_UNIFORM_STRUCT } from "../camera/CAMERA_UNIFORM_STRUCT.js";
+import { AABB3_STRUCT } from "../shader/chunk/geometry/aabb3/AABB3_STRUCT.js";
+import { chunk_aabb3_below_plane } from "../shader/chunk/geometry/aabb3/chunk_aabb3_below_plane.js";
+import {
+    chunk_frustum_transform_plane_matrix
+} from "../shader/chunk/geometry/frustum/chunk_frustum_transform_plane_matrix.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
+import { atomic_u32, u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+import { chunk_participating_media_volumes_iterate } from "./chunk_participating_media_volumes_iterate.js";
+import { chunk_volumetrics_media_group_list } from "./chunk_volumetrics_media_group_list.js";
+import { VOLUMETRICS_METADATA_STRUCT } from "./VOLUMETRICS_METADATA_STRUCT.js";
+
+/**
+ * Some of the scene's participating-media volumes, as their rows in the scene database: `indices[0,
+ * count)`, in no particular order.
+ */
+export const VOLUMETRICS_MEDIA_VOLUME_LIST = WebGPUStruct.from({
+    count: u32,
+    indices: WebGPUArray.u32,
+}, "VolumetricsMediaVolumeList");
+
+/**
+ * {@link VOLUMETRICS_MEDIA_VOLUME_LIST} as the split appends to it, from a count of zero.
+ */
+const VOLUMETRICS_MEDIA_VOLUME_LIST_APPEND = WebGPUStruct.from({
+    count: atomic_u32,
+    indices: WebGPUArray.u32,
+}, "VolumetricsMediaVolumeListAppend");
+
+/**
+ * Threads of a split workgroup, each taking one volume.
+ * @type {number}
+ */
+export const VOLUMETRICS_MEDIA_SPLIT_LANES = 64;
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .addUniform("volumetrics_metadata", VOLUMETRICS_METADATA_STRUCT)
+    .addStorageBuffer("scene_database", WebGPUArray.u32)
+    .addStorageBuffer("near_field", VOLUMETRICS_MEDIA_VOLUME_LIST_APPEND, true)
+    .addStorageBuffer("far_field", VOLUMETRICS_MEDIA_VOLUME_LIST_APPEND, true)
+;
+
+/**
+ * Splits the scene's participating-media volumes between the near field, the froxel grid's depths
+ * up to `froxel_far`, and the far field beyond it, where the aerial pass reads the volumes
+ * themselves. One thread a volume. A volume outside any of the grid's four side planes or its near
+ * plane goes to neither. Of the rest, a volume any part of which is nearer than `froxel_far` goes to
+ * the near field, and one any part of which is beyond goes to the far field, so a volume across
+ * `froxel_far` goes to both.
+ *
+ * The side planes are the grid's, widened a quarter froxel as the bin widens its groups'. The near
+ * plane is the one the bin's first groups start at. With `froxel_far` at its default, the camera's
+ * far, the discriminator is where the bin's last groups end, so any volume a group of the bin
+ * would keep is in the near field, and the bin reads only the near field. With `froxel_far` pulled
+ * nearer, the grid's last slice still reaches the camera's far. A volume wholly between the two then
+ * belongs to the far field alone and stops reaching that slice.
+ *
+ * The lists start at a count of zero; the graph clears them. Budget: one volume a thread.
+ */
+export const shader_volumetrics_split_participating_media = ComputeShader.from({
+    label: "Volumetrics / split participating media",
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(${VOLUMETRICS_MEDIA_SPLIT_LANES})
+fn main(
+    @builtin(global_invocation_id) id: vec3<u32>,
+) {
+    let v = id.x;
+
+    if (v >= participating_media_volumes_count(&scene_database)) {
+        return;
+    }
+
+    let resolution = vec2<f32>(volumetrics_metadata.resolution.xy);
+    let near_far = camera.clip_near_far;
+
+    let field = volumetrics_froxel_slab_between(
+        volumetrics_froxel_planes(volumetrics_metadata.frustum),
+        (vec2<f32>(0.0) - 0.25) / resolution,
+        (resolution + 0.25) / resolution,
+        near_far.x,
+        min(near_far.y, volumetrics_metadata.froxel_far),
+        near_far,
+    );
+
+    let volume = participating_media_volume_read(&scene_database, v);
+
+    // into the volume's frame, where it is the unit box, as the bin and the build take their planes
+    let local = frustum_transform_plane_matrix(field, transpose(volume.transform));
+
+    const unit_bounds = ${AABB3_STRUCT.make({
+            min: "vec3(-0.5)",
+            max: "vec3(0.5)",
+        })};
+
+    // the four side planes and the near plane
+    for (var i = 0u; i < 5u; i++) {
+        if (aabb3_below_plane(unit_bounds, local[i])) {
+            return;
+        }
+    }
+
+    // froxel_far: some of the volume on its near side, some on its far side, or both
+    // A list holds a row for every volume the host counted; a count past it, from a volume added
+    // after the lists were sized, loses that volume for the frame.
+    if (!aabb3_below_plane(unit_bounds, local[5])) {
+        let slot = atomicAdd(&near_field.count, 1u);
+
+        if (slot < arrayLength(&near_field.indices)) {
+            near_field.indices[slot] = v;
+        }
+    }
+
+    if (!aabb3_below_plane(unit_bounds, -local[5])) {
+        let slot = atomicAdd(&far_field.count, 1u);
+
+        if (slot < arrayLength(&far_field.indices)) {
+            far_field.indices[slot] = v;
+        }
+    }
+}
+        `, [
+            chunk_participating_media_volumes_iterate,
+            chunk_volumetrics_media_group_list,
+            chunk_frustum_transform_plane_matrix,
+            AABB3_STRUCT.declaration_chunk,
+            chunk_aabb3_below_plane,
+        ]
+    ),
+});

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

@@ -1 +1 @@
-{"version":3,"file":"volumetrics_position_world_to_froxel_uvw.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/volumetrics_position_world_to_froxel_uvw.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,uDAFU,SAAS,CAoBlB;0BA3ByB,iCAAiC"}
+{"version":3,"file":"volumetrics_position_world_to_froxel_uvw.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/volumetrics_position_world_to_froxel_uvw.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,uDAFU,SAAS,CAoBlB;0BA7ByB,iCAAiC"}

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

@@ -1,6 +1,8 @@
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 import { chunk_volumetrics_froxel_content_offset } from "./chunk_volumetrics_froxel_content_offset.js";
 import { chunk_volumetrics_froxel_uvw_from_clip } from "./chunk_volumetrics_froxel_uvw_from_clip.js";
+import { CAMERA_RESOURCE } from "../camera/CAMERA_RESOURCE.js";
+import { VOLUMETRICS_METADATA_RESOURCE } from "./VOLUMETRICS_RESOURCES.js";
 
 /**
  * NOTE: we don't clamp final slice coordinate, this is intentional, we let the linear texture sampler take care of that.
@@ -26,3 +28,6 @@ fn volumetrics_position_world_to_froxel_uvw(
         chunk_volumetrics_froxel_uvw_from_clip,
     ]
 )
+
+volumetrics_position_world_to_froxel_uvw.requireResource(CAMERA_RESOURCE);
+volumetrics_position_world_to_froxel_uvw.requireResource(VOLUMETRICS_METADATA_RESOURCE);

package/src/shade/renderer/water/GPUWaterRenderer.d.ts

@@ -42,7 +42,7 @@ export class GPUWaterRenderer {
     /** Optional single-pixel readback on the next rendered water frame. No per-frame readback. */
     request_probe(uv: any): Promise<any>;
     dispose(): void;
-    avboit_prepare({ graph, view_ctx, camera, color_texture, depth_texture, normal_texture, hzb_texture, environment_texture, light_cluster_parameters, light_cluster_lookup, light_cluster_data, shadowmap_atlas, indirect_lighting_mode, shader_switches }: {
+    avboit_prepare({ graph, view_ctx, camera, color_texture, depth_texture, normal_texture, hzb_texture, environment_texture, light_cluster_parameters, light_cluster_lookup, light_cluster_data, shadowmap_atlas, shader_switches }: {
         graph: any;
         view_ctx: any;
         camera: any;
@@ -55,7 +55,6 @@ export class GPUWaterRenderer {
         light_cluster_lookup: any;
         light_cluster_data: any;
         shadowmap_atlas: any;
-        indirect_lighting_mode?: number;
         shader_switches?: ShaderSwitchSet;
     }): {
         background_color: any;

package/src/shade/renderer/water/GPUWaterRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUWaterRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/GPUWaterRenderer.js"],"names":[],"mappings":"AAqBA,sFAAsF;AACtF;IACI,WAAa;IACb,mBAAe;IACf,yBAAqB;IACrB,aAAS;IACT,WAAa;IACb;;;;;;;;;;;MAE6B;IAC7B;;;;OAIG;IACH,QAFU,OAAO,4BAA4B,EAAE,cAAc,GAAC,IAAI,CAEpD;IAuBd;;;OAGG;IACH;;;;;MAA8F;IAC9F;;;OAGG;IACH,wBAAyD;IAMzD,oCAIC;IAED,8FAA8F;IAC9F,qCAgBC;IAED,gBASC;IAuDD;;;;;;;;;;;;;;;;;MAuIC;IAQD;;;;;YAMC;IAED;;;;;;;;;;MAOC;IAED;;;;;;;;;;;;;;MAwBC;IAED,gGAAgG;IAChG,mEAYC;;CA2BJ;gCAhY+B,uCAAuC"}
+{"version":3,"file":"GPUWaterRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/GPUWaterRenderer.js"],"names":[],"mappings":"AAmBA,sFAAsF;AACtF;IACI,WAAa;IACb,mBAAe;IACf,yBAAqB;IACrB,aAAS;IACT,WAAa;IACb;;;;;;;;;;;MAE6B;IAC7B;;;;OAIG;IACH,QAFU,OAAO,4BAA4B,EAAE,cAAc,GAAC,IAAI,CAEpD;IAmBd;;;OAGG;IACH;;;;;MAA8F;IAC9F;;;OAGG;IACH,wBAAyD;IAMzD,oCAIC;IAED,8FAA8F;IAC9F,qCAgBC;IAED,gBASC;IAuDD;;;;;;;;;;;;;;;;MAoIC;IAQD;;;;;YAMC;IAED;;;;;;;;;;MAOC;IAED;;;;;;;;;;;;;;MAwBC;IAED,gGAAgG;IAChG,mEAYC;;CA2BJ;gCAxX+B,uCAAuC"}