@woosh/meep-engine 3.50.0 → 3.51.0

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

@@ -0,0 +1,36 @@
+/**
+ * The participating-media build's workgroup, in froxels: flat in z, one slice a group. Read by its
+ * `@workgroup_size`, by the bin that pre-culls the volumes for each of those groups, and by the
+ * dispatches of both.
+ * @type {number[]}
+ */
+export const VOLUMETRICS_MEDIA_WORKGROUP_RESOLUTION: number[];
+/**
+ * The most volumes of its group's list a froxel of the participating-media build walks. Chosen, not
+ * derived. Past it the build drops the group's highest-indexed volumes, whatever each froxel would
+ * have made of them.
+ * @type {number}
+ */
+export const VOLUMETRICS_MEDIA_GROUP_VOLUME_BUDGET: number;
+/**
+ * The volumes each workgroup of the participating-media build may see, as one list per group: a
+ * bitmask over the volumes' rows, `list_words` words a group, the groups in `grid3d_to_index` order.
+ * The bin writes it, and the build walks its own group's list in row order instead of every volume.
+ *
+ * - `volumetrics_media_groups` is the build's workgroup grid over a froxel grid.
+ * - `volumetrics_media_list_words` is the words of one group's list: as many as the volumes need, and
+ *   never more than the buffer holds for each group, so a list sized from a count the host had
+ *   before a volume arrived drops that volume for a frame rather than overrun.
+ * - `volumetrics_froxel_planes` is the metadata frustum with its Y pair turned to the froxel grid's
+ *   rows (screen Y runs down, world Y up).
+ * - `volumetrics_froxel_slab` is the frustum of a box of froxels: `uv` over the grid's columns and
+ *   rows, `slice` over its depth curve, clamped to the camera's logical near and far.
+ *   `volumetrics_froxel_slab_between` is the same with the depths given, inside `[near, far]`.
+ * - `volumetrics_volume_in_slab` is the build's own rejection of a volume by a slab: its unit box
+ *   against the slab's planes taken into the volume's frame.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_volumetrics_media_group_list: CodeChunk;
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_volumetrics_media_group_list.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_volumetrics_media_group_list.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/chunk_volumetrics_media_group_list.js"],"names":[],"mappings":"AAWA;;;;;GAKG;AACH,qDAFU,MAAM,EAAE,CAEgD;AAElE;;;;;GAKG;AACH,oDAFU,MAAM,CAEwC;AAExD;;;;;;;;;;;;;;;;;;GAkBG;AACH,iDAFU,SAAS,CAoFjB;0BAzHwB,iCAAiC"}

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

@@ -0,0 +1,129 @@
+import { AABB3_STRUCT } from "../shader/chunk/geometry/aabb3/AABB3_STRUCT.js";
+import { chunk_aabb3_intersects_frustum } from "../shader/chunk/geometry/aabb3/chunk_aabb3_intersects_frustum.js";
+import { chunk_frustum_slice } from "../shader/chunk/geometry/frustum/chunk_frustum_slice.js";
+import {
+    chunk_frustum_transform_plane_matrix
+} from "../shader/chunk/geometry/frustum/chunk_frustum_transform_plane_matrix.js";
+import { chunk_grid3d_to_index } from "../shader/chunk/grid/chunk_grid3d_to_index.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { chunk_cluster_depth_from_z_slice } from "../light/cluster/chunk_cluster_depth_from_z_slice.js";
+import { PARTICIPATING_MEDIA_VOLUME_STRUCT } from "./PARTICIPATING_MEDIA_VOLUME_STRUCT.js";
+
+/**
+ * The participating-media build's workgroup, in froxels: flat in z, one slice a group. Read by its
+ * `@workgroup_size`, by the bin that pre-culls the volumes for each of those groups, and by the
+ * dispatches of both.
+ * @type {number[]}
+ */
+export const VOLUMETRICS_MEDIA_WORKGROUP_RESOLUTION = [16, 16, 1];
+
+/**
+ * The most volumes of its group's list a froxel of the participating-media build walks. Chosen, not
+ * derived. Past it the build drops the group's highest-indexed volumes, whatever each froxel would
+ * have made of them.
+ * @type {number}
+ */
+export const VOLUMETRICS_MEDIA_GROUP_VOLUME_BUDGET = 32;
+
+/**
+ * The volumes each workgroup of the participating-media build may see, as one list per group: a
+ * bitmask over the volumes' rows, `list_words` words a group, the groups in `grid3d_to_index` order.
+ * The bin writes it, and the build walks its own group's list in row order instead of every volume.
+ *
+ * - `volumetrics_media_groups` is the build's workgroup grid over a froxel grid.
+ * - `volumetrics_media_list_words` is the words of one group's list: as many as the volumes need, and
+ *   never more than the buffer holds for each group, so a list sized from a count the host had
+ *   before a volume arrived drops that volume for a frame rather than overrun.
+ * - `volumetrics_froxel_planes` is the metadata frustum with its Y pair turned to the froxel grid's
+ *   rows (screen Y runs down, world Y up).
+ * - `volumetrics_froxel_slab` is the frustum of a box of froxels: `uv` over the grid's columns and
+ *   rows, `slice` over its depth curve, clamped to the camera's logical near and far.
+ *   `volumetrics_froxel_slab_between` is the same with the depths given, inside `[near, far]`.
+ * - `volumetrics_volume_in_slab` is the build's own rejection of a volume by a slab: its unit box
+ *   against the slab's planes taken into the volume's frame.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_volumetrics_media_group_list = CodeChunk.from(
+    //language=WGSL
+    `
+const VOLUMETRICS_MEDIA_GROUP_XY = vec2<u32>(${VOLUMETRICS_MEDIA_WORKGROUP_RESOLUTION[0]}u, ${VOLUMETRICS_MEDIA_WORKGROUP_RESOLUTION[1]}u);
+const VOLUMETRICS_MEDIA_GROUP_VOLUME_BUDGET: u32 = ${VOLUMETRICS_MEDIA_GROUP_VOLUME_BUDGET}u;
+
+fn volumetrics_media_groups(resolution: vec3<u32>) -> vec3<u32> {
+    return vec3<u32>((resolution.xy + VOLUMETRICS_MEDIA_GROUP_XY - vec2<u32>(1u)) / VOLUMETRICS_MEDIA_GROUP_XY, resolution.z);
+}
+
+fn volumetrics_media_list_words(volume_count: u32, buffer_words: u32, groups: vec3<u32>) -> u32 {
+    return min((volume_count + 31u) / 32u, buffer_words / (groups.x * groups.y * groups.z));
+}
+
+fn volumetrics_media_list_offset(group: vec3<u32>, groups: vec3<u32>, list_words: u32) -> u32 {
+    return grid3d_to_index(group, groups.xy) * list_words;
+}
+
+fn volumetrics_froxel_planes(frustum: array<vec4<f32>, 6>) -> array<vec4<f32>, 6> {
+    // Frustum planes are [LEFT, RIGHT, BOTTOM, TOP, NEAR, FAR] (see Camera.construct_frustum_planes),
+    // every one facing in. The grid's rows run down the screen while world Y runs up, so the Y pair
+    // trades places, and stays facing in: frustum_slice takes the plane at uv 0 as it is and the one
+    // at uv 1 as it is, so swapped and kept they bound the slab from the inside, as X and Z do.
+    var planes = frustum;
+    let t = planes[2];
+    planes[2] = planes[3];
+    planes[3] = t;
+    return planes;
+}
+
+fn volumetrics_froxel_slab(
+    planes: array<vec4<f32>, 6>,
+    uv_min: vec2<f32>,
+    uv_max: vec2<f32>,
+    slice_0: f32,
+    slice_1: f32,
+    near_far: vec2<f32>,
+    curve: vec3<f32>,
+    slices: f32,
+) -> array<vec4<f32>, 6> {
+    let z0 = max(near_far.x, cluster_depth_from_z_slice(slice_0, curve, slices));
+    let z1 = min(near_far.y, cluster_depth_from_z_slice(slice_1, curve, slices));
+
+    return volumetrics_froxel_slab_between(planes, uv_min, uv_max, z0, z1, near_far);
+}
+
+fn volumetrics_froxel_slab_between(
+    planes: array<vec4<f32>, 6>,
+    uv_min: vec2<f32>,
+    uv_max: vec2<f32>,
+    z0: f32,
+    z1: f32,
+    near_far: vec2<f32>,
+) -> array<vec4<f32>, 6> {
+    let z0_norm = (z0 - near_far.x) / (near_far.y - near_far.x);
+    let z1_norm = (z1 - near_far.x) / (near_far.y - near_far.x);
+
+    return frustum_slice(planes, vec3(uv_min, z0_norm), vec3(uv_max, z1_norm));
+}
+
+fn volumetrics_volume_in_slab(slab: array<vec4<f32>, 6>, volume: ${PARTICIPATING_MEDIA_VOLUME_STRUCT.wgsl_ref}) -> bool {
+    // Points go world -> local through transform_inverse, so planes go by the transpose of *its*
+    // inverse, which is just transpose(transform) — already resident.
+    let local = frustum_transform_plane_matrix(slab, transpose(volume.transform));
+
+    const unit_bounds = ${AABB3_STRUCT.make({
+        min: "vec3(-0.5)",
+        max: "vec3(0.5)",
+    })};
+
+    return aabb3_intersects_frustum(unit_bounds, local);
+}
+    `,
+    [
+        PARTICIPATING_MEDIA_VOLUME_STRUCT.declaration_chunk,
+        AABB3_STRUCT.declaration_chunk,
+        chunk_aabb3_intersects_frustum,
+        chunk_frustum_slice,
+        chunk_frustum_transform_plane_matrix,
+        chunk_cluster_depth_from_z_slice,
+        chunk_grid3d_to_index,
+    ]
+);

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

@@ -1 +1 @@
-{"version":3,"file":"graph_build_volumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/graph_build_volumetrics.js"],"names":[],"mappings":"AAwWA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IAtB+B,KAAK;IACC,MAAM;IACJ,MAAM;IACV,IAAI;IACZ,GAAG;IAIH,kBAAkB,EAAlC,MAAM;IACU,oBAAoB,EAApC,MAAM;IACU,wBAAwB,EAAxC,MAAM;IACU,eAAe,EAA/B,MAAM;IACY,qBAAqB,EAAvC,MAAM,EAAE;IACU,qBAAqB,EAAvC,MAAM,EAAE;IAGQ,oBAAoB,EAApC,MAAM;IACW,WAAW,GAA5B,MAAM;IACW,UAAU,GAA3B,MAAM;IACqB,eAAe;IAChB,eAAe,GAAzC,eAAe;;;;;;EAkLzB;gCAjjB+B,uCAAuC"}
+{"version":3,"file":"graph_build_volumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/graph_build_volumetrics.js"],"names":[],"mappings":"AA+aA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IAtB+B,KAAK;IACC,MAAM;IACJ,MAAM;IACV,IAAI;IACZ,GAAG;IAIH,kBAAkB,EAAlC,MAAM;IACU,oBAAoB,EAApC,MAAM;IACU,wBAAwB,EAAxC,MAAM;IACU,eAAe,EAA/B,MAAM;IACY,qBAAqB,EAAvC,MAAM,EAAE;IACU,qBAAqB,EAAvC,MAAM,EAAE;IAGQ,oBAAoB,EAApC,MAAM;IACW,WAAW,GAA5B,MAAM;IACW,UAAU,GAA3B,MAAM;IACqB,eAAe;IAChB,eAAe,GAAzC,eAAe;;;;;;EAsLzB;gCA3nB+B,uCAAuC"}

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

@@ -1,5 +1,6 @@
 import { assert } from "../../../core/assert.js";
 import { SamplerDescriptor } from "../../descriptor/texture/SamplerDescriptor.js";
+import { BufferResourceDescriptor } from "../../device/graph/BufferResourceDescriptor.js";
 import { TextureResourceDescriptor } from "../../device/graph/TextureResourceDescriptor.js";
 import { ShaderSwitchSet } from "../shader/compiler/ShaderSwitchSet.js";
 import { graph_compute_pass } from "../shader/graph/compute/graph_compute_pass.js";
@@ -11,6 +12,12 @@ import { DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR } from "../texture/DEFAULT_RENDER
 import { WIND_FIELD_UNIFORM } from "../wind/WIND_FIELD_UNIFORM.js";
 import { volumetrics_sun_shadow_texture_name } from "./chunk_volumetrics_sun_optical_depth.js";
 import { PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR } from "./noise/PARTICIPATING_MEDIA_NOISE.js";
+import { VOLUMETRICS_MEDIA_WORKGROUP_RESOLUTION } from "./chunk_volumetrics_media_group_list.js";
+import { shader_volumetrics_bin_participating_media } from "./shader_volumetrics_bin_participating_media.js";
+import {
+    shader_volumetrics_split_participating_media,
+    VOLUMETRICS_MEDIA_SPLIT_LANES
+} from "./shader_volumetrics_split_participating_media.js";
 import { shader_volumetrics_build_lighting } from "./shader_volumetrics_build_lighting.js";
 import { shader_volumetrics_build_participating_media } from "./shader_volumetrics_build_participating_media.js";
 import { shader_volumetrics_build_scattering_lut } from "./shader_volumetrics_build_scattering_lut.js";
@@ -48,6 +55,21 @@ function graph_integrate_participating_media({
 
     const data = {};
 
+    // the media build's workgroups, each of which the bin gives a list of the volumes it may see
+    const groups = [
+        Math.ceil(resolution[0] / VOLUMETRICS_MEDIA_WORKGROUP_RESOLUTION[0]),
+        Math.ceil(resolution[1] / VOLUMETRICS_MEDIA_WORKGROUP_RESOLUTION[1]),
+        resolution[2],
+    ];
+
+    // A bit a volume. Sized from the scene's volumes, which the table's rows never outnumber; the
+    // shaders take the volume count off the table and the words a list gets off this buffer.
+    const volume_count = scene.volumetrics.source.volumes.length;
+    const list_words = Math.ceil(volume_count / 32);
+    const group_lists_bytes = 4 * Math.max(4, groups[0] * groups[1] * groups[2] * list_words);
+
+    // the near and the far field: a count, then a row for every volume either may hold
+    const field_bytes = 4 * Math.max(4, 1 + volume_count);
 
     const pass = graph.add(
         "aerial lut",
@@ -69,10 +91,40 @@ function graph_integrate_participating_media({
              */
             const output1 = resources.get(data.output1);
 
+            const group_lists = resources.get(data.group_lists);
+            const near_field = resources.get(data.near_field);
+            const far_field = resources.get(data.far_field);
+
             const encoder = context.encoder;
 
             const volumetrics_metadata = resources.get(data.volumetrics_metadata);
 
+            shader_volumetrics_split_participating_media.dispatch({
+                encoder,
+                bindings: {
+                    camera: camera.buffer.buffer,
+                    volumetrics_metadata,
+                    scene_database: scene.scene_database_buffer,
+                    near_field,
+                    far_field,
+                },
+                group_count_x: Math.max(1, Math.ceil(volume_count / VOLUMETRICS_MEDIA_SPLIT_LANES)),
+            });
+
+            shader_volumetrics_bin_participating_media.dispatch({
+                encoder,
+                bindings: {
+                    camera: camera.buffer.buffer,
+                    volumetrics_metadata,
+                    scene_database: scene.scene_database_buffer,
+                    near_field,
+                    group_lists,
+                },
+                group_count_x: groups[0],
+                group_count_y: groups[1],
+                group_count_z: groups[2],
+            });
+
             /**
              * The scene's noise atlas, imported this frame so a grow between frames is seen.
              * @type {GPUTextureContext}
@@ -92,6 +144,7 @@ function graph_integrate_participating_media({
                 sParticipatingMediaNoise: context.graphics.samplers.obtain(PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR),
                 tOutput0: output0.obtainView(DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR),
                 tOutput1: output1.obtainView(DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR),
+                group_lists,
             };
 
             // taken this frame rather than held: a producer that grows the field replaces its atlas
@@ -113,6 +166,23 @@ function graph_integrate_participating_media({
         });
 
     data.volumetrics_metadata = pass.read(volumetrics_metadata);
+    // the split appends to lists counted from zero
+    data.near_field = pass.create("participating media near field", BufferResourceDescriptor.from(
+        field_bytes,
+        GPUBufferUsage.STORAGE,
+        0, 4,
+    ));
+    data.far_field = pass.create("participating media far field", BufferResourceDescriptor.from(
+        field_bytes,
+        GPUBufferUsage.STORAGE,
+        0, 4,
+    ));
+    // the bin ORs bits into zeroed lists
+    data.group_lists = pass.create("participating media group lists", BufferResourceDescriptor.from(
+        group_lists_bytes,
+        GPUBufferUsage.STORAGE,
+        0, group_lists_bytes,
+    ));
     data.noise_atlas = pass.read(graph_import_texture(graph, scene.volumetrics.noise_atlas.texture, "volumetrics noise atlas"));
 
     data.output0 = pass.create("Participating Media 0", TextureResourceDescriptor.from({
@@ -132,6 +202,7 @@ function graph_integrate_participating_media({
         participating_media0: data.output0,
         participating_media1: data.output1,
         volumetrics_metadata: data.volumetrics_metadata,
+        far_field: data.far_field,
     };
 }
 
@@ -421,6 +492,7 @@ export function graph_build_volumetrics({
     const {
         participating_media0,
         participating_media1,
+        far_field,
     } = graph_integrate_participating_media({
         graph,
         scene: view.scene,
@@ -497,6 +569,7 @@ export function graph_build_volumetrics({
 
         const light_scattering_lut = resources.get(data.light_scattering_lut);
         const sun_transmittance_lut = resources.get(data.sun_transmittance_lut);
+        const far_field = resources.get(data.far_field);
 
         const encoder = context.encoder;
 
@@ -526,6 +599,7 @@ export function graph_build_volumetrics({
 
                 // RDR2-style far-field march inputs (used beyond froxel_far)
                 scene_database: view.scene.scene_database_buffer,
+                far_field,
                 light_data: lights.buffer_data,
                 tSunTransmittance: sun_transmittance_lut.obtainView(),
 
@@ -540,6 +614,7 @@ export function graph_build_volumetrics({
     a_data.participating_media1 = a_pass.read(participating_media1);
     a_data.volumetrics_metadata = a_pass.read(volumetrics_metadata);
     a_data.sun_transmittance_lut = a_pass.read(transmittance_lut);
+    a_data.far_field = a_pass.read(far_field);
 
     a_data.output = a_pass.create("Integrated Volumetrics", TextureResourceDescriptor.from({
         resolution: volumetric_resolution,

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

@@ -0,0 +1,26 @@
+/**
+ * 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: number;
+/**
+ * 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;
+import { ComputeShader } from "../shader/ComputeShader.js";
+//# sourceMappingURL=shader_volumetrics_bin_participating_media.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_volumetrics_bin_participating_media.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_bin_participating_media.js"],"names":[],"mappings":"AAWA;;;;;GAKG;AACH,0CAFU,MAAM,CAE8B;AAY9C;;;;;;;;;;;;;;;GAeG;AACH,uEAgEG;8BA3G2B,4BAA4B"}

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_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":"AAsPA,yEAIE;8BAnO4B,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,6 +28,10 @@ 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";
@@ -47,12 +51,13 @@ wind_field_add_resources(resources.createGroup()
     .addTexture("tParticipatingMediaNoise", "float", "3d")
     .addSampler("sParticipatingMediaNoise", "filtering", PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR)
     .addStorageTexture("tOutput0", "rgba16float", "3d", "write-only")
-    .addStorageTexture("tOutput1", "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>
 ){
@@ -86,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),
     );
@@ -132,9 +132,32 @@ fn main(
     var noise_wind = wind_field.far_velocity;
     var noise_wind_read = false;
 
-    let volume_count = participating_media_volumes_count(&scene_database);
+    // 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
@@ -241,6 +264,7 @@ fn main(
         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"}