@woosh/meep-engine 3.65.0 → 3.68.0

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

@@ -0,0 +1,192 @@
+/**
+ * @param {number} downsample_factor
+ * @param {number} adaptive_min_downsample_factor
+ * @returns {number} levels of adaptive placement: at half the downsample factor, a quarter, and so on while the spacing
+ *   is at least the minimum
+ */
+export function screen_probe_adaptive_levels(downsample_factor: number, adaptive_min_downsample_factor: number): number;
+/**
+ * @param {number} levels of adaptive placement
+ * @returns {number} the most adaptive probes a tile can hold: each level's grid points in the tile that no coarser
+ *   level holds, 3·4^(l−1) at level l, 4^levels − 1 over them all
+ */
+export function screen_probe_adaptive_tile_capacity(levels: number): number;
+/**
+ * @param {number} uniform_count uniform probes
+ * @param {number} levels of adaptive placement
+ * @returns {number} adaptive probe slots: as many as the uniform probes, Lumen's `AdaptiveProbeAllocationFraction` at
+ *   one (half there), so a frame's probes are never more than twice the uniform ones however finely the view's depth
+ *   breaks up; none without adaptive levels
+ */
+export function screen_probe_adaptive_capacity(uniform_count: number, levels: number): number;
+/**
+ * Threads of a pass that runs a thread an item: a probe, a ray, a texel.
+ * @type {number}
+ */
+export const SCREEN_PROBE_THREAD_WORKGROUP_SIZE: number;
+/**
+ * Side of a 2-D pass's workgroup, in tiles or pixels: 8 × 8 of them.
+ * @type {number}
+ */
+export const SCREEN_PROBE_TILE_WORKGROUP_SIZE: number;
+/**
+ * Bits of a ray's id that hold its slot among its probe's rays; the rest hold the probe. A probe casts n² rays, so
+ * n² is at most 2⁸.
+ * @type {number}
+ */
+export const SCREEN_PROBE_RAY_SLOT_BITS: number;
+/**
+ * The largest octahedron a probe can have, n = 16: n² is the ray slots {@link SCREEN_PROBE_RAY_SLOT_BITS} name, and
+ * one probe's texels are what a workgroup sorts and accumulates in its memory. At 16, the ray sort holds 2·n² pairs of
+ * words (4 KiB) and the composite five words a texel (5 KiB), inside WebGPU's guaranteed 16 KiB of workgroup storage
+ * with the rest of either pass; 32 would need 20 KiB for the composite alone.
+ * @type {number}
+ */
+export const SCREEN_PROBE_OCTAHEDRON_LIMIT: number;
+/**
+ * The smallest octahedron a probe can have, n = 4, the bottom of Lumen's range for it (4 to 16).
+ * @type {number}
+ */
+export const SCREEN_PROBE_OCTAHEDRON_MINIMUM: number;
+/**
+ * The plane weight's scale, Lumen's: a probe weighs `exp2(−k·r²)`, r its distance from the receiver's plane over the
+ * receiver's depth. ½ at r = 1%, 0.01 at r ≈ 2.6%.
+ * @type {number}
+ */
+export const SCREEN_PROBE_PLANE_WEIGHT_SCALE: number;
+/**
+ * A corner weighing no more than this is no corner, Lumen's: interpolation looks for an adaptive probe in its place,
+ * and a sum of weights under this is no light (the pixel is the temporal filter's to fill).
+ * @type {number}
+ */
+export const SCREEN_PROBE_WEIGHT_EPSILON: number;
+/**
+ * Lumen's plane weight scale for the integration's jitter: a pixel's lookup moves only onto a pixel this coplanar
+ * with it, weight 0.01 at r ≈ 0.26%.
+ * @type {number}
+ */
+export const SCREEN_PROBE_JITTER_PLANE_WEIGHT_SCALE: number;
+/**
+ * A pixel around a probe adds its cosine lobe to the probe's BRDF while the probe's plane weight from it is past
+ * this, Lumen's: r under 1.8% of the probe's depth.
+ * @type {number}
+ */
+export const SCREEN_PROBE_BRDF_PIXEL_WEIGHT: number;
+/**
+ * Lumen's `MinPDFToTrace`. A texel whose density, its BRDF's times its light's (times n²), is under this gives its ray
+ * away. One any of whose directions the BRDF density reaches this is held at it (`screen_probe_brdf_keeps`), so the
+ * light ranks what the pixels' lobes keep and culls none of it; a texel the lobes do not keep stays where its light is
+ * bright enough to lift it.
+ * @type {number}
+ */
+export const SCREEN_PROBE_MIN_PDF: number;
+/**
+ * Frames the uniform probes' place in their tiles cycles over, a Hammersley set of points across the tile, as
+ * Lumen's `GetScreenTileJitter` does.
+ * @type {number}
+ */
+export const SCREEN_PROBE_JITTER_PERIOD: number;
+/**
+ * The most a ray's radiance may hold, in the display's units (radiance times the exposure it was last shown at),
+ * Lumen's `MaxRayIntensity`: the composite holds each ray to it, the fireflies of a sun glint or an emissive seen
+ * through a crack, and its fixed-point sums are scaled by it.
+ * @type {number}
+ */
+export const SCREEN_PROBE_MAX_RAY_INTENSITY: number;
+/**
+ * Steps of a screen trace through the depth buffer's hierarchy, Lumen's `HZBTraversal.MaxIterations`: a budget for
+ * one thread. A ray that spends them is a miss of the screen, which the bricks take on from where it got.
+ * @type {number}
+ */
+export const SCREEN_PROBE_SCREEN_TRACE_STEPS: number;
+/**
+ * How far behind the depth buffer a screen trace still counts as on the surface, as a share of the surface's depth,
+ * Lumen's `HZBTraversal.RelativeDepthThickness`.
+ * @type {number}
+ */
+export const SCREEN_PROBE_SCREEN_THICKNESS: number;
+/**
+ * The share of the screen, along each side, over which a screen hit fades to a miss, Lumen's: from 80% of the way
+ * from the centre to the edge, in screen position.
+ * @type {number}
+ */
+export const SCREEN_PROBE_SCREEN_EDGE: number;
+/**
+ * How far past its probe a ray is traced before the world-space probes answer for the rest, in spacings of the
+ * cascade the probe reads them from: the furthest a corner probe of its cage stands from the point it serves,
+ * relocation included, `PROBE_DEPTH_LIMIT`. Past it the ray has left every corner's cage, as Lumen's rays leave a
+ * cell's diagonal before its radiance cache takes them.
+ * @type {number}
+ */
+export const SCREEN_PROBE_REACH_SPACINGS: number;
+/**
+ * Pushes along the bricks' field a probe's brick origin takes at most, as the probe clipmap's relocation takes three:
+ * on a plane the first lands at the clearance, and the others carry it past a corner's second face or a curved field.
+ * @type {number}
+ */
+export const SCREEN_PROBE_ORIGIN_STEPS: number;
+/**
+ * A ray hit something moving when the speeds of its hit and its probe differ by more than this share of the probe's
+ * depth, held to a metre from below, Lumen's `RelativeSpeedDifferenceToConsiderLightingMoving`.
+ * @type {number}
+ */
+export const SCREEN_PROBE_MOVING_SPEED: number;
+/**
+ * The temporal filter's history at a pixel is another surface when its depth differs from the one reprojected there
+ * by this share of the depth, dithered over ×½ to ×1½ and widened at grazing angles, Lumen's
+ * `Temporal.DistanceThreshold`.
+ * @type {number}
+ */
+export const SCREEN_PROBE_TEMPORAL_DISTANCE: number;
+/**
+ * Lumen's fast update: the share of a pixel's light seen moving at which it takes its new light whole, and the most of
+ * its history the fast update ever drops.
+ * @type {number}
+ */
+export const SCREEN_PROBE_FAST_UPDATE_MOVING: number;
+export const SCREEN_PROBE_FAST_UPDATE_LIMIT: 0.9;
+/**
+ * How a probe's ray ended, the low bits of its hit word.
+ * - PENDING: the screen could not answer; the bricks will.
+ * - SCREEN: a hit in the screen, lit by the last frame's colour.
+ * - HIT: a front face in the bricks.
+ * - BACK: a back face in the bricks: inside a solid.
+ * - FAR: nothing within its reach; the world-space probes' radiance past it.
+ * - SKY: nothing within the world, or no world probe around: the environment.
+ * - UNRESOLVED: the bricks' march spent its steps; no light.
+ * - NONE: no ray: the probe stands on no surface.
+ */
+export const SCREEN_PROBE_TRACE_PENDING: 0;
+export const SCREEN_PROBE_TRACE_SCREEN: 1;
+export const SCREEN_PROBE_TRACE_HIT: 2;
+export const SCREEN_PROBE_TRACE_BACK: 3;
+export const SCREEN_PROBE_TRACE_FAR: 4;
+export const SCREEN_PROBE_TRACE_SKY: 5;
+export const SCREEN_PROBE_TRACE_UNRESOLVED: 6;
+export const SCREEN_PROBE_TRACE_NONE: 7;
+export const SCREEN_PROBE_TRACE_KIND_MASK: 7;
+/**
+ * Set in a hit word when the ray hit something moving relative to its probe.
+ * @type {number}
+ */
+export const SCREEN_PROBE_TRACE_MOVING: number;
+/**
+ * Word offsets of the commands and counts one pass writes for the passes after it, `screen_probe_dispatch`: a
+ * workgroup a probe, a thread a probe, a thread a ray, a thread a ray left to the bricks, each three words of a
+ * folded dispatch; then the frame's probes, and its rays left to the bricks.
+ */
+export const SCREEN_PROBE_DISPATCH_PROBES: 0;
+export const SCREEN_PROBE_DISPATCH_THREADS: 3;
+export const SCREEN_PROBE_DISPATCH_RAYS: 6;
+export const SCREEN_PROBE_DISPATCH_BRICK_RAYS: 9;
+export const SCREEN_PROBE_DISPATCH_PROBE_COUNT: 12;
+export const SCREEN_PROBE_DISPATCH_BRICK_RAY_COUNT: 13;
+export const SCREEN_PROBE_DISPATCH_WORDS: 16;
+/**
+ * Word offsets of the frame's atomic counters, `screen_probe_counters`: adaptive probes placed, which may run past
+ * their slots and is held to them where read; rays left to the bricks.
+ */
+export const SCREEN_PROBE_COUNTER_ADAPTIVE: 0;
+export const SCREEN_PROBE_COUNTER_BRICK_RAYS: 1;
+export const SCREEN_PROBE_COUNTER_WORDS: 4;
+//# sourceMappingURL=SCREEN_PROBE.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SCREEN_PROBE.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/screen_probe/SCREEN_PROBE.js"],"names":[],"mappings":"AAoMA;;;;;GAKG;AACH,gEALW,MAAM,kCACN,MAAM,GACJ,MAAM,CAWlB;AAED;;;;GAIG;AACH,4DAJW,MAAM,GACJ,MAAM,CAKlB;AAED;;;;;;GAMG;AACH,8DANW,MAAM,UACN,MAAM,GACJ,MAAM,CAMlB;AApOD;;;GAGG;AACH,iDAFU,MAAM,CAEqC;AAErD;;;GAGG;AACH,+CAFU,MAAM,CAEkC;AAElD;;;;GAIG;AACH,yCAFU,MAAM,CAE4B;AAE5C;;;;;;GAMG;AACH,4CAFU,MAAM,CAEgC;AAEhD;;;GAGG;AACH,8CAFU,MAAM,CAEiC;AAEjD;;;;GAIG;AACH,8CAFU,MAAM,CAEqC;AAErD;;;;GAIG;AACH,0CAFU,MAAM,CAEgC;AAEhD;;;;GAIG;AACH,qDAFU,MAAM,CAE8C;AAE9D;;;;GAIG;AACH,6CAFU,MAAM,CAEkC;AAElD;;;;;;GAMG;AACH,mCAFU,MAAM,CAEwB;AAExC;;;;GAIG;AACH,yCAFU,MAAM,CAE4B;AAE5C;;;;;GAKG;AACH,6CAFU,MAAM,CAEiC;AAEjD;;;;GAIG;AACH,8CAFU,MAAM,CAEkC;AAElD;;;;GAIG;AACH,4CAFU,MAAM,CAEkC;AAElD;;;;GAIG;AACH,uCAFU,MAAM,CAE4B;AAE5C;;;;;;GAMG;AACH,0CAFU,MAAM,CAE6C;AAE7D;;;;GAIG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;;GAIG;AACH,wCAFU,MAAM,CAE+B;AAE/C;;;;;GAKG;AACH,6CAFU,MAAM,CAEoC;AAEpD;;;;GAIG;AACH,8CAFU,MAAM,CAEmC;AACnD,iDAAkD;AAElD;;;;;;;;;;GAUG;AACH,2CAA4C;AAC5C,0CAA2C;AAC3C,uCAAwC;AACxC,wCAAyC;AACzC,uCAAwC;AACxC,uCAAwC;AACxC,8CAA+C;AAC/C,wCAAyC;AACzC,6CAA8C;AAE9C;;;GAGG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;;GAIG;AACH,6CAA8C;AAC9C,8CAA+C;AAC/C,2CAA4C;AAC5C,iDAAkD;AAClD,mDAAoD;AACpD,uDAAwD;AACxD,6CAA8C;AAE9C;;;GAGG;AACH,8CAA+C;AAC/C,gDAAiD;AACjD,2CAA4C"}

package/src/shade/renderer/global_illumination/screen_probe/SCREEN_PROBE.js

@@ -0,0 +1,231 @@
+import { PROBE_DEPTH_LIMIT } from "../probe_clipmap/probe/PROBE_CLIPMAP.js";
+
+/**
+ * Threads of a pass that runs a thread an item: a probe, a ray, a texel.
+ * @type {number}
+ */
+export const SCREEN_PROBE_THREAD_WORKGROUP_SIZE = 64;
+
+/**
+ * Side of a 2-D pass's workgroup, in tiles or pixels: 8 × 8 of them.
+ * @type {number}
+ */
+export const SCREEN_PROBE_TILE_WORKGROUP_SIZE = 8;
+
+/**
+ * Bits of a ray's id that hold its slot among its probe's rays; the rest hold the probe. A probe casts n² rays, so
+ * n² is at most 2⁸.
+ * @type {number}
+ */
+export const SCREEN_PROBE_RAY_SLOT_BITS = 8;
+
+/**
+ * The largest octahedron a probe can have, n = 16: n² is the ray slots {@link SCREEN_PROBE_RAY_SLOT_BITS} name, and
+ * one probe's texels are what a workgroup sorts and accumulates in its memory. At 16, the ray sort holds 2·n² pairs of
+ * words (4 KiB) and the composite five words a texel (5 KiB), inside WebGPU's guaranteed 16 KiB of workgroup storage
+ * with the rest of either pass; 32 would need 20 KiB for the composite alone.
+ * @type {number}
+ */
+export const SCREEN_PROBE_OCTAHEDRON_LIMIT = 16;
+
+/**
+ * The smallest octahedron a probe can have, n = 4, the bottom of Lumen's range for it (4 to 16).
+ * @type {number}
+ */
+export const SCREEN_PROBE_OCTAHEDRON_MINIMUM = 4;
+
+/**
+ * The plane weight's scale, Lumen's: a probe weighs `exp2(−k·r²)`, r its distance from the receiver's plane over the
+ * receiver's depth. ½ at r = 1%, 0.01 at r ≈ 2.6%.
+ * @type {number}
+ */
+export const SCREEN_PROBE_PLANE_WEIGHT_SCALE = 10000;
+
+/**
+ * A corner weighing no more than this is no corner, Lumen's: interpolation looks for an adaptive probe in its place,
+ * and a sum of weights under this is no light (the pixel is the temporal filter's to fill).
+ * @type {number}
+ */
+export const SCREEN_PROBE_WEIGHT_EPSILON = 0.01;
+
+/**
+ * Lumen's plane weight scale for the integration's jitter: a pixel's lookup moves only onto a pixel this coplanar
+ * with it, weight 0.01 at r ≈ 0.26%.
+ * @type {number}
+ */
+export const SCREEN_PROBE_JITTER_PLANE_WEIGHT_SCALE = 1000000;
+
+/**
+ * A pixel around a probe adds its cosine lobe to the probe's BRDF while the probe's plane weight from it is past
+ * this, Lumen's: r under 1.8% of the probe's depth.
+ * @type {number}
+ */
+export const SCREEN_PROBE_BRDF_PIXEL_WEIGHT = 0.1;
+
+/**
+ * Lumen's `MinPDFToTrace`. A texel whose density, its BRDF's times its light's (times n²), is under this gives its ray
+ * away. One any of whose directions the BRDF density reaches this is held at it (`screen_probe_brdf_keeps`), so the
+ * light ranks what the pixels' lobes keep and culls none of it; a texel the lobes do not keep stays where its light is
+ * bright enough to lift it.
+ * @type {number}
+ */
+export const SCREEN_PROBE_MIN_PDF = 0.1;
+
+/**
+ * Frames the uniform probes' place in their tiles cycles over, a Hammersley set of points across the tile, as
+ * Lumen's `GetScreenTileJitter` does.
+ * @type {number}
+ */
+export const SCREEN_PROBE_JITTER_PERIOD = 8;
+
+/**
+ * The most a ray's radiance may hold, in the display's units (radiance times the exposure it was last shown at),
+ * Lumen's `MaxRayIntensity`: the composite holds each ray to it, the fireflies of a sun glint or an emissive seen
+ * through a crack, and its fixed-point sums are scaled by it.
+ * @type {number}
+ */
+export const SCREEN_PROBE_MAX_RAY_INTENSITY = 40;
+
+/**
+ * Steps of a screen trace through the depth buffer's hierarchy, Lumen's `HZBTraversal.MaxIterations`: a budget for
+ * one thread. A ray that spends them is a miss of the screen, which the bricks take on from where it got.
+ * @type {number}
+ */
+export const SCREEN_PROBE_SCREEN_TRACE_STEPS = 50;
+
+/**
+ * How far behind the depth buffer a screen trace still counts as on the surface, as a share of the surface's depth,
+ * Lumen's `HZBTraversal.RelativeDepthThickness`.
+ * @type {number}
+ */
+export const SCREEN_PROBE_SCREEN_THICKNESS = 0.02;
+
+/**
+ * The share of the screen, along each side, over which a screen hit fades to a miss, Lumen's: from 80% of the way
+ * from the centre to the edge, in screen position.
+ * @type {number}
+ */
+export const SCREEN_PROBE_SCREEN_EDGE = 0.2;
+
+/**
+ * How far past its probe a ray is traced before the world-space probes answer for the rest, in spacings of the
+ * cascade the probe reads them from: the furthest a corner probe of its cage stands from the point it serves,
+ * relocation included, `PROBE_DEPTH_LIMIT`. Past it the ray has left every corner's cage, as Lumen's rays leave a
+ * cell's diagonal before its radiance cache takes them.
+ * @type {number}
+ */
+export const SCREEN_PROBE_REACH_SPACINGS = PROBE_DEPTH_LIMIT;
+
+/**
+ * Pushes along the bricks' field a probe's brick origin takes at most, as the probe clipmap's relocation takes three:
+ * on a plane the first lands at the clearance, and the others carry it past a corner's second face or a curved field.
+ * @type {number}
+ */
+export const SCREEN_PROBE_ORIGIN_STEPS = 3;
+
+/**
+ * A ray hit something moving when the speeds of its hit and its probe differ by more than this share of the probe's
+ * depth, held to a metre from below, Lumen's `RelativeSpeedDifferenceToConsiderLightingMoving`.
+ * @type {number}
+ */
+export const SCREEN_PROBE_MOVING_SPEED = 0.005;
+
+/**
+ * The temporal filter's history at a pixel is another surface when its depth differs from the one reprojected there
+ * by this share of the depth, dithered over ×½ to ×1½ and widened at grazing angles, Lumen's
+ * `Temporal.DistanceThreshold`.
+ * @type {number}
+ */
+export const SCREEN_PROBE_TEMPORAL_DISTANCE = 0.005;
+
+/**
+ * Lumen's fast update: the share of a pixel's light seen moving at which it takes its new light whole, and the most of
+ * its history the fast update ever drops.
+ * @type {number}
+ */
+export const SCREEN_PROBE_FAST_UPDATE_MOVING = 0.1;
+export const SCREEN_PROBE_FAST_UPDATE_LIMIT = 0.9;
+
+/**
+ * How a probe's ray ended, the low bits of its hit word.
+ * - PENDING: the screen could not answer; the bricks will.
+ * - SCREEN: a hit in the screen, lit by the last frame's colour.
+ * - HIT: a front face in the bricks.
+ * - BACK: a back face in the bricks: inside a solid.
+ * - FAR: nothing within its reach; the world-space probes' radiance past it.
+ * - SKY: nothing within the world, or no world probe around: the environment.
+ * - UNRESOLVED: the bricks' march spent its steps; no light.
+ * - NONE: no ray: the probe stands on no surface.
+ */
+export const SCREEN_PROBE_TRACE_PENDING = 0;
+export const SCREEN_PROBE_TRACE_SCREEN = 1;
+export const SCREEN_PROBE_TRACE_HIT = 2;
+export const SCREEN_PROBE_TRACE_BACK = 3;
+export const SCREEN_PROBE_TRACE_FAR = 4;
+export const SCREEN_PROBE_TRACE_SKY = 5;
+export const SCREEN_PROBE_TRACE_UNRESOLVED = 6;
+export const SCREEN_PROBE_TRACE_NONE = 7;
+export const SCREEN_PROBE_TRACE_KIND_MASK = 7;
+
+/**
+ * Set in a hit word when the ray hit something moving relative to its probe.
+ * @type {number}
+ */
+export const SCREEN_PROBE_TRACE_MOVING = 8;
+
+/**
+ * Word offsets of the commands and counts one pass writes for the passes after it, `screen_probe_dispatch`: a
+ * workgroup a probe, a thread a probe, a thread a ray, a thread a ray left to the bricks, each three words of a
+ * folded dispatch; then the frame's probes, and its rays left to the bricks.
+ */
+export const SCREEN_PROBE_DISPATCH_PROBES = 0;
+export const SCREEN_PROBE_DISPATCH_THREADS = 3;
+export const SCREEN_PROBE_DISPATCH_RAYS = 6;
+export const SCREEN_PROBE_DISPATCH_BRICK_RAYS = 9;
+export const SCREEN_PROBE_DISPATCH_PROBE_COUNT = 12;
+export const SCREEN_PROBE_DISPATCH_BRICK_RAY_COUNT = 13;
+export const SCREEN_PROBE_DISPATCH_WORDS = 16;
+
+/**
+ * Word offsets of the frame's atomic counters, `screen_probe_counters`: adaptive probes placed, which may run past
+ * their slots and is held to them where read; rays left to the bricks.
+ */
+export const SCREEN_PROBE_COUNTER_ADAPTIVE = 0;
+export const SCREEN_PROBE_COUNTER_BRICK_RAYS = 1;
+export const SCREEN_PROBE_COUNTER_WORDS = 4;
+
+/**
+ * @param {number} downsample_factor
+ * @param {number} adaptive_min_downsample_factor
+ * @returns {number} levels of adaptive placement: at half the downsample factor, a quarter, and so on while the spacing
+ *   is at least the minimum
+ */
+export function screen_probe_adaptive_levels(downsample_factor, adaptive_min_downsample_factor) {
+    let levels = 0;
+
+    for (let spacing = downsample_factor >>> 1; spacing >= adaptive_min_downsample_factor && spacing >= 1; spacing >>>= 1) {
+        levels++;
+    }
+
+    return levels;
+}
+
+/**
+ * @param {number} levels of adaptive placement
+ * @returns {number} the most adaptive probes a tile can hold: each level's grid points in the tile that no coarser
+ *   level holds, 3·4^(l−1) at level l, 4^levels − 1 over them all
+ */
+export function screen_probe_adaptive_tile_capacity(levels) {
+    return 4 ** levels - 1;
+}
+
+/**
+ * @param {number} uniform_count uniform probes
+ * @param {number} levels of adaptive placement
+ * @returns {number} adaptive probe slots: as many as the uniform probes, Lumen's `AdaptiveProbeAllocationFraction` at
+ *   one (half there), so a frame's probes are never more than twice the uniform ones however finely the view's depth
+ *   breaks up; none without adaptive levels
+ */
+export function screen_probe_adaptive_capacity(uniform_count, levels) {
+    return levels > 0 ? uniform_count : 0;
+}

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

@@ -0,0 +1,11 @@
+/**
+ * What {@link ScreenProbeSettingsdebug_view } shows in place of the frame's colour, before TAA.
+ */
+export type ScreenProbeDebugView = number;
+export namespace ScreenProbeDebugView {
+    let None: number;
+    let IndirectDiffuse: number;
+    let ProbePlacement: number;
+    let TraceKinds: number;
+}
+//# sourceMappingURL=ScreenProbeDebugView.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ScreenProbeDebugView.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/screen_probe/ScreenProbeDebugView.js"],"names":[],"mappings":";;;mCAIU,MAAM"}

package/src/shade/renderer/global_illumination/screen_probe/ScreenProbeDebugView.js

@@ -0,0 +1,25 @@
+/**
+ * What {@link ScreenProbeSettings#debug_view} shows in place of the frame's colour, before TAA.
+ *
+ * @readonly
+ * @enum {number}
+ */
+export const ScreenProbeDebugView = {
+    /** the frame as rendered */
+    None: 0,
+    /**
+     * the light the screen probes' indirect diffuse is made of, after the temporal filter: their irradiance at the
+     * bent normal over π, what a white Lambertian surface would send back, before the surface's albedo and occlusion
+     */
+    IndirectDiffuse: 1,
+    /**
+     * where the frame's probes stand over the indirect diffuse: a uniform probe's pixel green, an adaptive probe's red,
+     * and a pixel no probe interpolates to (the temporal filter's to fill) blue
+     */
+    ProbePlacement: 2,
+    /**
+     * how each probe's rays ended, over the probe's footprint: the share resolved in the screen red, by the SDF bricks
+     * green, by the world-space probes past the trace blue
+     */
+    TraceKinds: 3,
+};

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

@@ -0,0 +1,110 @@
+/**
+ * Settings of {@link ShadeIndirectLightingMode.ScreenProbes}, held on `Renderer.screen_probes` and read every frame
+ * the mode runs. The world the probes trace and the world-space probes past their reach are the probe clipmap's,
+ * set by `Renderer.probe_clipmap` (`ProbeClipmapSettings`).
+ *
+ * Two kinds of field, by what a change costs:
+ * - **structure**: {@link downsample_factor} and {@link octahedron_resolution}. A change makes the screen probes'
+ *   resources again at the next frame, and their history starts from nothing.
+ * - **the rest** set the frame's passes and take effect the next frame without a rebuild.
+ *
+ * Each setter checks what its own value must be; what the device and the probes' layout hold is checked when the
+ * screen probes are made.
+ */
+export class ScreenProbeSettings {
+    /**
+     * @param {number} v a power of two from 1: tiles are found by shifts
+     */
+    set downsample_factor(v: number);
+    /**
+     * Pixels between the uniform probes along each axis: one probe stands on the G-buffer in every square tile of
+     * this many pixels a side, Lumen's `ScreenProbeGather.DownsampleFactor`. Adaptive probes fill in between where
+     * interpolating the uniform ones would cross an edge ({@link adaptive_min_downsample_factor}). Every ray a probe
+     * casts and every pixel's interpolation scale with the count, so the cost goes as the inverse square of this.
+     * Structure.
+     * @returns {number}
+     */
+    get downsample_factor(): number;
+    /**
+     * @param {number} v 4, 8 or 16: Lumen's range, whose top is what a probe's workgroup sorts and accumulates in its
+     *   memory (`SCREEN_PROBE_OCTAHEDRON_MINIMUM`, `SCREEN_PROBE_OCTAHEDRON_LIMIT`)
+     */
+    set octahedron_resolution(v: number);
+    /**
+     * Texels a side of a probe's radiance, over the sphere by Clarberg's equal-area map: each probe casts this
+     * squared rays a frame, one a texel, Lumen's `TracingOctahedronResolution`. With importance sampling a ray may
+     * instead stand in a quarter of a texel at twice this resolution, where the probe's light is brightest.
+     * Structure.
+     * @returns {number}
+     */
+    get octahedron_resolution(): number;
+    /**
+     * @param {number} v a power of two from 1
+     */
+    set adaptive_min_downsample_factor(v: number);
+    /**
+     * The finest spacing adaptive probes are placed at, in pixels, Lumen's `AdaptiveProbeMinDownsampleFactor`.
+     * Placement runs at half the {@link downsample_factor}, then a quarter, while the spacing is at least this:
+     * a pixel on that finer grid gets a probe where the probes already placed would not interpolate to it. At or
+     * above the downsample factor no adaptive probe is placed.
+     * @returns {number}
+     */
+    get adaptive_min_downsample_factor(): number;
+    /**
+     * @param {boolean} v
+     */
+    set importance_sampling(v: boolean);
+    /**
+     * Whether a probe's rays follow where its light comes from (Lumen's structured importance sampling): each texel
+     * is weighed by the cosine lobes of the pixels around the probe and by the light the probe's history saw there;
+     * the rays of texels the pixels cannot see go, three at a time, to split the brightest texels into four. Off,
+     * every texel takes one ray. Takes effect the next frame.
+     * @returns {boolean}
+     */
+    get importance_sampling(): boolean;
+    /**
+     * @param {boolean} v
+     */
+    set screen_traces(v: boolean);
+    /**
+     * Whether a probe's rays are traced through the screen first, against the depth buffer's hierarchy, and lit by the
+     * last frame's colour where they hit; what the screen cannot answer goes on through the SDF bricks. Off, every
+     * ray is traced through the bricks alone. Takes effect the next frame.
+     * @returns {boolean}
+     */
+    get screen_traces(): boolean;
+    /**
+     * @param {number} v a non-negative integer
+     */
+    set spatial_filter_passes(v: number);
+    /**
+     * Passes of the filter between neighbouring probes, Lumen's `SpatialFilterNumPasses`: each texel takes its four
+     * neighbours' along the same direction where they stand on its surface and saw the same point. Zero records none.
+     * Takes effect the next frame.
+     * @returns {number}
+     */
+    get spatial_filter_passes(): number;
+    /**
+     * @param {number} v frames, at least 1 and finite
+     */
+    set temporal_frames(v: number);
+    /**
+     * The most frames the temporal filter averages a pixel's diffuse over, Lumen's `Temporal.MaxFramesAccumulated`:
+     * a pixel whose history holds blends its new light by 1 / (1 + frames). Where the probes' rays saw something
+     * move, it takes fewer. Takes effect the next frame.
+     * @returns {number}
+     */
+    get temporal_frames(): number;
+    /**
+     * @param {ScreenProbeDebugView} v
+     */
+    set debug_view(v: number);
+    /**
+     * What the frame shows in place of its colour, before TAA: the frame itself, or one of the mode's debug views.
+     * Takes effect the next frame.
+     * @returns {ScreenProbeDebugView}
+     */
+    get debug_view(): number;
+    #private;
+}
+//# sourceMappingURL=ScreenProbeSettings.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ScreenProbeSettings.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/screen_probe/ScreenProbeSettings.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;GAYG;AACH;IAgBI;;OAEG;IACH,iCAKC;IApBD;;;;;;;OAOG;IACH,gCAEC;IAyBD;;;OAGG;IACH,qCAKC;IApBD;;;;;;OAMG;IACH,oCAEC;IA0BD;;OAEG;IACH,8CAKC;IAnBD;;;;;;OAMG;IACH,6CAEC;IAyBD;;OAEG;IACH,oCAIC;IAlBD;;;;;;OAMG;IACH,mCAEC;IAuBD;;OAEG;IACH,8BAIC;IAjBD;;;;;OAKG;IACH,6BAEC;IAuBD;;OAEG;IACH,qCAIC;IAjBD;;;;;OAKG;IACH,oCAEC;IAuBD;;OAEG;IACH,+BAKC;IAlBD;;;;;OAKG;IACH,8BAEC;IAuBD;;OAEG;IACH,0BAIC;IAhBD;;;;OAIG;IACH,yBAEC;;CAUJ"}