@woosh/meep-engine 3.50.0 → 3.51.0

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,
+        ]
+    ),
+});