@woosh/meep-engine 3.54.0 → 3.55.0

package/src/shade/renderer/postprocess/ssr/depth_max_shader.js

@@ -1,98 +0,0 @@
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ImageShader } from "../../shader/ImageShader.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
-
-const resources = new ShaderResourceSetDescriptor();
-
-// per-pass, eight bytes, read-only: immediate data rather than a uniform buffer
-resources.setImmediate("output_resolution", "vec2<u32>");
-
-resources.createGroup()
-    .addTexture("tInput");
-
-
-/**
- * Inclusive source-texel window one output texel of the reduction reads: `(min.xy, max.xy)`.
- *
- * The windows of one step tile the source exactly — every source texel belongs to one output texel,
- * none twice and none missed — which is what makes the result a max over the whole level rather than a
- * max over an arbitrary stencil. Pinned by `depth_max_source_bounds.spec`.
- *
- * The stride is `ceil(source / output)`, not a hardcoded 2, and the upper bound is
- * `min + stride - 1` because the loops that read it are inclusive. It used to be `target * 2` for the
- * origin and `min + stride` for the bound, which at a halving step is three texels per axis: nine
- * reads for a 2x2 footprint, overlapping its neighbours on both sides.
- */
-export const chunk_depth_max_source_bounds = CodeChunk.from(
-    //language=WGSL
-    `
-fn depth_max_source_bounds(
-    target_coord: vec2<u32>,
-    source_resolution: vec2<u32>,
-    output_resolution: vec2<u32>
-) -> vec4<u32> {
-
-    let scale = vec2f(source_resolution) / vec2f(output_resolution);
-
-    let stride = max(vec2u(ceil(scale)), vec2u(1u));
-
-    let source_bounds_min = target_coord * stride;
-
-    // inclusive, and clamped so an output resolution that does not divide the source cannot read past
-    // the last texel
-    let source_bounds_max = min(
-        source_bounds_min + stride - vec2u(1u),
-        source_resolution - vec2u(1u)
-    );
-
-    return vec4u(source_bounds_min, source_bounds_max);
-}
-    `
-);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-@fragment
-fn main(
-    @builtin(position) coord : vec4<f32>,
-    @location(0) uv: vec2<f32>,
-) -> @location(0) f32 {
-
-    let target_coord_i = vec2<u32>(coord.xy);
-
-    let source_resolution = textureDimensions(tInput);
-
-    let bounds = depth_max_source_bounds(target_coord_i, source_resolution, output_resolution);
-
-    var max_value = 0.0;
-
-    for(var y = bounds.y ; y <= bounds.w ; y++){
-        for(var x = bounds.x ; x <= bounds.z ; x++){
-
-            let depth = textureLoad(tInput, vec2u(x,y), 0).r;
-
-            max_value = max(depth, max_value);
-        }
-    }
-
-    return max_value;
-}
-    `,
-    [chunk_depth_max_source_bounds]
-)
-
-export const depth_max_shader = new ImageShader({
-    descriptor: ShaderDescriptor.from({
-        label: "Depth Reduce / max",
-        body,
-        resources,
-    }),
-    targets: [
-        {
-            format: "r32float"
-        }
-    ]
-});
-

package/src/shade/renderer/postprocess/ssr/graph_build_depth_max_pyramid.d.ts

@@ -1,23 +0,0 @@
-/**
- * Build an `r32float` max-depth mip chain.
- *
- * **Nothing calls this.** `SSR.graph_pass` binds `view_ctx.hierarchical_z_buffer.texture` as
- * `tHZB` — see `Renderer.js` — and {@link HierarchicalZBuffer} is generally sufficient instead of
- * this. Kept because `@woosh/meep-engine` publishes raw `src`, so an unreferenced export is still
- * public surface.
- *
- * **The two are not interchangeable.** This pyramid is single-channel; the live HZB is two-channel and
- * `chunk_ffx_sssr_load_depth` reads its `.y`. Substituting this one gives a silently zero `.y`
- * rather than an error. See `prefilter/NOTES.md` for the rest of the dead surface in this directory.
- *
- * @param {Object} options
- * @param {FrameGraph} options.graph
- * @param {number[]} options.resolution
- * @param {number} options.input_depth
- */
-export function graph_build_depth_max_pyramid({ graph, resolution, input_depth }: {
-    graph: FrameGraph;
-    resolution: number[];
-    input_depth: number;
-}): any;
-//# sourceMappingURL=graph_build_depth_max_pyramid.d.ts.map

package/src/shade/renderer/postprocess/ssr/graph_build_depth_max_pyramid.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"graph_build_depth_max_pyramid.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/graph_build_depth_max_pyramid.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;GAgBG;AACH;IAJ+B,KAAK;IACP,UAAU,EAA5B,MAAM,EAAE;IACQ,WAAW,EAA3B,MAAM;QAiGhB"}

package/src/shade/renderer/postprocess/ssr/graph_build_depth_max_pyramid.js

@@ -1,118 +0,0 @@
-import { TextureViewDescriptor } from "../../../descriptor/texture/TextureViewDescriptor.js";
-import { TextureResourceDescriptor } from "../../../device/graph/TextureResourceDescriptor.js";
-import { copy_shader_f32 } from "./copy_shader_f32.js";
-import { depth_max_shader } from "./depth_max_shader.js";
-
-/**
- * Build an `r32float` max-depth mip chain.
- *
- * **Nothing calls this.** `SSR.graph_pass` binds `view_ctx.hierarchical_z_buffer.texture` as
- * `tHZB` — see `Renderer.js` — and {@link HierarchicalZBuffer} is generally sufficient instead of
- * this. Kept because `@woosh/meep-engine` publishes raw `src`, so an unreferenced export is still
- * public surface.
- *
- * **The two are not interchangeable.** This pyramid is single-channel; the live HZB is two-channel and
- * `chunk_ffx_sssr_load_depth` reads its `.y`. Substituting this one gives a silently zero `.y`
- * rather than an error. See `prefilter/NOTES.md` for the rest of the dead surface in this directory.
- *
- * @param {Object} options
- * @param {FrameGraph} options.graph
- * @param {number[]} options.resolution
- * @param {number} options.input_depth
- */
-export function graph_build_depth_max_pyramid({
-                                                  graph,
-                                                  resolution,
-                                                  input_depth = -1
-                                              }) {
-    /**
-     *
-     * @param data
-     * @param {FramePassResources} resources
-     * @param {GraphicsExecutionContext} context
-     */
-    function execute(data, resources, context) {
-        /**
-         * @type {GPUTextureContext}
-         */
-        const input = resources.get(data.input);
-        /**
-         * @type {GPUTextureContext}
-         */
-        const output = resources.get(data.output);
-
-        const encoder = context.encoder;
-
-        let source_view = output.obtainView(TextureViewDescriptor.from({
-            baseMipLevel: 0,
-            mipLevelCount: 1
-        }));
-
-        copy_shader_f32.draw({
-            encoder: encoder,
-            bindings: {
-                tInput: input.obtainView(),
-            },
-            colorAttachments: [
-                {
-                    view: source_view,
-
-                    storeOp: "store",
-                    loadOp: "clear",
-                }
-            ]
-        });
-
-        const mips = output.descriptor.mipLevelCount;
-
-        for (let i = 1; i < mips; i++) {
-
-            const destination_resolution = new Uint32Array([resolution[0] >>> i, resolution[1] >>> i]);
-
-            const output_resolution = encoder.allocateTransientBufferAndLoad(
-                destination_resolution.buffer,
-            );
-
-            const destination_view = output.obtainView(TextureViewDescriptor.from({
-                baseMipLevel: i,
-                mipLevelCount: 1
-            }));
-
-            depth_max_shader.draw({
-                encoder,
-                bindings: {
-                    tInput: source_view,
-                    output_resolution: output_resolution,
-                },
-                colorAttachments: [
-                    {
-                        view: destination_view,
-                        storeOp: "store",
-                        loadOp: "clear",
-                    }
-                ]
-            })
-
-            source_view = destination_view;
-        }
-
-    }
-
-    const pass_data = {};
-
-    const builder = graph.add("build depth max pyramid", pass_data, execute);
-
-
-    pass_data.input = builder.read(input_depth);
-
-    pass_data.output = builder.create("depth max", TextureResourceDescriptor.from({
-        resolution,
-        dimension: "2d",
-        usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
-        format: "r32float",
-        enableMips: true
-    }));
-
-
-    return pass_data.output;
-}

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

@@ -1,24 +0,0 @@
-/**
- * Packs and unpacks a 3D froxel coordinate `(x, y, z)` (up to 1024 per axis) into a single `u32`.
- * Shared between `shader_volumetrics_classify_froxels` and `shader_volumetrics_lighting_regimes`.
- *
- * @type {CodeChunk}
- */
-export const chunk_volumetrics_froxel_pack: CodeChunk;
-/**
- * Computes the jittered world-space sample position and view ray for a froxel `(x, y, z)`.
- * Shared by `shader_volumetrics_classify_froxels` and `shader_volumetrics_lighting_regimes` so the
- * classification pass and the lighting pass are guaranteed to evaluate the exact same world point.
- *
- * @type {CodeChunk}
- */
-export const chunk_volumetrics_froxel_jittered_ray: CodeChunk;
-/**
- * Evaluates a froxel's participating-media sample (`scattering`, `extinction`, `phase_g`, `random_u`)
- * at the jittered sample point produced by {@link chunk_volumetrics_froxel_jittered_ray}.
- *
- * @type {CodeChunk}
- */
-export const chunk_volumetrics_froxel_media_sample: CodeChunk;
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
-//# sourceMappingURL=chunk_volumetrics_froxel_sample.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"chunk_volumetrics_froxel_sample.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/chunk_volumetrics_froxel_sample.js"],"names":[],"mappings":"AAkBA;;;;;GAKG;AACH,4CAFU,SAAS,CAmBjB;AAEF;;;;;;GAMG;AACH,oDAFU,SAAS,CA0DjB;AAYF;;;;;GAKG;AACH,oDAFU,SAAS,CA2DjB;0BA5KwB,iCAAiC"}

package/src/shade/renderer/volumetrics/gi/chunk_volumetrics_froxel_centre_ws.d.ts

@@ -1,15 +0,0 @@
-/**
- * `volumetrics_froxel_centre_ws(voxel, resolution)` — the world position a froxel's value stands for:
- * its column's centre, at the depth its slab's content sits at (`volumetrics_froxel_content_offset`),
- * which is where the lighting pass's jittered samples average to and where
- * `volumetrics_position_world_to_froxel_uvw` puts the froxel's texel centre. A froxel GI module
- * whose answer depends on position asks it there; GI is smooth enough across a froxel that one
- * sample is all of it.
- *
- * The enclosing shader binds `camera` and `volumetrics_metadata` under those names.
- *
- * @type {CodeChunk}
- */
-export const chunk_volumetrics_froxel_centre_ws: CodeChunk;
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-//# sourceMappingURL=chunk_volumetrics_froxel_centre_ws.d.ts.map

package/src/shade/renderer/volumetrics/gi/chunk_volumetrics_froxel_centre_ws.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunk_volumetrics_froxel_centre_ws.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/gi/chunk_volumetrics_froxel_centre_ws.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;GAWG;AACH,iDAFU,SAAS,CAyBjB;0BAzCwB,oCAAoC"}

package/src/shade/renderer/volumetrics/gi/chunk_volumetrics_gi.d.ts

@@ -1,17 +0,0 @@
-/**
- * How the froxel GI stage (`shader_volumetrics_gi`) stores its answer. One thread per froxel asks the
- * renderer's indirect lighting mode what radiance arrives at the froxel, as RGB SH2
- * (`chunk_volumetrics_gi_sample`), and hands the answer to `volumetrics_gi_store`. That starts the
- * froxel irradiance volume, and `shader_volumetrics_build_irradiance` adds the lights to it.
- *
- * `volumetrics_gi_store(voxel, radiance)` scales the field by `INDIRECT_LIGHT_INTENSITY`, as the
- * deferred and forward paths scale their indirect light, encodes it as the volume stores light
- * (`volumetrics_irradiance_sh_add_radiance`) and writes it to `tGIY` / `tGICoCg`.
- *
- * The enclosing shader binds `tGIY` and `tGICoCg` under those names.
- *
- * @type {CodeChunk}
- */
-export const chunk_volumetrics_gi: CodeChunk;
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-//# sourceMappingURL=chunk_volumetrics_gi.d.ts.map

package/src/shade/renderer/volumetrics/gi/chunk_volumetrics_gi.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunk_volumetrics_gi.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/gi/chunk_volumetrics_gi.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;GAaG;AACH,mCAFU,SAAS,CA0BjB;0BA3CwB,oCAAoC"}

package/src/shade/renderer/volumetrics/gi/chunk_volumetrics_gi_sample.d.ts

@@ -1,35 +0,0 @@
-/**
- * {@link chunk_volumetrics_gi_sample} under IBL: the environment, as `GPULightCollection.environment_sh`
- * holds it (`shader_project_environment_sh`). It is infinitely far, so every froxel receives the same
- * field.
- * @type {CodeChunk}
- */
-export const chunk_volumetrics_gi_sample_ibl: CodeChunk;
-/**
- * {@link chunk_volumetrics_gi_sample} under Brick4: the sparse volumetric light map's probes,
- * interpolated at the froxel's centre and truncated from SH3 to SH2. Reads `brick4`.
- * @type {CodeChunk}
- */
-export const chunk_volumetrics_gi_sample_brick4: CodeChunk;
-/**
- * {@link chunk_volumetrics_gi_sample} under LPV: the light probe volume's tetrahedral mesh, its probes
- * (radiance SH2) interpolated barycentrically at the froxel's centre. Reads the LPV's buffers.
- * @type {CodeChunk}
- */
-export const chunk_volumetrics_gi_sample_lpv: CodeChunk;
-/**
- * The radiance that arrives at a froxel, as RGB SH2, by the renderer's indirect lighting mode
- * ({@link INDIRECT_LIGHTING}):
- *
- * ```wgsl
- * fn volumetrics_gi_sample(voxel: vec3<u32>, resolution: vec3<u32>) -> array<vec3<f32>, 4>
- * ```
- *
- * A new mode is one more alternative: nothing downstream knows which mode wrote the volume.
- *
- * @type {CodeChunkChoice}
- */
-export const chunk_volumetrics_gi_sample: CodeChunkChoice;
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { CodeChunkChoice } from "../../shader/compiler/CodeChunkChoice.js";
-//# sourceMappingURL=chunk_volumetrics_gi_sample.d.ts.map

package/src/shade/renderer/volumetrics/gi/chunk_volumetrics_gi_sample.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunk_volumetrics_gi_sample.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/gi/chunk_volumetrics_gi_sample.js"],"names":[],"mappings":"AAWA;;;;;GAKG;AACH,8CAFU,SAAS,CAUhB;AAEH;;;;GAIG;AACH,iDAFU,SAAS,CAWhB;AAEH;;;;GAIG;AACH,8CAFU,SAAS,CAWhB;AAEH;;;;;;;;;;;GAWG;AACH,0CAFU,eAAe,CAE0D;0BArEzD,oCAAoC;gCAC9B,0CAA0C"}

package/src/shade/renderer/volumetrics/gi/graph_build_froxel_gi.d.ts

@@ -1,35 +0,0 @@
-/**
- * The froxel GI stage: the renderer's indirect lighting at every froxel, as the froxel irradiance
- * volume encodes light, for `shader_volumetrics_build_irradiance` to add the lights to. The shader is
- * built for the renderer's switches, which pick the indirect lighting mode it samples
- * (`chunk_volumetrics_gi_sample`); this binds the environment and the running mode's source.
- *
- * @param {object} options
- * @param {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} options.graph
- * @param {ShaderSwitchSet} [options.shader_switches] the renderer's
- * @param {import("../../scene/GPUSceneContext.js").GPUSceneContext} options.scene_ctx for its environment,
- *   `lights.environment_sh`
- * @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. A source not given is the shader's default, for a variant that does not read it
- * @param {import("../../camera/GPUCameraContext.js").GPUCameraContext} options.camera
- * @param {number} options.volumetrics_metadata graph handle
- * @param {number[]} options.resolution the froxel grid
- * @returns {{Y: number, CoCg: number}} handles of the GI volume, in the froxel irradiance encoding
- */
-export function graph_build_froxel_gi({ graph, shader_switches, scene_ctx, brick4, lpv, camera, volumetrics_metadata, resolution, }: {
-    graph: import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
-    shader_switches?: ShaderSwitchSet;
-    scene_ctx: import("../../scene/GPUSceneContext.js").GPUSceneContext;
-    brick4?: import("../../global_illumination/brick4/Brick4LightMap.js").Brick4LightMap;
-    lpv?: import("../../global_illumination/lpv/GPULightProbeVolume.js").GPULightProbeVolume;
-    camera: import("../../camera/GPUCameraContext.js").GPUCameraContext;
-    volumetrics_metadata: number;
-    resolution: number[];
-}): {
-    Y: number;
-    CoCg: number;
-};
-import { ShaderSwitchSet } from "../../shader/compiler/ShaderSwitchSet.js";
-//# sourceMappingURL=graph_build_froxel_gi.d.ts.map

package/src/shade/renderer/volumetrics/gi/graph_build_froxel_gi.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"graph_build_froxel_gi.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/gi/graph_build_froxel_gi.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAbsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;IACvD,eAAe,GAAzC,eAAe;IACmD,SAAS,EAA3E,OAAO,gCAAgC,EAAE,eAAe;IAE8B,MAAM,GAA5F,OAAO,oDAAoD,EAAE,cAAc;IAEkB,GAAG,GAAhG,OAAO,sDAAsD,EAAE,mBAAmB;IAEb,MAAM,EAA3E,OAAO,kCAAkC,EAAE,gBAAgB;IAC3C,oBAAoB,EAApC,MAAM;IACY,UAAU,EAA5B,MAAM,EAAE;IACN;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAsDrC;gCA5E+B,0CAA0C"}

package/src/shade/renderer/volumetrics/gi/shader_volumetrics_gi.d.ts

@@ -1,10 +0,0 @@
-/**
- * The froxel GI stage: the renderer's indirect lighting at every froxel, one thread per froxel. Which
- * mode's light it asks for is a shader switch ({@link chunk_volumetrics_gi_sample}); the bindings are
- * the same for every mode. See `chunk_volumetrics_gi` for what it does with the answer.
- *
- * @type {ComputeShader}
- */
-export const shader_volumetrics_gi: ComputeShader;
-import { ComputeShader } from "../../shader/ComputeShader.js";
-//# sourceMappingURL=shader_volumetrics_gi.d.ts.map

package/src/shade/renderer/volumetrics/gi/shader_volumetrics_gi.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shader_volumetrics_gi.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/gi/shader_volumetrics_gi.js"],"names":[],"mappings":"AAuCA;;;;;;GAMG;AACH,oCAFU,aAAa,CAMpB;8BA9C2B,+BAA+B"}

package/src/shade/renderer/volumetrics/gi/volumetrics_gi_resources.d.ts

@@ -1,28 +0,0 @@
-/**
- * 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(): ShaderResourceGroupDescriptor;
-/**
- * The froxel GI's luma volume, as its modules write it (`chunk_volumetrics_gi`).
- * @type {ShaderResourceDescriptor}
- */
-export const VOLUMETRICS_GI_Y_RESOURCE: ShaderResourceDescriptor;
-/**
- * The froxel GI's chroma volume, as its modules write it (`chunk_volumetrics_gi`).
- * @type {ShaderResourceDescriptor}
- */
-export const VOLUMETRICS_GI_COCG_RESOURCE: ShaderResourceDescriptor;
-/**
- * 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: number[];
-import { ShaderResourceGroupDescriptor } from "../../shader/resource/ShaderResourceGroupDescriptor.js";
-import { ShaderResourceDescriptor } from "../../shader/resource/ShaderResourceDescriptor.js";
-//# sourceMappingURL=volumetrics_gi_resources.d.ts.map

package/src/shade/renderer/volumetrics/gi/volumetrics_gi_resources.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"volumetrics_gi_resources.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/gi/volumetrics_gi_resources.js"],"names":[],"mappings":"AAiBA;;;;;;GAMG;AACH,iDAFa,6BAA6B,CAQzC;AAzBD;;;GAGG;AACH,wCAFU,wBAAwB,CAE0F;AAE5H;;;GAGG;AACH,2CAFU,wBAAwB,CAEgG;AAiBlI;;;;;GAKG;AACH,kDAFU,MAAM,EAAE,CAE2C;8CApCf,wDAAwD;yCAD7D,mDAAmD"}

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

@@ -1,48 +0,0 @@
-/**
- * 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, brick4, lpv, }: {
-    graph: import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
-    camera: import("../camera/GPUCameraContext.js").GPUCameraContext;
-    view: import("../view/GPUViewContext.js").GPUViewContext;
-    lights: import("../light/GPULightCollection.js").GPULightCollection;
-    light_cluster_data: number;
-    light_cluster_lookup: number;
-    light_cluster_parameters: number;
-    shadowmap_atlas: number;
-    volumetrics_metadata: number;
-    resolution: number[];
-    shader_switches?: ShaderSwitchSet;
-    brick4?: import("../global_illumination/brick4/Brick4LightMap.js").Brick4LightMap;
-    lpv?: import("../global_illumination/lpv/GPULightProbeVolume.js").GPULightProbeVolume;
-}): {
-    Y: number;
-    CoCg: number;
-};
-import { ShaderSwitchSet } from "../shader/compiler/ShaderSwitchSet.js";
-//# sourceMappingURL=graph_build_froxel_irradiance.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"graph_build_froxel_irradiance.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/graph_build_froxel_irradiance.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IAlBmG,KAAK,EAA7F,OAAO,2DAA2D,EAAE,UAAU;IACZ,MAAM,EAAxE,OAAO,+BAA+B,EAAE,gBAAgB;IACI,IAAI,EAAhE,OAAO,2BAA2B,EAAE,cAAc;IACmB,MAAM,EAA3E,OAAO,gCAAgC,EAAE,kBAAkB;IAC3C,kBAAkB,EAAlC,MAAM;IACU,oBAAoB,EAApC,MAAM;IACU,wBAAwB,EAAxC,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,oBAAoB,EAApC,MAAM;IACY,UAAU,EAA5B,MAAM,EAAE;IACkB,eAAe,GAAzC,eAAe;IAEoE,MAAM,GAAzF,OAAO,iDAAiD,EAAE,cAAc;IAEkB,GAAG,GAA7F,OAAO,mDAAmD,EAAE,mBAAmB;IAE7E;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAsFrC;gCAvH+B,uCAAuC"}

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

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

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

@@ -1 +0,0 @@
-{"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_classify_froxels.d.ts

@@ -1,16 +0,0 @@
-export const VOLUMETRICS_CLASSIFY_WORKGROUP_RESOLUTION: readonly number[];
-/**
- * Classifies every froxel of the volumetric grid into one of the three lighting regimes (Decision 4.2)
- * using subgroup-coalesced appends ({@link chunk_collection_u32_append}):
- *
- * 1. `list_clipmap` — froxels fully inside the world-space irradiance clipmap (`c < count - 1`, or
- *    `c == count - 1` with `edge_weight == 0`).
- * 2. `list_blended` — froxels in the outer transition band of the coarsest cascade (`c == count - 1`
- *    with `edge_weight > 0`), where clipmap irradiance blends into the far-field lighting.
- * 3. `list_far_field` — froxels outside all cascades (`CLIPMAP_LEVEL_NONE`).
- *
- * @type {ComputeShader}
- */
-export const shader_volumetrics_classify_froxels: ComputeShader;
-import { ComputeShader } from "../shader/ComputeShader.js";
-//# sourceMappingURL=shader_volumetrics_classify_froxels.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"shader_volumetrics_classify_froxels.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_classify_froxels.js"],"names":[],"mappings":"AAgBA,0EAAkF;AAyDlF;;;;;;;;;;;GAWG;AACH,kDAFU,aAAa,CAMpB;8BApF2B,4BAA4B"}

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

@@ -1,23 +0,0 @@
-/**
- * Workgroup size (64 threads) used by each of the 3 volumetric lighting regime dispatches.
- * @type {number}
- */
-export const VOLUMETRICS_REGIME_WORKGROUP_SIZE: number;
-/**
- * Evaluates far-field in-scattering at a froxel sample (`VolumetricsFroxelSample`) using the same
- * full irradiance model as the world-space irradiance clipmap (environment GI + directional lights
- * with atmospheric transmittance and multiple scattering, evaluated through
- * `irradiance_clipmap_sh_multiscattering`).
- *
- * Shared as a first-class {@link CodeChunk} between `shader_volumetrics_lighting_blended` and
- * `shader_volumetrics_lighting_far_field`.
- *
- * @type {CodeChunk}
- */
-export const chunk_volumetrics_far_field_directional: CodeChunk;
-export const shader_volumetrics_lighting_clipmap: ComputeShader;
-export const shader_volumetrics_lighting_blended: ComputeShader;
-export const shader_volumetrics_lighting_far_field: ComputeShader;
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../shader/ComputeShader.js";
-//# sourceMappingURL=shader_volumetrics_lighting_regimes.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"shader_volumetrics_lighting_regimes.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_lighting_regimes.js"],"names":[],"mappings":"AA+CA;;;GAGG;AACH,gDAFU,MAAM,CAEoC;AAEpD;;;;;;;;;;GAUG;AACH,sDAFU,SAAS,CA6FjB;AAwFF,gEAIG;AAuFH,gEAIG;AA2DH,kEAIG;0BAhYuB,iCAAiC;8BAC7B,4BAA4B"}