@woosh/meep-engine 3.52.0 → 3.54.0

package/src/engine/graphics/render/visibility/VisibilityComputer.d.ts

@@ -1,39 +0,0 @@
-export class VisibilityComputer {
-    /**
-     *
-     * @type {CameraView}
-     */
-    __view: CameraView;
-    /**
-     *
-     * @type {RenderLayer}
-     * @private
-     */
-    private __activeLayer;
-    /**
-     *
-     * @type {IncrementalDeltaSet<*>}
-     * @private
-     */
-    private __output;
-    /**
-     *
-     * @param {CameraView} view
-     */
-    set view(view: CameraView);
-    /**
-     * @private
-     * @param {RenderLayer} layer
-     */
-    private __processLayer;
-    /**
-     * @param {IncrementalDeltaSet<Object3D>} v
-     */
-    set output(v: IncrementalDeltaSet<Object3D>);
-    /**
-     *
-     * @param {RenderLayerManager} renderLayers
-     */
-    build(renderLayers: RenderLayerManager): void;
-}
-//# sourceMappingURL=VisibilityComputer.d.ts.map

package/src/engine/graphics/render/visibility/VisibilityComputer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"VisibilityComputer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/render/visibility/VisibilityComputer.js"],"names":[],"mappings":"AAEA;IACI;;;OAGG;IACH,mBAAc;IAEd;;;;OAIG;IACH,sBAAqB;IAErB;;;;OAIG;IACH,iBAAgB;IAEhB;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,uBA2BC;IAGD;;OAEG;IACH,6CAEC;IAED;;;OAGG;IACH,8CAEC;CACJ"}

package/src/engine/graphics/render/visibility/VisibilityComputer.js

@@ -1,80 +0,0 @@
-const scratch_array = [];
-
-export class VisibilityComputer {
-    /**
-     *
-     * @type {CameraView}
-     */
-    __view = null;
-
-    /**
-     *
-     * @type {RenderLayer}
-     * @private
-     */
-    __activeLayer = null;
-
-    /**
-     *
-     * @type {IncrementalDeltaSet<*>}
-     * @private
-     */
-    __output = null;
-
-    /**
-     *
-     * @param {CameraView} view
-     */
-    set view(view) {
-        this.__view = view;
-    }
-
-    /**
-     * @private
-     * @param {RenderLayer} layer
-     */
-    __processLayer(layer) {
-        if (!layer.state.visible) {
-            //whole layer is hidden
-
-            // layer.visibleSet.clear();
-            return;
-        }
-
-        this.__activeLayer = layer;
-
-        if (layer.managed) {
-
-            this.__output.pushOther(layer.visibleSet);
-
-            return;
-        }
-
-        const added_objects = layer.buildVisibleSet(scratch_array, 0, this.__view);
-
-        for (let i = 0; i < added_objects; i++) {
-            const object3d = scratch_array[i];
-
-            //object passed all filters, add it to visible set
-            this.__output.push(object3d);
-
-            this.__activeLayer.visibleSet.push(object3d);
-        }
-    }
-
-
-    /**
-     * @param {IncrementalDeltaSet<Object3D>} v
-     */
-    set output(v) {
-        this.__output = v;
-    }
-
-    /**
-     *
-     * @param {RenderLayerManager} renderLayers
-     */
-    build(renderLayers) {
-        renderLayers.traverse(this.__processLayer, this);
-    }
-}

package/src/engine/graphics/render/visibility/VisibilityFilter.d.ts

@@ -1,29 +0,0 @@
-export class VisibilityFilter {
-    constructor({ name, objectPredicateInitialize, objectPredicateFinalize, objectPredicateExecute, layerPredicate }: {
-        name: any;
-        objectPredicateInitialize?: typeof noop;
-        objectPredicateFinalize?: typeof noop;
-        objectPredicateExecute?: typeof returnTrue;
-        layerPredicate?: typeof returnTrue;
-    });
-    /**
-     *
-     * @type {boolean}
-     */
-    enabled: boolean;
-    /**
-     * @type {string}
-     */
-    name: string;
-    objectPredicateExecute: typeof returnTrue;
-    objectPredicateInitialize: typeof noop;
-    objectPredicateFinalize: typeof noop;
-    /**
-     *
-     * @type {function(RenderLayer): boolean}
-     */
-    layerPredicate: (arg0: RenderLayer) => boolean;
-}
-import { returnTrue } from "../../../../core/function/returnTrue.js";
-import { noop } from "../../../../core/function/noop.js";
-//# sourceMappingURL=VisibilityFilter.d.ts.map

package/src/engine/graphics/render/visibility/VisibilityFilter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"VisibilityFilter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/render/visibility/VisibilityFilter.js"],"names":[],"mappings":"AAIA;IAOI;;;;;;OAwBC;IA9BD;;;OAGG;IACH,SAFU,OAAO,CAEF;IAYX;;OAEG;IACH,MAFU,MAAM,CAEA;IAEhB,0CAAoD;IACpD,uCAA0D;IAC1D,qCAAsD;IAEtD;;;OAGG;IACH,uCAFiC,OAAO,CAEJ;CAE3C;2BAlC0B,yCAAyC;qBAD/C,mCAAmC"}

package/src/engine/graphics/render/visibility/VisibilityFilter.js

@@ -1,37 +0,0 @@
-import { assert } from "../../../../core/assert.js";
-import { noop } from "../../../../core/function/noop.js";
-import { returnTrue } from "../../../../core/function/returnTrue.js";
-
-export class VisibilityFilter {
-    /**
-     *
-     * @type {boolean}
-     */
-    enabled = true;
-
-    constructor({
-                    name,
-                    objectPredicateInitialize = noop,
-                    objectPredicateFinalize = noop,
-                    objectPredicateExecute = returnTrue,
-                    layerPredicate = returnTrue
-                }) {
-
-        assert.isString(name, 'name');
-
-        /**
-         * @type {string}
-         */
-        this.name = name;
-
-        this.objectPredicateExecute = objectPredicateExecute;
-        this.objectPredicateInitialize = objectPredicateInitialize;
-        this.objectPredicateFinalize = objectPredicateFinalize;
-
-        /**
-         *
-         * @type {function(RenderLayer): boolean}
-         */
-        this.layerPredicate = layerPredicate;
-    }
-}

package/src/engine/graphics3/animation/write_graph_playback.d.ts

@@ -1,24 +0,0 @@
-/**
- * Hand one graph's blend down to the renderer: what each of its clips weighs, and where each of the
- * audible ones is playing.
- *
- * **Time is written every frame and weight only when it moves.** The clock is the reason this
- * function exists — Shade can advance a clip itself and is never asked to, because the pose gameplay
- * reads and the pose on the screen have to be the same one (I-4) — while a graph sitting in one
- * state has the same weights it had last frame and there is nothing to say. `set_playback_weight`
- * and `set_time` both go through the clip table's upload dedupe, so a repeated value costs a
- * comparison rather than a transfer; skipping the unchanged weights is about not doing the read
- * either.
- *
- * A clip at zero weight has its time left alone. It contributes nothing wherever it is, and where it
- * is, is where the state that owns it stopped.
- *
- * @param {GPUAnimationManager} manager
- * @param {AnimationGraphController} controller
- * @param {Int32Array} clip_ids the manager's id for each of `controller.def.clipIndex`, in order
- * @param {Float32Array} written the weight each of those clips was last given; updated in place.
- * A value no weight can take — `-1` — is how a caller says it does not know, which is the case
- * after a renderer restart
- */
-export function write_graph_playback(manager: GPUAnimationManager, controller: AnimationGraphController, clip_ids: Int32Array, written: Float32Array): void;
-//# sourceMappingURL=write_graph_playback.d.ts.map

package/src/engine/graphics3/animation/write_graph_playback.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"write_graph_playback.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/animation/write_graph_playback.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,mHALW,UAAU,WACV,YAAY,QA2BtB"}

package/src/engine/graphics3/animation/write_graph_playback.js

@@ -1,48 +0,0 @@
-import { assert } from "../../../core/assert.js";
-
-/**
- * Hand one graph's blend down to the renderer: what each of its clips weighs, and where each of the
- * audible ones is playing.
- *
- * **Time is written every frame and weight only when it moves.** The clock is the reason this
- * function exists — Shade can advance a clip itself and is never asked to, because the pose gameplay
- * reads and the pose on the screen have to be the same one (I-4) — while a graph sitting in one
- * state has the same weights it had last frame and there is nothing to say. `set_playback_weight`
- * and `set_time` both go through the clip table's upload dedupe, so a repeated value costs a
- * comparison rather than a transfer; skipping the unchanged weights is about not doing the read
- * either.
- *
- * A clip at zero weight has its time left alone. It contributes nothing wherever it is, and where it
- * is, is where the state that owns it stopped.
- *
- * @param {GPUAnimationManager} manager
- * @param {AnimationGraphController} controller
- * @param {Int32Array} clip_ids the manager's id for each of `controller.def.clipIndex`, in order
- * @param {Float32Array} written the weight each of those clips was last given; updated in place.
- * A value no weight can take — `-1` — is how a caller says it does not know, which is the case
- * after a renderer restart
- */
-export function write_graph_playback(manager, controller, clip_ids, written) {
-    assert.defined(manager, 'manager');
-    assert.defined(controller, 'controller');
-
-    const weights = controller.blendState.weights;
-
-    assert.equal(clip_ids.length, weights.length, 'clip_ids.length');
-    assert.equal(written.length, weights.length, 'written.length');
-
-    for (let i = 0; i < weights.length; i++) {
-        const clip_id = clip_ids[i];
-        const weight = weights[i];
-
-        if (weight !== written[i]) {
-            manager.set_playback_weight(clip_id, weight);
-
-            written[i] = weight;
-        }
-
-        if (weight > 0) {
-            manager.set_time(clip_id, controller.clip_time(i));
-        }
-    }
-}

package/src/engine/graphics3/decal/DecalAtlasFill.js

@@ -1,32 +0,0 @@
-/**
- * How a decal atlas fills the border around a patch.
- *
- * Two rules rather than one, because the correct fill depends on what the channel means and getting
- * it wrong shows up only once the mip chain is built.
- *
- * @enum {number}
- */
-export const DecalAtlasFill = {
-    /**
-     * Colour weighted by coverage, and a gutter of nothing.
-     *
-     * The patch is stored **premultiplied** and its border is zero. Averaging that pair down a mip
-     * chain gives premultiplied colour times coverage at every level, which is what a decal fading
-     * out at its edge should look like. The same arrangement in *straight* alpha is where dark
-     * halos come from — an edge texel averaged against transparent black keeps its alpha and loses
-     * its colour — and straight alpha beside a zeroed gutter is exactly what the atlas this
-     * replaces has today.
-     */
-    PremultipliedCoverage: 0,
-
-    /**
-     * The nearest content texel, repeated outward.
-     *
-     * For channels that carry no coverage of their own — a normal, a roughness, a metalness — there
-     * is nothing to fade toward, and a zeroed gutter would drag a partially covered mip texel toward
-     * a meaningless value (a zero normal, mirror-smooth roughness). Coverage for these comes from
-     * the albedo's alpha, so their border repeats the edge and lets the mip chain average content
-     * against more of the same.
-     */
-    EdgeExtend: 1,
-};

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

@@ -1,49 +0,0 @@
-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_texel_coordinate_to_uv } from "../../shader/chunk/texture/chunk_texel_coordinate_to_uv.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { chunk_camera_ray_planar_depth_scale } from "../chunk_camera_ray_planar_depth_scale.js";
-import { chunk_volumetrics_froxel_content_offset } from "../chunk_volumetrics_froxel_content_offset.js";
-import { CAMERA_RESOURCE } from "../../camera/CAMERA_RESOURCE.js";
-import { VOLUMETRICS_METADATA_RESOURCE } from "../VOLUMETRICS_RESOURCES.js";
-
-/**
- * `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.from(
-    //language=WGSL
-    `
-fn volumetrics_froxel_centre_ws(voxel: vec3<u32>, resolution: vec3<u32>) -> vec3<f32> {
-    let curve = volumetrics_metadata.froxel_cluster_parameters;
-    let near_far = camera.clip_near_far;
-
-    let slice = f32(voxel.z) + volumetrics_froxel_content_offset(curve.z);
-    let view_depth = clamp(cluster_depth_from_z_slice(slice, curve, f32(resolution.z)), near_far.x, near_far.y);
-
-    let ray = camera_ray_from_uv(texel_coordinate_to_uv(vec2<f32>(voxel.xy), resolution.xy), camera);
-
-    // planar depth to a distance along the ray, as the lighting pass does
-    return ray.origin + ray.direction * (view_depth * camera_ray_planar_depth_scale(ray.direction, camera));
-}
-`, [
-        RAY_STRUCT.declaration_chunk,
-        chunk_volumetrics_froxel_content_offset,
-        chunk_cluster_depth_from_z_slice,
-        chunk_camera_ray_from_uv,
-        chunk_texel_coordinate_to_uv,
-        chunk_camera_ray_planar_depth_scale,
-    ]
-);
-
-chunk_volumetrics_froxel_centre_ws.requireResource(CAMERA_RESOURCE);
-chunk_volumetrics_froxel_centre_ws.requireResource(VOLUMETRICS_METADATA_RESOURCE);

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

@@ -1,50 +0,0 @@
-import {
-    METRO_L1_IRRADIANCE_STRUCT
-} from "../../shader/chunk/spherical_harmonics/l1i/chunk_convert_to_irradiance_sh.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { INDIRECT_LIGHT_INTENSITY } from "../../deferred/INDIRECT_LIGHT_INTENSITY.js";
-import { chunk_volumetrics_irradiance_sh } from "../chunk_volumetrics_irradiance_sh.js";
-import { VOLUMETRICS_GI_COCG_RESOURCE, VOLUMETRICS_GI_Y_RESOURCE } from "./volumetrics_gi_resources.js";
-
-/**
- * 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.from(
-    //language=WGSL
-    `
-fn volumetrics_gi_store(voxel: vec3<u32>, radiance: array<vec3<f32>, 4>) {
-    const INDIRECT_INTENSITY : f32 = ${INDIRECT_LIGHT_INTENSITY};
-
-    let scaled = array<vec3<f32>, 4>(
-        radiance[0] * INDIRECT_INTENSITY,
-        radiance[1] * INDIRECT_INTENSITY,
-        radiance[2] * INDIRECT_INTENSITY,
-        radiance[3] * INDIRECT_INTENSITY,
-    );
-
-    var sh: ${METRO_L1_IRRADIANCE_STRUCT.wgsl_ref};
-
-    let stored = volumetrics_irradiance_sh_storable(volumetrics_irradiance_sh_add_radiance(sh, scaled));
-
-    textureStore(tGIY, voxel, stored.Y);
-    textureStore(tGICoCg, voxel, vec4<f32>(stored.CoCg, 0.0, 0.0));
-}
-`, [
-        METRO_L1_IRRADIANCE_STRUCT.declaration_chunk,
-        chunk_volumetrics_irradiance_sh,
-    ]
-);
-
-chunk_volumetrics_gi.requireResource(VOLUMETRICS_GI_COCG_RESOURCE);
-chunk_volumetrics_gi.requireResource(VOLUMETRICS_GI_Y_RESOURCE);

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

@@ -1,105 +0,0 @@
-import { chunk_brick4_sample_sh } from "../../global_illumination/brick4/gpu/draw/chunk_brick4_sample_sh.js";
-import { INDIRECT_LIGHTING } from "../../INDIRECT_LIGHTING.js";
-import { ShadeIndirectLightingMode } from "../../ShadeIndirectLightingMode.js";
-import { chunk_lpv_mesh_interpolation_probe_sh } from "../../shader/chunk/light/lpv/chunk_lpv_mesh_interpolation_probe_sh.js";
-import { chunk_lpv_mesh_lookup_nearest_cell } from "../../shader/chunk/light/lpv/chunk_lpv_mesh_lookup_nearest_cell.js";
-import { INVALID_TET_DECLARATION } from "../../shader/chunk/light/lpv/INVALID_TET_DECLARATION.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { CodeChunkChoice } from "../../shader/compiler/CodeChunkChoice.js";
-import { chunk_volumetrics_froxel_centre_ws } from "./chunk_volumetrics_froxel_centre_ws.js";
-import { ENVIRONMENT_SH_RESOURCE } from "../../light/environment/ENVIRONMENT_SH_RESOURCE.js";
-
-/**
- * {@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.from(
-    //language=WGSL
-    `
-fn volumetrics_gi_sample(voxel: vec3<u32>, resolution: vec3<u32>) -> array<vec3<f32>, 4> {
-    return array<vec3<f32>, 4>(
-        environment_sh[0].xyz,
-        environment_sh[1].xyz,
-        environment_sh[2].xyz,
-        environment_sh[3].xyz,
-    );
-}
-`, []);
-
-chunk_volumetrics_gi_sample_ibl.requireResource(ENVIRONMENT_SH_RESOURCE);
-
-/**
- * {@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.from(
-    //language=WGSL
-    `
-fn volumetrics_gi_sample(voxel: vec3<u32>, resolution: vec3<u32>) -> array<vec3<f32>, 4> {
-    let position = volumetrics_froxel_centre_ws(voxel, resolution);
-
-    // A froxel has no surface. The normal only masks probes behind one, and a zero normal weighs
-    // every probe of the brick the same (brick4_probe_compute_weight_by_normal), which is the
-    // interpolation a point in open space wants.
-    let sh = brick4_sample_sh(position, vec3<f32>(0.0));
-
-    // SH3 to SH2: the first four coefficients are the same two bands, in the same order
-    return array<vec3<f32>, 4>(sh[0], sh[1], sh[2], sh[3]);
-}
-`, [
-    chunk_volumetrics_froxel_centre_ws,
-    chunk_brick4_sample_sh,
-]);
-
-/**
- * {@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.from(
-    //language=WGSL
-    `
-fn volumetrics_gi_sample(voxel: vec3<u32>, resolution: vec3<u32>) -> array<vec3<f32>, 4> {
-    let position = volumetrics_froxel_centre_ws(voxel, resolution);
-
-    var weights: vec4<f32>;
-    let tet = lpv_mesh_lookup_nearest_cell(position, &weights);
-
-    // Outside the probe mesh there is nothing to interpolate, and the deferred LPV pass gives such a
-    // point no indirect light either. No visibility mask: that needs a surface normal, and a froxel
-    // has none.
-    var radiance = array<vec3<f32>, 4>();
-
-    if (tet != INVALID_TET) {
-        radiance = lpv_mesh_interpolation_probe_sh(weights, tet);
-    }
-
-    return radiance;
-}
-`, [
-    chunk_volumetrics_froxel_centre_ws,
-    chunk_lpv_mesh_lookup_nearest_cell,
-    chunk_lpv_mesh_interpolation_probe_sh,
-    INVALID_TET_DECLARATION,
-]);
-
-/**
- * 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.from(INDIRECT_LIGHTING);
-
-chunk_volumetrics_gi_sample.add(ShadeIndirectLightingMode.IBL, chunk_volumetrics_gi_sample_ibl);
-chunk_volumetrics_gi_sample.add(ShadeIndirectLightingMode.Brick4, chunk_volumetrics_gi_sample_brick4);
-chunk_volumetrics_gi_sample.add(ShadeIndirectLightingMode.LPV, chunk_volumetrics_gi_sample_lpv);

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

@@ -1,80 +0,0 @@
-import { TextureResourceDescriptor } from "../../../device/graph/TextureResourceDescriptor.js";
-import { graph_compute_pass } from "../../shader/graph/compute/graph_compute_pass.js";
-import { graph_import_buffer } from "../../shader/graph/graph_import_buffer.js";
-import { ShaderSwitchSet } from "../../shader/compiler/ShaderSwitchSet.js";
-import { shader_volumetrics_gi } from "./shader_volumetrics_gi.js";
-import { VOLUMETRICS_GI_WORKGROUP_RESOLUTION } from "./volumetrics_gi_resources.js";
-
-/**
- * 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 = ShaderSwitchSet.EMPTY,
-                                          scene_ctx,
-                                          brick4,
-                                          lpv,
-                                          camera,
-                                          volumetrics_metadata,
-                                          resolution,
-                                      }) {
-    const volume = () => TextureResourceDescriptor.from({
-        resolution,
-        dimension: "3d",
-        format: "rgba16float",
-        usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING
-    });
-
-    const bindings = {
-        volumetrics_metadata,
-        camera: graph_import_buffer(graph, camera.buffer.buffer, "froxel gi camera"),
-        tGIY: volume(),
-        tGICoCg: volume(),
-        environment_sh: scene_ctx.lights.environment_sh,
-    };
-
-    // the running mode's source; the others are the shader's defaults, which its variant does not read
-    if (brick4 !== undefined) {
-        bindings.brick4 = brick4.buffer;
-    }
-
-    if (lpv !== undefined) {
-        bindings.lpv_lookup = lpv.buffer_mesh_bvh;
-        bindings.lpv_metadata = lpv.buffer_metadata;
-        bindings.lpv_mesh = lpv.buffer_mesh;
-        bindings.lpv_probes = lpv.buffer_probes;
-    }
-
-    const outputs = graph_compute_pass({
-        graph,
-        shader: shader_volumetrics_gi.variant(shader_switches),
-        group_count: [
-            Math.ceil(resolution[0] / VOLUMETRICS_GI_WORKGROUP_RESOLUTION[0]),
-            Math.ceil(resolution[1] / VOLUMETRICS_GI_WORKGROUP_RESOLUTION[1]),
-            Math.ceil(resolution[2] / VOLUMETRICS_GI_WORKGROUP_RESOLUTION[2]),
-        ],
-        bindings,
-    });
-
-    return {
-        Y: outputs.tGIY,
-        CoCg: outputs.tGICoCg,
-    };
-}

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

@@ -1,51 +0,0 @@
-import { BRICK4_DATA_STRUCT } from "../../global_illumination/brick4/gpu/BRICK4_DATA_STRUCT.js";
-import { LPV_SHADER_RESOURCE_GROUP_WITH_DEFAULTS } from "../../global_illumination/probe/octahedral/LPV_SHADER_RESOURCE_GROUP.js";
-import { ENVIRONMENT_SH_TYPE } from "../../light/environment/shader_project_environment_sh.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import { chunk_volumetrics_gi } from "./chunk_volumetrics_gi.js";
-import { chunk_volumetrics_gi_sample } from "./chunk_volumetrics_gi_sample.js";
-import { VOLUMETRICS_GI_WORKGROUP_RESOLUTION, volumetrics_gi_resource_group } from "./volumetrics_gi_resources.js";
-
-const resources = new ShaderResourceSetDescriptor();
-
-// every indirect lighting mode's source, whichever the variant reads (chunk_volumetrics_gi_sample). The pass
-// binds the environment and the running mode's source; the others have defaults the variant does not read.
-resources.addGroup(
-    volumetrics_gi_resource_group()
-        .addUniform("environment_sh", ENVIRONMENT_SH_TYPE)
-        .addStorageBuffer("brick4", BRICK4_DATA_STRUCT, false, true)
-);
-resources.addGroup(LPV_SHADER_RESOURCE_GROUP_WITH_DEFAULTS);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-@compute @workgroup_size(${VOLUMETRICS_GI_WORKGROUP_RESOLUTION.join(", ")})
-fn main(@builtin(global_invocation_id) voxel: vec3<u32>) {
-    let resolution = textureDimensions(tGIY);
-
-    if (any(voxel >= resolution)) {
-        return;
-    }
-
-    volumetrics_gi_store(voxel, volumetrics_gi_sample(voxel, resolution));
-}
-`, [
-    chunk_volumetrics_gi,
-    chunk_volumetrics_gi_sample,
-]);
-
-/**
- * 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.from({
-    label: "Volumetrics / GI",
-    resources,
-    body,
-});