@woosh/meep-engine 3.67.0 → 3.69.0

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_light.js

@@ -1,20 +1,13 @@
-import { MESH_SDF_BRICK_VOXELS } from "../../../geometry/sdf/MESH_SDF.js";
-import { chunk_light_cluster_counts } from "../../../light/cluster/chunk_light_cluster_counts.js";
 import { LIGHT_DATA_RESOURCE } from "../../../light/LIGHT_DATA_RESOURCE.js";
-import { LIGHT_DATABASE_SPEC } from "../../../light/LIGHT_DATABASE_SPEC.js";
-import { LIGHT_FLAGS } from "../../../light/model/io/LIGHT_FLAGS.js";
 import {
-    chunk_world_light_cluster_lookup_at,
     WORLD_CLUSTER_DATA_RESOURCE,
     WORLD_CLUSTER_LOOKUP_RESOURCE
 } from "../../../light/world_cluster/chunk_world_light_cluster_lookup.js";
-import { chunk_rgb_to_luminance } from "../../../shader/chunk/color/chunk_rgb_to_luminance.js";
 import { chunk_rgbe9995_decode } from "../../../shader/chunk/color/rgbe9995/chunk_rgbe9995_decode.js";
 import { chunk_rgbe9995_encode } from "../../../shader/chunk/color/rgbe9995/chunk_rgbe9995_encode.js";
 import {
     chunk_uv_octahedral_unit_decode
 } from "../../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_decode.js";
-import { chunk_sphere_sample_volume } from "../../../shader/chunk/geometry/sphere/chunk_sphere_sample_volume.js";
 import { chunk_folded_workgroup_index } from "../../../shader/chunk/grid/chunk_folded_workgroup_index.js";
 import { RECIPROCAL_PI_DECLARATION } from "../../../shader/chunk/math/RECIPROCAL_PI_DECLARATION.js";
 import { chunk_hash_to_float01 } from "../../../shader/chunk/random/chunk_hash_to_float01.js";
@@ -22,18 +15,13 @@ import { chunk_pcg4d } from "../../../shader/chunk/random/pcg/chunk_pcg4d.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
-import {
-    chunk_irradiance_clipmap_local_light
-} from "../../../volumetrics/irradiance_clipmap/chunk_irradiance_clipmap_local_light.js";
-import { IRRADIANCE_CLIPMAP_LIGHT_BUDGET } from "../../../volumetrics/irradiance_clipmap/IRRADIANCE_CLIPMAP.js";
 import { BRICK_TRACE_HIT } from "../brick/BRICK_CLIPMAP.js";
 import {
     BRICK_ATLAS_TEXTURE_RESOURCE,
     BRICK_LEVELS_RESOURCE,
     BRICK_MAP_TEXTURE_RESOURCE,
     BRICK_OCCUPANCY_TEXTURE_RESOURCE,
-    BRICK_SAMPLER_RESOURCE,
-    chunk_brick_clipmap_trace
+    BRICK_SAMPLER_RESOURCE
 } from "../brick/chunk_brick_clipmap_trace.js";
 import {
     chunk_probe_clipmap,
@@ -42,12 +30,10 @@ import {
     PROBE_RAYS_WRITE_RESOURCE,
     PROBE_TRACE_READ_RESOURCE
 } from "./chunk_probe_clipmap.js";
+import { chunk_probe_clipmap_local_irradiance } from "./chunk_probe_clipmap_hit_light.js";
 import { PROBE_THREAD_WORKGROUP_SIZE } from "./PROBE_CLIPMAP.js";
 import { PROBE_TRACE_SETTINGS } from "./shader_probe_clipmap_trace.js";
 
-const POINT = LIGHT_DATABASE_SPEC.get('light_point');
-const SPOT = LIGHT_DATABASE_SPEC.get('light_spot');
-
 const resources = new ShaderResourceSetDescriptor();
 
 resources.setImmediate("settings", PROBE_TRACE_SETTINGS);
@@ -73,21 +59,10 @@ resources.createGroup()
  * into its flags. It adds ρ_d·E_loc/π to the radiance shade left, ρ_d being the albedo shade left in the
  * ray's \`albedo\`; the next bounce, E_ind, is the bounce pass's, after it (`shader_probe_clipmap_bounce`).
  *
- * - **E_loc, the local lights**: one of the point and spot lights of the hit's cell of the world light
- *   clusters, built over the bricks' cascades so that every hit has one, at most
- *   `IRRADIANCE_CLIPMAP_LIGHT_BUDGET` of each; past them lights are dropped. Each light's unshadowed
- *   irradiance is the irradiance clipmap's, at the footprint of a voxel of the hit's cascade, by its
- *   cosine at the hit's normal.
- *   - One is picked by weighted reservoir sampling over the cell's lights, its weight the luminance of
- *     that irradiance, with one number stretched over the candidates as `sample_discrete_wrs` does; it
- *     lights the hit by its irradiance over the chance of its pick, w/W. The probe's blend of its rays
- *     averages the picks to the cell's sum.
- *   - The picked light's shadow is a ray traced through the brick clipmap, as the hit's own ray was:
- *     from a voxel off the surface, past the field's half-voxel expand, toward a point of the light's
- *     sphere drawn as the path tracer draws it, stopping short of that point by the light's near clip or
- *     a voxel, whichever is more, for the expand at that end. It sees the light if it misses; a hit, or a
- *     march that spends its steps, is no light. A light that casts no shadow traces none.
- *   - The pick and the point are drawn from the ray's slot and direction, fresh every update.
+ * - **E_loc, the local lights**: one of the hit's world light cluster cell's point and spot lights, picked by
+ *   weighted reservoir sampling and shadowed by a ray traced through the brick clipmap
+ *   (`probe_clipmap_local_irradiance`). The probe's blend of its rays averages the picks to the cell's sum.
+ * - The pick and the point are drawn from the ray's slot and direction, fresh every update.
  *
  * Its own pass because shade binds nine of a stage's ten storage buffers; apart from the bounce because the
  * two together would bind twelve storage buffers, and a shadow march is another cost than probe taps
@@ -101,114 +76,6 @@ export const shader_probe_clipmap_light = ComputeShader.from({
     body: CodeChunk.from(
         //language=WGSL
         `
-// E_loc at a front-face hit in brick cascade \`cascade\`: one of its world cluster cell's point and spot lights,
-// picked by \`random.x\` in proportion to its light at the hit and over the chance of its pick, shadowed by a ray
-// toward the point of the light's sphere \`random.yzw\` draws
-fn probe_clipmap_local_irradiance(cascade: u32, position: vec3<f32>, normal: vec3<f32>, random: vec4<f32>) -> vec3<f32> {
-    let level = brick_levels[cascade];
-    let voxel = level.cell_size / ${MESH_SDF_BRICK_VOXELS}.0;
-    let cell = world_light_cluster_metadata_at(cascade, level, 0.0, position);
-    let point_count = min(light_cluster_count_point(cell.counts), ${IRRADIANCE_CLIPMAP_LIGHT_BUDGET}u);
-    let spot_count = min(light_cluster_count_spot(cell.counts), ${IRRADIANCE_CLIPMAP_LIGHT_BUDGET}u);
-
-    // the cell's spot lights follow its point lights
-    let spots = cell.offset + light_cluster_count_point(cell.counts);
-
-    // the reservoir: the weights so far, and the light it holds
-    var u = random.x;
-    var total = 0.0;
-    var picked = vec3<f32>(0.0);
-    var picked_weight = 0.0;
-    var picked_index = 0u;
-    var picked_spot = false;
-
-    for (var j = 0u; j < point_count + spot_count; j++) {
-        let spot = j >= point_count;
-        let index = world_cluster_data[select(cell.offset + j, spots + (j - point_count), spot)];
-
-        var irradiance: vec3<f32>;
-
-        if (spot) {
-            let light = irradiance_clipmap_get_spot_light_info_by_index(&light_data, index, position, voxel);
-
-            irradiance = light.color * max(dot(normal, light.direction), 0.0);
-        } else {
-            let light = irradiance_clipmap_get_point_light_info_by_index(&light_data, index, position, voxel);
-
-            irradiance = light.color * max(dot(normal, light.direction), 0.0);
-        }
-
-        let weight = rgb_to_luminance(irradiance);
-
-        if (weight <= 0.0) {
-            continue;
-        }
-
-        // the light takes the reservoir by its share of the weights so far, and the number is stretched back
-        // over [0, 1) from whichever side of the share it fell
-        total += weight;
-
-        let share = weight / total;
-
-        if (u < share) {
-            u = u / share;
-            picked = irradiance;
-            picked_weight = weight;
-            picked_index = index;
-            picked_spot = spot;
-        } else {
-            u = (u - share) / (1.0 - share);
-        }
-    }
-
-    if (total <= 0.0) {
-        return vec3<f32>(0.0);
-    }
-
-    // the pick's light over the chance of the pick, w / W
-    let estimate = picked * (total / picked_weight);
-
-    var source: vec3<f32>;
-    var radius: f32;
-    var near_clip: f32;
-    var flags: u32;
-
-    if (picked_spot) {
-        let light = ${SPOT.marshalling_method_read}(&light_data, picked_index);
-
-        source = light.position;
-        radius = light.radius;
-        near_clip = light.near_clip_distance;
-        flags = light.flags;
-    } else {
-        let light = ${POINT.marshalling_method_read}(&light_data, picked_index);
-
-        source = light.position.xyz;
-        radius = light.radius;
-        near_clip = light.near_clip_distance;
-        flags = light.flags;
-    }
-
-    if ((flags & ${LIGHT_FLAGS.CASTS_SHADOW_BIT}u) == 0u) {
-        return estimate;
-    }
-
-    // from a voxel off the surface, past the half voxel the field's surface may sit off it, to a point of the
-    // light, short of it by the light's near clip or by a voxel for the expand at that end
-    let lifted = position + normal * voxel;
-    let to_light = source + radius * sphere_sample_volume(random.yzw) - lifted;
-    let span = length(to_light);
-    let reach = span - max(near_clip, voxel);
-
-    if (reach <= 0.0) {
-        return estimate;
-    }
-
-    let shadow = brick_clipmap_trace(lifted, to_light / span, 0.0, reach, settings.brick_cascade_count, settings.brick_atlas_shift);
-
-    return select(vec3<f32>(0.0), estimate, shadow.kind == BRICK_TRACE_MISS);
-}
-
 @compute @workgroup_size(${PROBE_THREAD_WORKGROUP_SIZE})
 fn main(
     @builtin(workgroup_id) workgroup_id: vec3<u32>,
@@ -236,7 +103,7 @@ fn main(
     let random = vec4<f32>(hash_to_float01(hash.x), hash_to_float01(hash.y), hash_to_float01(hash.z), hash_to_float01(hash.w));
 
     // E/π of the local lights
-    let e = probe_clipmap_local_irradiance((record.flags >> PROBE_RAY_CASCADE_SHIFT) & PROBE_RAY_CASCADE_MASK, position, normal, random) * RECIPROCAL_PI;
+    let e = probe_clipmap_local_irradiance((record.flags >> PROBE_RAY_CASCADE_SHIFT) & PROBE_RAY_CASCADE_MASK, position, normal, random, settings.brick_cascade_count, settings.brick_atlas_shift) * RECIPROCAL_PI;
 
     if (all(e == vec3<f32>(0.0))) {
         return;
@@ -250,16 +117,9 @@ fn main(
             chunk_folded_workgroup_index,
             chunk_uv_octahedral_unit_decode,
             RECIPROCAL_PI_DECLARATION,
-            chunk_world_light_cluster_lookup_at,
-            chunk_light_cluster_counts,
-            chunk_irradiance_clipmap_local_light,
-            chunk_rgb_to_luminance,
-            chunk_brick_clipmap_trace,
+            chunk_probe_clipmap_local_irradiance,
             chunk_pcg4d,
             chunk_hash_to_float01,
-            chunk_sphere_sample_volume,
-            POINT.chunk_read,
-            SPOT.chunk_read,
             chunk_rgbe9995_decode,
             chunk_rgbe9995_encode,
         ]),

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_trace.d.ts

@@ -18,15 +18,10 @@ export const PROBE_TRACE_SETTINGS: WebGPUStruct;
  *   rays of a round and kind are stratified inside it over the updates of that kind it takes them on.
  * - **Origin**: a point of a small ball around the probe where relocation left it, `probe_origins`, one a
  *   ray (`probe_clipmap_ray_origin`); t_min one voxel of the brick cascade there.
- * - **Direct light**: a hit off a front face takes E_dir = Σ colour·max(0, n·l)·visibility over the
- *   directional lights (§8.7). The visibility is a shadow ray, traced through the brick clipmap as the
- *   ray itself was, toward each of the first {@link PROBE_SHADOWED_SUNS} lights that cast shadows, in the
- *   table's order; lights past them are unshadowed at hits. It starts a voxel off the hit along its
- *   normal, outside the half-voxel expand, and heads for a point of the light's disk drawn as the path
- *   tracer draws it (`cone_sample_direction`), from the ray's slot and direction, so that the probe's
- *   blend of its rays integrates the penumbra. The light is seen whole if the ray misses, and not at all
- *   if it hits or spends its steps: what the march could not answer is no light, not all of it. A
- *   surface turned from a light traces no ray toward it, since the light gives it nothing.
+ * - **Direct light**: a hit off a front face takes E_dir over the directional lights, shadowed by rays
+ *   traced through the brick clipmap as the ray itself was (`probe_clipmap_sun_irradiance`, §8.7). Each
+ *   light's point of its disk is drawn from the ray's slot and direction, so that the probe's blend of its
+ *   rays integrates the penumbra.
  * - **Back face**: a hit whose field's gradient is along the ray, so it came from inside a solid.
  *
  * Writes the ray's `PROBE_RAY_STRUCT`, with E_dir as its light, which shade turns into the ray's

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_trace.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_trace.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_trace.js"],"names":[],"mappings":"AAkDA;;GAEG;AACH,mCAFU,YAAY,CAiBG;AAsBzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,yCAFU,aAAa,CAuJpB;6BAzP0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_trace.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_trace.js"],"names":[],"mappings":"AAyCA;;GAEG;AACH,mCAFU,YAAY,CAiBG;AAsBzB;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,yCAFU,aAAa,CAoHpB;6BAhN0B,sCAAsC;8BAHrC,kCAAkC"}

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_trace.js

@@ -1,9 +1,6 @@
 import { MESH_SDF_BRICK_VOXELS } from "../../../geometry/sdf/MESH_SDF.js";
 import { LIGHT_DATA_RESOURCE } from "../../../light/LIGHT_DATA_RESOURCE.js";
-import { LIGHT_DATABASE_SPEC } from "../../../light/LIGHT_DATABASE_SPEC.js";
-import { LIGHT_FLAGS } from "../../../light/model/io/LIGHT_FLAGS.js";
 import { chunk_rgbe9995_encode } from "../../../shader/chunk/color/rgbe9995/chunk_rgbe9995_encode.js";
-import { chunk_cone_sample_direction } from "../../../shader/chunk/geometry/cone/chunk_cone_sample_direction.js";
 import {
     chunk_uv_octahedral_unit_decode
 } from "../../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_decode.js";
@@ -11,11 +8,6 @@ import {
     chunk_uv_octahedral_unit_encode
 } from "../../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_encode.js";
 import { chunk_folded_workgroup_index } from "../../../shader/chunk/grid/chunk_folded_workgroup_index.js";
-import {
-    chunk_directional_lights_iteration_mask
-} from "../../../shader/chunk/light/io/chunk_directional_lights_iteration_mask.js";
-import { chunk_hash_to_float01 } from "../../../shader/chunk/random/chunk_hash_to_float01.js";
-import { chunk_pcg3d } from "../../../shader/chunk/random/pcg/chunk_pcg3d.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
@@ -44,9 +36,8 @@ import {
     PROBE_STATES_READ_RESOURCE,
     PROBE_TRACE_READ_RESOURCE
 } from "./chunk_probe_clipmap.js";
-import { PROBE_SHADOWED_SUNS, PROBE_THREAD_WORKGROUP_SIZE } from "./PROBE_CLIPMAP.js";
-
-const DIRECTIONAL = LIGHT_DATABASE_SPEC.get('light_directional');
+import { chunk_probe_clipmap_sun_irradiance } from "./chunk_probe_clipmap_hit_light.js";
+import { PROBE_THREAD_WORKGROUP_SIZE } from "./PROBE_CLIPMAP.js";
 
 /**
  * @type {WebGPUStruct}
@@ -104,15 +95,10 @@ resources.createGroup()
  *   rays of a round and kind are stratified inside it over the updates of that kind it takes them on.
  * - **Origin**: a point of a small ball around the probe where relocation left it, `probe_origins`, one a
  *   ray (`probe_clipmap_ray_origin`); t_min one voxel of the brick cascade there.
- * - **Direct light**: a hit off a front face takes E_dir = Σ colour·max(0, n·l)·visibility over the
- *   directional lights (§8.7). The visibility is a shadow ray, traced through the brick clipmap as the
- *   ray itself was, toward each of the first {@link PROBE_SHADOWED_SUNS} lights that cast shadows, in the
- *   table's order; lights past them are unshadowed at hits. It starts a voxel off the hit along its
- *   normal, outside the half-voxel expand, and heads for a point of the light's disk drawn as the path
- *   tracer draws it (`cone_sample_direction`), from the ray's slot and direction, so that the probe's
- *   blend of its rays integrates the penumbra. The light is seen whole if the ray misses, and not at all
- *   if it hits or spends its steps: what the march could not answer is no light, not all of it. A
- *   surface turned from a light traces no ray toward it, since the light gives it nothing.
+ * - **Direct light**: a hit off a front face takes E_dir over the directional lights, shadowed by rays
+ *   traced through the brick clipmap as the ray itself was (`probe_clipmap_sun_irradiance`, §8.7). Each
+ *   light's point of its disk is drawn from the ray's slot and direction, so that the probe's blend of its
+ *   rays integrates the penumbra.
  * - **Back face**: a hit whose field's gradient is along the ray, so it came from inside a solid.
  *
  * Writes the ray's `PROBE_RAY_STRUCT`, with E_dir as its light, which shade turns into the ray's
@@ -208,39 +194,8 @@ fn main(
     var direct = vec3<f32>(0.0);
 
     if (is_hit && !back_face) {
-        let voxel = brick_levels[hit.cascade].cell_size / ${MESH_SDF_BRICK_VOXELS}.0;
-        let lifted = hit.position + voxel * hit.normal;
-
-        var bits = directional_lights_iteration_mask(&light_data);
-        var shadowed = 0u;
-
-        while (bits != 0u) {
-            let index = countTrailingZeros(bits);
-
-            bits &= ~(1u << index);
-
-            let light = ${DIRECTIONAL.marshalling_method_read}(&light_data, index);
-            let n_dot_l = dot(hit.normal, -light.direction);
-
-            var visible = 1.0;
-
-            if ((light.flags & ${LIGHT_FLAGS.CASTS_SHADOW_BIT}u) != 0u && shadowed < ${PROBE_SHADOWED_SUNS}u) {
-                // a surface turned from the light takes none of it whatever the shadow, so it traces none;
-                // the light keeps its place among the shadowed all the same
-                if (n_dot_l > 0.0) {
-                    // a point of the disk of its own for each light, apart from the origin's draw
-                    let hash = pcg3d(vec3<u32>(slot, packed, 0x3C6EF372u + shadowed));
-                    let toward = cone_sample_direction(-light.direction, light.disk_radius, vec2<f32>(hash_to_float01(hash.x), hash_to_float01(hash.y)));
-                    let shadow = brick_clipmap_trace(lifted, toward, 0.0, settings.t_max, cascade_count, settings.brick_atlas_shift);
-
-                    visible = select(0.0, 1.0, shadow.kind == BRICK_TRACE_MISS);
-                }
-
-                shadowed++;
-            }
-
-            direct += light.color * max(n_dot_l, 0.0) * visible;
-        }
+        // each light's point of its disk drawn from the ray's slot and direction, apart from the origin's draw
+        direct = probe_clipmap_sun_irradiance(hit.position, hit.normal, hit.cascade, vec2<u32>(slot, packed), settings.t_max, cascade_count, settings.brick_atlas_shift);
     }
 
     probe_rays[ray].t = hit.t;
@@ -262,11 +217,7 @@ fn main(
             chunk_uv_octahedral_unit_decode,
             chunk_uv_octahedral_unit_encode,
             chunk_brick_clipmap_trace,
-            chunk_cone_sample_direction,
-            chunk_pcg3d,
-            chunk_hash_to_float01,
-            chunk_directional_lights_iteration_mask,
+            chunk_probe_clipmap_sun_irradiance,
             chunk_rgbe9995_encode,
-            DIRECTIONAL.chunk_read,
         ]),
 });

package/src/shade/renderer/global_illumination/screen_probe/GPUScreenProbeGI.d.ts

@@ -0,0 +1,142 @@
+/**
+ * {@link ShadeIndirectLightingMode.ScreenProbes} for one view: Lumen's screen probe gather, over the world the probe
+ * clipmap holds (`GPUProbeClipmapGI`): its bricks, which rays traverse, its surface material, which hits read, its
+ * world light clusters, and its two sets of world-space probes, which stand in for what lies past a screen probe's reach
+ * and give a hit its next bounce.
+ *
+ * **A frame**, in three passes and a capture:
+ * 1. **Place** ({@link graph_update}): a uniform probe in every tile of `downsample_factor` pixels at the frame's
+ *    jitter, then the adaptive levels, finest last, each placing a probe where the probes so far would not
+ *    interpolate to a point of its grid; then the commands over the frame's probes.
+ * 2. **Trace**, after the world's bricks: each probe's world-space pick, reach and brick origin (and the world probes
+ *    it wants); its BRDF and lighting densities and its rays, reassigned to where its light is; the screen trace; the
+ *    bricks' trace, shade, local light and bounce of what the screen left; the hits' wants; the composite into each
+ *    probe's radiance, the spatial filter's passes, and the probes' SH3.
+ * 3. **Resolve** ({@link graph_resolve}), once the bent normals exist: each pixel's irradiance from its probes, then
+ *    the temporal filter into the frame's diffuse, which the deferred passes read.
+ * 4. **Capture** ({@link graph_capture}): the lit colour of the opaque surfaces, for the next frame's screen hits.
+ *
+ * **Its history**: last frame's probes (their records and filtered radiance, for the lighting density), its diffuse
+ * and frames (for the temporal filter) and its colour (for the screen hits) are kept while the structure and the view
+ * stay, until {@link reset_history}; any change starts it again. Nothing is allocated on a frame that changes neither: the adaptive probes' slots
+ * are made with the rest, as many as the uniform probes (`screen_probe_adaptive_capacity`), and a frame that would
+ * place more places no more.
+ */
+export class GPUScreenProbeGI {
+    /**
+     * @param {GPUDevice} device
+     */
+    constructor(device: GPUDevice);
+    /**
+     * Drop the history: the next frame takes nothing from the frames before it, as a first frame does. For a cut, or a
+     * change of scene or lighting the temporal filters must not blend across (`Renderer#indicate_view_change`).
+     */
+    reset_history(): void;
+    /**
+     * @returns {boolean} whether its resources stand: a frame of the mode has run and not been left since
+     */
+    get built(): boolean;
+    /**
+     * @returns {number} uniform probes this frame's structure places
+     */
+    get uniform_count(): number;
+    /**
+     * @returns {number} adaptive probe slots
+     */
+    get adaptive_capacity(): number;
+    /**
+     * Take the frame's placement and traces, after the world's update ({@link GPUProbeClipmapGI#graph_update}) in the
+     * same frame: make the resources for the view and the structure the settings describe, unless they already are,
+     * and record the place and trace passes. {@link graph_resolve} follows once the bent normals exist.
+     *
+     * @param {Object} options
+     * @param {FrameGraph} options.graph
+     * @param {GPUViewContext} options.view
+     * @param {ScreenProbeSettings} options.settings
+     * @param {GPUProbeClipmapGI} options.world the probe clipmap GI, updated this frame: the bricks, material, light
+     *   clusters and world-space probes the screen probes trace and read
+     * @param {*} options.stbn the 2-channel spatio-temporal blue noise, `STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2`
+     * @param {number} options.depth graph handle of the view's reverse-Z depth
+     * @param {number} options.normal graph handle of the G-buffer's shading normals
+     * @param {number} options.pbr graph handle of the G-buffer's PBR target, which holds the face normal
+     * @param {number} options.velocity graph handle of the frame's motion, internal pixels
+     * @param {number} options.occlusion graph handle of the TAA's history confidence (`shader_depth_occlusion_clip`)
+     * @param {number} options.hzb graph handle of the view's hierarchical Z buffer, from mip 1
+     * @param {number} options.exposure graph handle of the factor the display multiplies radiance by, as the last frame
+     *   was shown
+     */
+    graph_update({ graph, view, settings, world, stbn, depth, normal, pbr, velocity, occlusion, hzb, exposure }: {
+        graph: FrameGraph;
+        view: GPUViewContext;
+        settings: ScreenProbeSettings;
+        world: GPUProbeClipmapGI;
+        stbn: any;
+        depth: number;
+        normal: number;
+        pbr: number;
+        velocity: number;
+        occlusion: number;
+        hzb: number;
+        exposure: number;
+    }): void;
+    /**
+     * Take the frame's resolve, once the bent normals exist: each pixel's irradiance from its probes, then the temporal
+     * filter into the frame's diffuse.
+     *
+     * @param {Object} options
+     * @param {FrameGraph} options.graph
+     * @param {number} options.depth graph handle of the view's reverse-Z depth
+     * @param {number} options.depth_previous graph handle of last frame's
+     * @param {number} options.pbr graph handle of the G-buffer's PBR target
+     * @param {number} options.velocity graph handle of the frame's motion
+     * @param {number} options.bent_normals graph handle of the bent normals (the shading normals where GTAO is off)
+     * @param {number} options.exposure graph handle of the factor the display multiplies radiance by, as the last frame
+     *   was shown, the one {@link graph_update} took: what the probes' radiance is pre-exposed by
+     * @returns {number} graph handle of the frame's diffuse, `rgba16float`: E at the bent normal, before AO
+     */
+    graph_resolve({ graph, depth, depth_previous, pbr, velocity, bent_normals, exposure }: {
+        graph: FrameGraph;
+        depth: number;
+        depth_previous: number;
+        pbr: number;
+        velocity: number;
+        bent_normals: number;
+        exposure: number;
+    }): number;
+    /**
+     * @returns {number} graph handle of the diffuse this frame's {@link graph_resolve} wrote
+     */
+    get diffuse_handle(): number;
+    /**
+     * Put what the debug views read of the frame's probes into `bindings`: the frame uniform, the probes and their
+     * tiles' adaptive lists, the integration's output and the rays' hit words, as this frame left them.
+     *
+     * @param {Object} bindings
+     * @returns {Object} bindings
+     */
+    write_debug_bindings(bindings: any): any;
+    /**
+     * Keep the frame's lit colour of the opaque surfaces for the next frame's screen hits: once the indirect light is
+     * added, before fog and transparencies.
+     *
+     * @param {Object} options
+     * @param {FrameGraph} options.graph
+     * @param {number} options.color graph handle of the scene's colour, the view's size
+     */
+    graph_capture({ graph, color }: {
+        graph: FrameGraph;
+        color: number;
+    }): void;
+    /**
+     * Give back every resource, as on the first frame out of the mode: the next {@link graph_update} starts again
+     * from nothing.
+     */
+    release(): void;
+    destroy(): void;
+    #private;
+}
+export type FrameGraph = import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+export type GPUViewContext = import("../../view/GPUViewContext.js").GPUViewContext;
+export type ScreenProbeSettings = import("./ScreenProbeSettings.js").ScreenProbeSettings;
+export type GPUProbeClipmapGI = import("../probe_clipmap/GPUProbeClipmapGI.js").GPUProbeClipmapGI;
+//# sourceMappingURL=GPUScreenProbeGI.d.ts.map

package/src/shade/renderer/global_illumination/screen_probe/GPUScreenProbeGI.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GPUScreenProbeGI.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/screen_probe/GPUScreenProbeGI.js"],"names":[],"mappings":"AAqEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IAsHI;;OAEG;IACH,+BAIC;IAED;;;OAGG;IACH,sBAEC;IAED;;OAEG;IACH,qBAEC;IAED;;OAEG;IACH,4BAEC;IAED;;OAEG;IACH,gCAEC;IAiBD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH;QAf+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACe,QAAQ,EAArC,mBAAmB;QACQ,KAAK,EAAhC,iBAAiB;QAEN,IAAI;QACC,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;QACU,GAAG,EAAnB,MAAM;QACU,QAAQ,EAAxB,MAAM;QACU,SAAS,EAAzB,MAAM;QACU,GAAG,EAAnB,MAAM;QACU,QAAQ,EAAxB,MAAM;aAoFhB;IAED;;;;;;;;;;;;;;OAcG;IACH;QAV+B,KAAK,EAAzB,UAAU;QACM,KAAK,EAArB,MAAM;QACU,cAAc,EAA9B,MAAM;QACU,GAAG,EAAnB,MAAM;QACU,QAAQ,EAAxB,MAAM;QACU,YAAY,EAA5B,MAAM;QACU,QAAQ,EAAxB,MAAM;QAEJ,MAAM,CAqBlB;IAED;;OAEG;IACH,6BAEC;IAED;;;;;;OAMG;IACH,yCASC;IAED;;;;;;;OAOG;IACH;QAH+B,KAAK,EAAzB,UAAU;QACM,KAAK,EAArB,MAAM;aAWhB;IA6bD;;;OAGG;IACH,gBA+BC;IAED,gBAQC;;CACJ;yBAh3BY,OAAO,8DAA8D,EAAE,UAAU;6BACjF,OAAO,8BAA8B,EAAE,cAAc;kCACrD,OAAO,0BAA0B,EAAE,mBAAmB;gCACtD,OAAO,uCAAuC,EAAE,iBAAiB"}