@woosh/meep-engine 3.53.0 → 3.54.0

package/src/shade/renderer/volumetrics/gi/volumetrics_gi_resources.js

@@ -1,39 +0,0 @@
-import { CAMERA_RESOURCE } from "../../camera/CAMERA_RESOURCE.js";
-import { ShaderResourceDescriptor } from "../../shader/resource/ShaderResourceDescriptor.js";
-import { ShaderResourceGroupDescriptor } from "../../shader/resource/ShaderResourceGroupDescriptor.js";
-import { VOLUMETRICS_METADATA_RESOURCE } from "../VOLUMETRICS_RESOURCES.js";
-
-/**
- * The froxel GI's luma volume, as its modules write it (`chunk_volumetrics_gi`).
- * @type {ShaderResourceDescriptor}
- */
-export const VOLUMETRICS_GI_Y_RESOURCE = ShaderResourceDescriptor.storageTexture("tGIY", "rgba16float", "3d", "write-only");
-
-/**
- * The froxel GI's chroma volume, as its modules write it (`chunk_volumetrics_gi`).
- * @type {ShaderResourceDescriptor}
- */
-export const VOLUMETRICS_GI_COCG_RESOURCE = ShaderResourceDescriptor.storageTexture("tGICoCg", "rgba16float", "3d", "write-only");
-
-/**
- * The bindings every froxel GI module has, whatever its mode reads: where the froxels are, and the
- * two volumes it writes (`chunk_volumetrics_gi`). rgba16float for both, because rg16float is not a
- * storage format without texture-formats-tier1.
- *
- * @returns {ShaderResourceGroupDescriptor}
- */
-export function volumetrics_gi_resource_group() {
-    return new ShaderResourceGroupDescriptor()
-        .add(VOLUMETRICS_METADATA_RESOURCE)
-        .add(CAMERA_RESOURCE)
-        .add(VOLUMETRICS_GI_Y_RESOURCE)
-        .add(VOLUMETRICS_GI_COCG_RESOURCE);
-}
-
-/**
- * Workgroup shape of every froxel GI module, `[x, y, z]` in froxels: flat in z like the lighting
- * pass, and 64 invocations.
- *
- * @type {number[]}
- */
-export const VOLUMETRICS_GI_WORKGROUP_RESOLUTION = [8, 8, 1];

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

@@ -1,121 +0,0 @@
-import { TextureResourceDescriptor } from "../../device/graph/TextureResourceDescriptor.js";
-import { ShaderSwitchSet } from "../shader/compiler/ShaderSwitchSet.js";
-import { SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR } from "../shadow/map/SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR.js";
-import { STATIC_GRAPHICS_ENGINE_ASSETS } from "../STATIC_GRAPHICS_ENGINE_ASSETS.js";
-import { DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR } from "../texture/DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR.js";
-import { graph_build_froxel_gi } from "./gi/graph_build_froxel_gi.js";
-import { shader_volumetrics_build_irradiance } from "./shader_volumetrics_build_irradiance.js";
-
-/**
- * The froxel irradiance volume (`chunk_volumetrics_irradiance_sh`), what lit particles are lit by: the
- * froxel GI stage (`gi/graph_build_froxel_gi`), then every light with its shadow on top of it
- * (`shader_volumetrics_build_irradiance`).
- *
- * Nothing here reads the fog. The volume is the same with or without participating media, and the
- * two passes run only when something reads what they write — the frame graph culls them otherwise,
- * which is the frame with no lit particle in it.
- *
- * @param {Object} options
- * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} options.graph
- * @param {import("../camera/GPUCameraContext.js").GPUCameraContext} options.camera
- * @param {import("../view/GPUViewContext.js").GPUViewContext} options.view
- * @param {import("../light/GPULightCollection.js").GPULightCollection} options.lights
- * @param {number} options.light_cluster_data
- * @param {number} options.light_cluster_lookup
- * @param {number} options.light_cluster_parameters
- * @param {number} options.shadowmap_atlas
- * @param {number} options.volumetrics_metadata where the froxels are
- * @param {number[]} options.resolution the froxel grid
- * @param {ShaderSwitchSet} [options.shader_switches] the renderer's; the GI that starts the volume and the
- *   lights' pass are built for them
- * @param {import("../global_illumination/brick4/Brick4LightMap.js").Brick4LightMap} [options.brick4] the scene's,
- *   while Brick4 runs
- * @param {import("../global_illumination/lpv/GPULightProbeVolume.js").GPULightProbeVolume} [options.lpv] the
- *   scene's, while LPV runs
- * @returns {{Y: number, CoCg: number}} handles of the volume: luma SH2, and chroma in `.rg`
- */
-export function graph_build_froxel_irradiance({
-                                                  graph,
-                                                  camera,
-                                                  view,
-                                                  lights,
-                                                  light_cluster_data,
-                                                  light_cluster_lookup,
-                                                  light_cluster_parameters,
-                                                  shadowmap_atlas,
-                                                  volumetrics_metadata,
-                                                  resolution,
-                                                  shader_switches = ShaderSwitchSet.EMPTY,
-                                                  brick4,
-                                                  lpv,
-                                              }) {
-
-    const gi = graph_build_froxel_gi({
-        graph,
-        shader_switches,
-        brick4,
-        lpv,
-        scene_ctx: view.scene,
-        camera,
-        volumetrics_metadata,
-        resolution,
-    });
-
-    const data = {};
-
-    const pass = graph.add(shader_volumetrics_build_irradiance.descriptor.label, data, (data, resources, context) => {
-        const output_Y = resources.get(data.irradiance_Y);
-        const output_CoCg = resources.get(data.irradiance_CoCg);
-
-        // The blue noise the sample is jittered by. Fetched here rather than when the pass is
-        // recorded: the engine's assets arrive at startup, and this is when the pass needs them.
-        const tSTBN_vec3 = context.graphics.textures.obtain(STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec3);
-
-        shader_volumetrics_build_irradiance.variant(shader_switches).dispatchThreads({
-            encoder: context.encoder,
-            thread_count_x: output_Y.width,
-            thread_count_y: output_Y.height,
-            thread_count_z: output_Y.depth,
-            bindings: {
-                volumetrics_metadata: resources.get(data.volumetrics_metadata),
-                camera: camera.buffer.buffer,
-                view: view.uniform_buffer.buffer,
-                tSTBN_vec3: tSTBN_vec3.obtainView(),
-                tGIY: resources.get(data.gi_Y).obtainView(),
-                tGICoCg: resources.get(data.gi_CoCg).obtainView(),
-                tIrradianceY: output_Y.obtainView(DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR),
-                tIrradianceCoCg: output_CoCg.obtainView(DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR),
-
-                light_data: lights.buffer_data,
-                cluster_parameters: resources.get(data.light_cluster_parameters),
-                cluster_lookup: resources.get(data.light_cluster_lookup),
-                cluster_data: resources.get(data.light_cluster_data),
-                shadowmapAtlas: resources.get(data.shadowmap_atlas).obtainView(),
-                sCompareLinear: context.graphics.samplers.obtain(SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR),
-            },
-        });
-    });
-
-    data.volumetrics_metadata = pass.read(volumetrics_metadata);
-    data.gi_Y = pass.read(gi.Y);
-    data.gi_CoCg = pass.read(gi.CoCg);
-    data.light_cluster_data = pass.read(light_cluster_data);
-    data.light_cluster_lookup = pass.read(light_cluster_lookup);
-    data.light_cluster_parameters = pass.read(light_cluster_parameters);
-    data.shadowmap_atlas = pass.read(shadowmap_atlas);
-
-    const volume = (label) => pass.create(label, TextureResourceDescriptor.from({
-        resolution,
-        dimension: "3d",
-        format: "rgba16float",
-        usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING
-    }));
-
-    data.irradiance_Y = volume("Froxel Irradiance Y");
-    data.irradiance_CoCg = volume("Froxel Irradiance CoCg");
-
-    return {
-        Y: data.irradiance_Y,
-        CoCg: data.irradiance_CoCg,
-    };
-}

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

@@ -1,237 +0,0 @@
-import { CAMERA_UNIFORM_STRUCT } from "../camera/CAMERA_UNIFORM_STRUCT.js";
-import { chunk_light_cluster_counts } from "../light/cluster/chunk_light_cluster_counts.js";
-import { chunk_light_cluster_metadata_by_position } from "../light/cluster/chunk_light_cluster_metadata_by_position.js";
-import { LIGHT_CLUSTER_LOOKUP_STRUCT } from "../light/cluster/shader_cluster_assign_lights.js";
-import { chunk_cluster_depth_from_z_slice } from "../light/cluster/chunk_cluster_depth_from_z_slice.js";
-import { chunk_camera_ray_from_uv } from "../shader/chunk/geometry/ray/chunk_camera_ray_from_uv.js";
-import { RAY_STRUCT } from "../shader/chunk/geometry/ray/RAY_STRUCT.js";
-import { chunk_stbn_sample_vec3 } from "../shader/chunk/noise/chunk_stbn_sample_vec3.js";
-import {
-    chunk_directional_lights_iteration_mask
-} from "../shader/chunk/light/io/chunk_directional_lights_iteration_mask.js";
-import {
-    chunk_get_directional_light_info_by_index
-} from "../shader/chunk/light/io/chunk_get_directional_light_info_by_index.js";
-import {
-    chunk_get_point_light_info_by_index
-} from "../shader/chunk/light/io/chunk_get_point_light_info_by_index.js";
-import { chunk_get_spot_light_info_by_index } from "../shader/chunk/light/io/chunk_get_spot_light_info_by_index.js";
-import {
-    METRO_L1_IRRADIANCE_STRUCT
-} from "../shader/chunk/spherical_harmonics/l1i/chunk_convert_to_irradiance_sh.js";
-import { chunk_texel_coordinate_to_uv } from "../shader/chunk/texture/chunk_texel_coordinate_to_uv.js";
-import { chunk_uv_to_texel_coordinate } from "../shader/chunk/texture/chunk_uv_to_texel_coordinate.js";
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
-import { vec3f } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../shader/type/WebGPUArray.js";
-import { chunk_shadowmap_get_light_visibility } from "../shadow/map/shader/chunk_shadowmap_get_light_visibility.js";
-import { SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR } from "../shadow/map/SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR.js";
-import { VIEW_UNIFORM_STRUCT } from "../view/VIEW_UNIFORM_STRUCT.js";
-import { chunk_volumetrics_irradiance_sh } from "./chunk_volumetrics_irradiance_sh.js";
-import { chunk_volumetrics_local_light_shadow } from "./chunk_volumetrics_local_light_shadow.js";
-import { chunk_camera_ray_planar_depth_scale } from "./chunk_camera_ray_planar_depth_scale.js";
-import { chunk_volumetrics_column_jitter } from "./chunk_volumetrics_column_jitter.js";
-import { VOLUMETRICS_METADATA_STRUCT } from "./VOLUMETRICS_METADATA_STRUCT.js";
-
-/**
- * Workgroup shape of this pass, `[x, y, z]` in froxels, stated to the `@workgroup_size` below and
- * read back out of it by the dispatch. Flat in z and 64 invocations, for the reasons the fog's
- * lighting pass gives (`VOLUMETRICS_LIGHTING_WORKGROUP_RESOLUTION`): it walks the same light
- * clusters, and those are farthest apart along depth.
- *
- * @type {number[]}
- */
-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
-// of the other. rgba16float for both, because rg16float is not a storage format without
-// texture-formats-tier1. It starts from what the froxel GI stage (gi/) wrote to tGIY / tGICoCg.
-resources.createGroup()
-    .addUniform("volumetrics_metadata", VOLUMETRICS_METADATA_STRUCT)
-    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
-    .addUniform("view", VIEW_UNIFORM_STRUCT)
-    .addTexture("tSTBN_vec3", "unfilterable-float", "3d")
-    .addTexture("tGIY", "float", "3d")
-    .addTexture("tGICoCg", "float", "3d")
-    .addStorageTexture("tIrradianceY", "rgba16float", "3d", "write-only")
-    .addStorageTexture("tIrradianceCoCg", "rgba16float", "3d", "write-only");
-
-// Lighting information
-resources.createGroup()
-    .addStorageBuffer("light_data", WebGPUArray.u32)
-    // clusters
-    .addUniform("cluster_parameters", vec3f)
-    .addStorageBuffer("cluster_lookup", LIGHT_CLUSTER_LOOKUP_STRUCT)
-    .addStorageBuffer("cluster_data", WebGPUArray.u32)
-    // shadows
-    .addTexture("shadowmapAtlas", "depth")
-    .addSampler("sCompareLinear", "comparison", SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-@compute @workgroup_size(${VOLUMETRICS_IRRADIANCE_WORKGROUP_RESOLUTION.join(",")})
-fn main(
-    @builtin(global_invocation_id) voxel : vec3<u32>
-){
-    let resolution = textureDimensions(tIrradianceY);
-
-    if (any(voxel >= resolution)) {
-        return;
-    }
-
-    // The fog lighting pass's sample, taken the same way (shader_volumetrics_build_lighting, where
-    // the irradiance was written until it had a pass of its own): one point per froxel per frame,
-    // jittered across the slab in depth by the column jitter and the blue noise, and in xy by the
-    // blue noise. Never a fixed point. A particle spans many froxels and reads them trilinearly, and
-    // a lattice of samples that never moves shows on it as seams wherever neighbouring texels
-    // disagree — beside a light, along a shadow edge. Moved every frame, the lattice is resolved by
-    // the main TAA, which the particles are drawn ahead of.
-    let near_far = camera.clip_near_far;
-    let curve = volumetrics_metadata.froxel_cluster_parameters;
-
-    let z_jitter = volumetrics_column_jitter(voxel.xy, view.frame_index);
-
-    let z0 = max(near_far.x, cluster_depth_from_z_slice(f32(voxel.z) + z_jitter, curve, f32(resolution.z)));
-    let z1 = min(near_far.y, cluster_depth_from_z_slice(f32(voxel.z + 1u) + z_jitter, curve, f32(resolution.z)));
-
-    // the lighting pass's offset and temporal axis, so the two passes ask about the same point
-    const STBN_DECORRELATION_OFFSET = vec2<u32>(37u, 71u);
-
-    let noise = stbn_sample_vec3(vec3(voxel.xy + STBN_DECORRELATION_OFFSET, view.frame_index + voxel.z));
-
-    // interpolate the cubes, then take the cube root: uniform in world-space volume across the slab
-    let view_depth = pow(mix(z0 * z0 * z0, z1 * z1 * z1, noise.z), 0.333333);
-
-    let tile_uv = saturate(texel_coordinate_to_uv(vec2<f32>(voxel.xy) + (noise.xy - 0.5), resolution.xy));
-    let view_ray = camera_ray_from_uv(tile_uv, camera);
-
-    // view_depth is planar, so step the ray by the planar-to-distance scale
-    let position_ws = view_ray.origin
-        + view_ray.direction * (view_depth * camera_ray_planar_depth_scale(view_ray.direction, camera));
-
-    let view_pixel_coord = uv_to_texel_coordinate(tile_uv, vec2(view.width, view.height));
-
-    var irradiance: ${METRO_L1_IRRADIANCE_STRUCT.wgsl_ref};
-
-    // Each light as the surfaces around the froxel receive it: its colour and its shadow, and no
-    // medium on the way in. The deferred and forward paths light meshes by exactly this, and a lit
-    // particle beside a lit log has to agree with it — the fog is composited over both afterwards.
-
-    var directional_bits = directional_lights_iteration_mask(&light_data);
-    while (directional_bits != 0u) {
-        let directional_index = countTrailingZeros(directional_bits);
-        directional_bits &= ~(1u << directional_index);
-
-        let sun = get_directional_light_info_by_index(&light_data, directional_index);
-
-        let shadow_term = shadowmap_get_directional_light_visibility(
-            &light_data,
-            directional_index,
-            position_ws,
-            // toward-camera, the deferred cascade-blend convention; view_ray runs camera->scene
-            -view_ray.direction,
-            sun.direction
-        );
-
-        irradiance = volumetrics_irradiance_sh_add(irradiance, shadow_term * sun.color, sun.direction);
-    }
-
-    let cluster_metadata = light_cluster_metadata_by_position(
-        view_pixel_coord,
-        view_depth,
-        vec2(view.width, view.height)
-    );
-
-    let cluster_offset = cluster_metadata.offset;
-    let point_count = light_cluster_count_point(cluster_metadata.counts);
-    let spot_count = light_cluster_count_spot(cluster_metadata.counts);
-
-    // 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);
-
-        if (all(direct_light.color == vec3(0.0))) {
-            continue;
-        }
-
-        let shadow_term = volumetrics_point_light_shadow(&light_data, light_index, position_ws);
-
-        irradiance = volumetrics_irradiance_sh_add(irradiance, shadow_term * direct_light.color, direct_light.direction);
-    }
-
-    // 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);
-
-        if (all(direct_light.color == vec3(0.0))) {
-            continue;
-        }
-
-        let shadow_term = volumetrics_spot_light_shadow(&light_data, light_index, position_ws);
-
-        irradiance = volumetrics_irradiance_sh_add(irradiance, shadow_term * direct_light.color, direct_light.direction);
-    }
-
-    // What the renderer's indirect lighting gives this froxel, in the same encoding; the lights add
-    // to it. Written by the froxel GI module the mode selects, which is all this pass knows of GI.
-    irradiance.Y += textureLoad(tGIY, voxel, 0);
-    irradiance.CoCg += textureLoad(tGICoCg, voxel, 0).xy;
-
-    // nothing filters this volume, so nothing downstream would stop an Inf or a NaN here
-    let stored = volumetrics_irradiance_sh_storable(irradiance);
-
-    textureStore(tIrradianceY, voxel, stored.Y);
-    textureStore(tIrradianceCoCg, voxel, vec4<f32>(stored.CoCg, 0.0, 0.0));
-}
-    `, [
-        METRO_L1_IRRADIANCE_STRUCT.declaration_chunk,
-        RAY_STRUCT.declaration_chunk,
-        chunk_volumetrics_column_jitter,
-        chunk_cluster_depth_from_z_slice,
-        chunk_stbn_sample_vec3,
-        chunk_texel_coordinate_to_uv,
-        chunk_uv_to_texel_coordinate,
-        chunk_camera_ray_from_uv,
-        chunk_camera_ray_planar_depth_scale,
-
-        chunk_light_cluster_metadata_by_position,
-        chunk_light_cluster_counts,
-        chunk_directional_lights_iteration_mask,
-        chunk_get_directional_light_info_by_index,
-        chunk_get_point_light_info_by_index,
-        chunk_get_spot_light_info_by_index,
-        chunk_shadowmap_get_light_visibility,
-        chunk_volumetrics_local_light_shadow,
-        chunk_volumetrics_irradiance_sh,
-    ]
-);
-
-/**
- * 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
- * spot light with its shadow, at a point jittered through the froxel every frame.
- *
- * Its own pass, not a by-product of the fog's lighting pass: particle lighting needs no medium, so it
- * runs whether or not the scene has any fog, and the frame graph culls it when nothing reads it.
- *
- * @type {ComputeShader}
- */
-export const shader_volumetrics_build_irradiance = ComputeShader.from({
-    label: "Volumetrics / build irradiance",
-    resources,
-    body,
-});