@woosh/meep-engine 3.67.0 → 3.68.0

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

@@ -0,0 +1,364 @@
+import { chunk_project_position_from_depth } from "../../shader/chunk/camera/chunk_project_position_from_depth.js";
+import { chunk_get_view_space_depth } from "../../shader/chunk/depth/chunk_get_view_space_depth.js";
+import { chunk_is_background } from "../../shader/chunk/depth/chunk_is_background.js";
+import { chunk_mat4_extract_position } from "../../shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
+import {
+    chunk_decode_g_buffer_face_normal
+} from "../../shader/chunk/geometry/normal/chunk_decode_g_buffer_face_normal.js";
+import { chunk_decode_g_buffer_normal } from "../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
+import { chunk_stbn_sample_vec2 } from "../../shader/chunk/noise/chunk_stbn_sample_vec2.js";
+import { chunk_sh3_color_add_scaled } from "../../shader/chunk/spherical_harmonics/chunk_sh3_color_add_scaled.js";
+import {
+    chunk_sh3_color_get_irradiance_at
+} from "../../shader/chunk/spherical_harmonics/chunk_sh3_color_get_irradiance_at.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceDescriptor } from "../../shader/resource/ShaderResourceDescriptor.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { STBN_VEC2_RESOURCE } from "../../STATIC_GRAPHICS_ENGINE_ASSET_RESOURCES.js";
+import { chunk_probe_clipmap } from "../probe_clipmap/probe/chunk_probe_clipmap.js";
+import {
+    chunk_screen_probe,
+    SCREEN_PROBE_EXPOSURE_RESOURCE,
+    SCREEN_PROBE_FRAME_RESOURCE,
+    SCREEN_PROBE_MOVING_READ_RESOURCE,
+    SCREEN_PROBE_SH_READ_RESOURCE,
+    SCREEN_PROBE_TILE_COUNTS_READ_RESOURCE,
+    SCREEN_PROBE_TILE_PROBES_READ_RESOURCE,
+    SCREEN_PROBES_READ_RESOURCE
+} from "./chunk_screen_probe.js";
+import { chunk_screen_probe_interpolate } from "./chunk_screen_probe_interpolate.js";
+import {
+    SCREEN_PROBE_CAMERA_PREVIOUS_RESOURCE,
+    SCREEN_PROBE_CAMERA_RESOURCE,
+    SCREEN_PROBE_DEPTH_RESOURCE,
+    SCREEN_PROBE_PBR_RESOURCE,
+    SCREEN_PROBE_VELOCITY_RESOURCE
+} from "./chunk_screen_probe_surface.js";
+import { chunk_screen_probe_covers } from "./shader_screen_probe_place.js";
+import {
+    SCREEN_PROBE_FAST_UPDATE_LIMIT,
+    SCREEN_PROBE_FAST_UPDATE_MOVING,
+    SCREEN_PROBE_JITTER_PLANE_WEIGHT_SCALE,
+    SCREEN_PROBE_TEMPORAL_DISTANCE,
+    SCREEN_PROBE_TILE_WORKGROUP_SIZE,
+    SCREEN_PROBE_WEIGHT_EPSILON
+} from "./SCREEN_PROBE.js";
+
+/** The G-buffer's bent normals, as GTAO left them (the shading normals where it is off). @type {ShaderResourceDescriptor} */
+export const SCREEN_PROBE_BENT_NORMAL_RESOURCE = ShaderResourceDescriptor.texture("tBentNormals", "uint");
+
+/** The integration's output, `rgba16float`: E at the bent normal, and in alpha the moving share, negative where no probe covered the pixel. @type {ShaderResourceDescriptor} */
+export const SCREEN_PROBE_INTEGRATED_READ_RESOURCE = ShaderResourceDescriptor.texture("screen_probe_integrated", "unfilterable-float");
+/** @type {ShaderResourceDescriptor} */
+export const SCREEN_PROBE_INTEGRATED_WRITE_RESOURCE = ShaderResourceDescriptor.storageTexture("screen_probe_integrated", "rgba16float", "2d", "write-only");
+
+/** Last frame's filtered diffuse, `rgba16float`. @type {ShaderResourceDescriptor} */
+export const SCREEN_PROBE_DIFFUSE_HISTORY_RESOURCE = ShaderResourceDescriptor.texture("screen_probe_diffuse_history", "unfilterable-float");
+/** This frame's, the temporal filter's output. @type {ShaderResourceDescriptor} */
+export const SCREEN_PROBE_DIFFUSE_WRITE_RESOURCE = ShaderResourceDescriptor.storageTexture("screen_probe_diffuse", "rgba16float", "2d", "write-only");
+
+/** Last frame's frames and fast update a pixel, two unorm16 in `r32uint`. @type {ShaderResourceDescriptor} */
+export const SCREEN_PROBE_FRAMES_HISTORY_RESOURCE = ShaderResourceDescriptor.texture("screen_probe_frames_history", "uint");
+/** @type {ShaderResourceDescriptor} */
+export const SCREEN_PROBE_FRAMES_WRITE_RESOURCE = ShaderResourceDescriptor.storageTexture("screen_probe_frames", "r32uint", "2d", "write-only");
+
+/** Last frame's reverse-Z depth. @type {ShaderResourceDescriptor} */
+export const SCREEN_PROBE_DEPTH_PREVIOUS_RESOURCE = ShaderResourceDescriptor.texture("tDepthPrevious");
+
+const integrate_resources = new ShaderResourceSetDescriptor();
+
+integrate_resources.createGroup()
+    .add(SCREEN_PROBE_FRAME_RESOURCE)
+    .add(SCREEN_PROBE_EXPOSURE_RESOURCE)
+    .add(SCREEN_PROBE_CAMERA_RESOURCE)
+    .add(SCREEN_PROBES_READ_RESOURCE)
+    .add(SCREEN_PROBE_TILE_COUNTS_READ_RESOURCE)
+    .add(SCREEN_PROBE_TILE_PROBES_READ_RESOURCE)
+    .add(SCREEN_PROBE_SH_READ_RESOURCE)
+    .add(SCREEN_PROBE_MOVING_READ_RESOURCE)
+    .add(STBN_VEC2_RESOURCE)
+    .add(SCREEN_PROBE_DEPTH_RESOURCE)
+    .add(SCREEN_PROBE_PBR_RESOURCE)
+    .add(SCREEN_PROBE_BENT_NORMAL_RESOURCE)
+    .add(SCREEN_PROBE_INTEGRATED_WRITE_RESOURCE);
+
+/**
+ * Each pixel's diffuse light from the probes (Lumen's `ScreenProbeIntegrateCS`, its SH3 diffuse): a thread a pixel.
+ *
+ * - **The lookup's jitter**: by the frame's blue noise at the pixel, up to a tile's width each way, Lumen's
+ *   `FullResolutionJitterWidth` of one, kept only where the pixel it lands on is coplanar with this one (plane weight at
+ *   `SCREEN_PROBE_JITTER_PLANE_WEIGHT_SCALE` past 0.01), so the probes' grid dissolves into noise the temporal filter
+ *   averages without crossing an edge.
+ * - **The probes**: `screen_probe_interpolate` from the pixel's surface point, view depth and face normal; the weights
+ *   normalised by their sum, held to `SCREEN_PROBE_WEIGHT_EPSILON` from below.
+ * - **The light**: the probes' SH3 blended by the weights (each probe by name), E at the pixel's bent normal
+ *   (`sh3_color_get_irradiance_at`), as the probe clipmap's diffuse resolves at it, over the exposure the SH was
+ *   pre-exposed by: the scene's units, which the temporal filter and the deferred passes take.
+ * - **Alpha**: the probes' moving shares by the same weights, held to 0.001 from below; negative where the weights do
+ *   not cover the pixel (`screen_probe_covers`), whose light is then zero and the temporal filter's to fill.
+ * - A pixel of the sky is zero.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_screen_probe_integrate = ComputeShader.from({
+    label: "Screen Probe Integrate",
+    resources: integrate_resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+fn screen_probe_tile_adaptive_count(tile: u32) -> u32 {
+    return screen_probe_tile_counts[tile];
+}
+
+fn screen_probe_sh_of(probe: u32) -> array<vec3<f32>, 9> {
+    let at = probe * 7u;
+
+    return probe_record_sh_decode(array<u32, 7>(
+        screen_probe_sh[at], screen_probe_sh[at + 1u], screen_probe_sh[at + 2u], screen_probe_sh[at + 3u],
+        screen_probe_sh[at + 4u], screen_probe_sh[at + 5u], screen_probe_sh[at + 6u],
+    ));
+}
+
+@compute @workgroup_size(${SCREEN_PROBE_TILE_WORKGROUP_SIZE}, ${SCREEN_PROBE_TILE_WORKGROUP_SIZE}, 1)
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+    let frame = screen_probe_frame;
+
+    if (any(id.xy >= frame.view_size)) {
+        return;
+    }
+
+    let pixel = id.xy;
+    let size = vec2<f32>(frame.view_size);
+    let device_depth = textureLoad(tDepth, pixel, 0).r;
+
+    if (is_background(device_depth)) {
+        textureStore(screen_probe_integrated, pixel, vec4<f32>(0.0));
+        return;
+    }
+
+    let position = project_position_from_depth((vec2<f32>(pixel) + 0.5) / size, device_depth, camera.view_projection_matrix_inverse);
+    let depth = get_view_space_depth(device_depth, camera);
+    let face = decode_g_buffer_face_normal(textureLoad(tPBR, pixel, 0));
+
+    // the lookup moves up to a tile each way, onto a pixel coplanar with this one
+    let span = f32(1u << frame.downsample_shift);
+    let shift = (stbn_sample_vec2(vec3<u32>(pixel, frame.frame_index)) * 2.0 - 1.0) * span;
+    let landed = vec2<u32>(clamp(vec2<f32>(pixel) + shift, vec2<f32>(0.0), size - 1.0));
+    let landed_depth = textureLoad(tDepth, landed, 0).r;
+
+    var offset = vec2<f32>(0.0);
+
+    if (!is_background(landed_depth)) {
+        let landed_position = project_position_from_depth((vec2<f32>(landed) + 0.5) / size, landed_depth, camera.view_projection_matrix_inverse);
+        let relative = abs(dot(face, landed_position - position)) / depth;
+
+        if (exp2(-${SCREEN_PROBE_JITTER_PLANE_WEIGHT_SCALE}.0 * relative * relative) > 0.01) {
+            offset = shift;
+        }
+    }
+
+    let sample = screen_probe_interpolate(pixel, offset, position, depth, face);
+    let covered = screen_probe_covers(sample.weights);
+    let weights = sample.weights / max(dot(sample.weights, vec4<f32>(1.0)), ${SCREEN_PROBE_WEIGHT_EPSILON});
+
+    var sh = array<vec3<f32>, 9>();
+    var moving = 0.0;
+
+    // each corner by name, a corner of no weight not read
+    if (weights.x > 0.0) { sh = sh3_color_add_scaled(sh, screen_probe_sh_of(sample.probes.x), weights.x); moving += weights.x * screen_probe_moving[sample.probes.x]; }
+    if (weights.y > 0.0) { sh = sh3_color_add_scaled(sh, screen_probe_sh_of(sample.probes.y), weights.y); moving += weights.y * screen_probe_moving[sample.probes.y]; }
+    if (weights.z > 0.0) { sh = sh3_color_add_scaled(sh, screen_probe_sh_of(sample.probes.z), weights.z); moving += weights.z * screen_probe_moving[sample.probes.z]; }
+    if (weights.w > 0.0) { sh = sh3_color_add_scaled(sh, screen_probe_sh_of(sample.probes.w), weights.w); moving += weights.w * screen_probe_moving[sample.probes.w]; }
+
+    let bent_normal = decode_g_buffer_normal(textureLoad(tBentNormals, pixel, 0).x);
+    let irradiance = select(vec3<f32>(0.0), sh3_color_get_irradiance_at(bent_normal, sh) / max(screen_probe_exposure.value, 1e-20), covered);
+
+    textureStore(screen_probe_integrated, pixel, vec4<f32>(irradiance, select(-1.0, 1.0, covered) * max(moving, 0.001)));
+}
+`, [
+            chunk_screen_probe,
+            chunk_screen_probe_interpolate,
+            chunk_screen_probe_covers,
+            chunk_is_background,
+            chunk_project_position_from_depth,
+            chunk_get_view_space_depth,
+            chunk_decode_g_buffer_face_normal,
+            chunk_decode_g_buffer_normal,
+            chunk_stbn_sample_vec2,
+            chunk_sh3_color_add_scaled,
+            chunk_sh3_color_get_irradiance_at,
+            chunk_probe_clipmap,
+        ]),
+});
+
+const temporal_resources = new ShaderResourceSetDescriptor();
+
+temporal_resources.createGroup()
+    .add(SCREEN_PROBE_FRAME_RESOURCE)
+    .add(SCREEN_PROBE_CAMERA_RESOURCE)
+    .add(SCREEN_PROBE_CAMERA_PREVIOUS_RESOURCE)
+    .add(STBN_VEC2_RESOURCE)
+    .add(SCREEN_PROBE_DEPTH_RESOURCE)
+    .add(SCREEN_PROBE_DEPTH_PREVIOUS_RESOURCE)
+    .add(SCREEN_PROBE_PBR_RESOURCE)
+    .add(SCREEN_PROBE_VELOCITY_RESOURCE)
+    .add(SCREEN_PROBE_INTEGRATED_READ_RESOURCE)
+    .add(SCREEN_PROBE_DIFFUSE_HISTORY_RESOURCE)
+    .add(SCREEN_PROBE_FRAMES_HISTORY_RESOURCE)
+    .add(SCREEN_PROBE_DIFFUSE_WRITE_RESOURCE)
+    .add(SCREEN_PROBE_FRAMES_WRITE_RESOURCE);
+
+/**
+ * The temporal filter (Lumen's `ScreenProbeTemporalReprojectionCS`): a thread a pixel, blending its integrated light
+ * into its history.
+ *
+ * - **Reprojection**: the pixel's place last frame by its velocity; its four bilinear neighbours there, each kept
+ *   where last frame's depth at it is the depth this pixel's point had then by its velocity (Lumen's history depth),
+ *   within `SCREEN_PROBE_TEMPORAL_DISTANCE` of it, the threshold dithered over ×½ to ×1½ (a blue-noise draw half the
+ *   noise's period from the integration's jitter, so the two do not move together) and divided by the cosine between
+ *   the face normal and the view (held to 0.1), the depth a grazing surface spans between jittered frames; and on the
+ *   screen. Each texel's history by its bilinear weight among those kept.
+ * - **Frames**: each kept neighbour's count plus one, held to `temporal_frames`, by the same weights.
+ * - **Fast update**: the pixel's moving share over `SCREEN_PROBE_FAST_UPDATE_MOVING`, less 0.2 over 0.8, held to
+ *   `SCREEN_PROBE_FAST_UPDATE_LIMIT`, and no less than the history's: the frames are held to (1 − it) of the most.
+ *   The history keeps this frame's own share.
+ * - **A pixel the probes did not cover** takes the mean of its covered neighbours in a 3 × 3 this frame; with none,
+ *   its history alone.
+ * - The blend is 1 / (1 + frames); a pixel with no history to keep takes its new light whole.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_screen_probe_temporal = ComputeShader.from({
+    label: "Screen Probe Temporal",
+    resources: temporal_resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+// a covered neighbour's light this frame, and one if it was covered
+fn screen_probe_neighbour_light(pixel: vec2<i32>, offset: vec2<i32>) -> vec4<f32> {
+    let at = pixel + offset;
+
+    if (any(at < vec2<i32>(0)) || any(at >= vec2<i32>(screen_probe_frame.view_size))) {
+        return vec4<f32>(0.0);
+    }
+
+    let value = textureLoad(screen_probe_integrated, vec2<u32>(at), 0);
+
+    return select(vec4<f32>(0.0), vec4<f32>(value.rgb, 1.0), value.a > 0.0);
+}
+
+@compute @workgroup_size(${SCREEN_PROBE_TILE_WORKGROUP_SIZE}, ${SCREEN_PROBE_TILE_WORKGROUP_SIZE}, 1)
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+    let frame = screen_probe_frame;
+
+    if (any(id.xy >= frame.view_size)) {
+        return;
+    }
+
+    let pixel = id.xy;
+    let size = vec2<f32>(frame.view_size);
+    let device_depth = textureLoad(tDepth, pixel, 0).r;
+
+    if (is_background(device_depth)) {
+        textureStore(screen_probe_diffuse, pixel, vec4<f32>(0.0));
+        textureStore(screen_probe_frames, pixel, vec4<u32>(0u));
+        return;
+    }
+
+    let position = project_position_from_depth((vec2<f32>(pixel) + 0.5) / size, device_depth, camera.view_projection_matrix_inverse);
+    let fresh = textureLoad(screen_probe_integrated, pixel, 0);
+    let covered = fresh.a > 0.0;
+    let moving = abs(fresh.a);
+
+    var light = fresh.rgb;
+    var force_history = false;
+
+    if (!covered) {
+        let p = vec2<i32>(pixel);
+        let s = screen_probe_neighbour_light(p, vec2<i32>(-1, -1)) + screen_probe_neighbour_light(p, vec2<i32>(0, -1)) + screen_probe_neighbour_light(p, vec2<i32>(1, -1))
+            + screen_probe_neighbour_light(p, vec2<i32>(-1, 0)) + screen_probe_neighbour_light(p, vec2<i32>(1, 0))
+            + screen_probe_neighbour_light(p, vec2<i32>(-1, 1)) + screen_probe_neighbour_light(p, vec2<i32>(0, 1)) + screen_probe_neighbour_light(p, vec2<i32>(1, 1));
+
+        light = select(vec3<f32>(0.0), s.rgb / s.a, s.a > 0.0);
+        force_history = s.a <= 0.0;
+    }
+
+    var history = vec3<f32>(0.0);
+    var frames = 0.0;
+    var fast_history = 0.0;
+    var kept = 0.0;
+
+    if (frame.history != 0u) {
+        let previous = vec2<f32>(pixel) + 0.5 - textureLoad(tVelocity, pixel, 0).rg;
+        let on_screen = all(previous >= vec2<f32>(0.0)) && all(previous <= size);
+
+        if (on_screen) {
+            // the point's view depth last frame: its depth now less the depth its velocity moved through
+            let expected = get_view_space_depth(device_depth, camera) - textureLoad(tVelocity, pixel, 0).z;
+            let face = decode_g_buffer_face_normal(textureLoad(tPBR, pixel, 0));
+            let view_direction = normalize(mat4_extract_position(camera.transform) - position);
+            let noise = stbn_sample_vec2(vec3<u32>(pixel, frame.frame_index + 32u)).x;
+            let threshold = ${SCREEN_PROBE_TEMPORAL_DISTANCE} * mix(0.5, 1.5, noise) / clamp(dot(view_direction, face), 0.1, 1.0);
+
+            let corner = previous - 0.5;
+            let base = vec2<i32>(floor(corner));
+            let f = corner - floor(corner);
+
+            for (var k = 0u; k < 4u; k++) {
+                let tap = base + vec2<i32>(i32(k & 1u), i32(k >> 1u));
+
+                if (any(tap < vec2<i32>(0)) || any(tap >= vec2<i32>(frame.view_size))) {
+                    continue;
+                }
+
+                let axes = select(1.0 - f, f, vec2<bool>((k & 1u) != 0u, (k >> 1u) != 0u));
+                let bilinear = axes.x * axes.y;
+                let history_depth = get_view_space_depth(textureLoad(tDepthPrevious, vec2<u32>(tap), 0).r, camera_previous);
+
+                if (abs(history_depth - expected) >= expected * threshold || bilinear <= 0.0) {
+                    continue;
+                }
+
+                let packed = unpack2x16unorm(textureLoad(screen_probe_frames_history, vec2<u32>(tap), 0).r);
+
+                history += bilinear * textureLoad(screen_probe_diffuse_history, vec2<u32>(tap), 0).rgb;
+                frames += bilinear * min(packed.x * frame.temporal_frames + 1.0, frame.temporal_frames);
+                fast_history += bilinear * packed.y;
+                kept += bilinear;
+            }
+        }
+    }
+
+    // this frame's share of moving light, as Lumen's fast update maps it
+    let fast_own = saturate(min((saturate(moving / ${SCREEN_PROBE_FAST_UPDATE_MOVING}) - 0.2) / 0.8, ${SCREEN_PROBE_FAST_UPDATE_LIMIT}));
+
+    var out = light;
+    var accumulated = 0.0;
+
+    if (kept > 0.0) {
+        history /= kept;
+        frames /= kept;
+        fast_history /= kept;
+
+        let fast = max(fast_own, fast_history);
+
+        accumulated = min(frames, (1.0 - fast) * frame.temporal_frames);
+
+        // with nothing new to take, the history stands
+        out = select(mix(history, light, 1.0 / (1.0 + accumulated)), history, force_history);
+    }
+
+    textureStore(screen_probe_diffuse, pixel, vec4<f32>(max(out, vec3<f32>(0.0)), 1.0));
+    textureStore(screen_probe_frames, pixel, vec4<u32>(pack2x16unorm(vec2<f32>(accumulated / frame.temporal_frames, fast_own)), 0u, 0u, 0u));
+}
+`, [
+            chunk_screen_probe,
+            chunk_is_background,
+            chunk_project_position_from_depth,
+            chunk_get_view_space_depth,
+            chunk_decode_g_buffer_face_normal,
+            chunk_mat4_extract_position,
+            chunk_stbn_sample_vec2,
+        ]),
+});

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

@@ -0,0 +1,40 @@
+/** Last frame's lit colour of the opaque surfaces, the view's size, before transparencies and fog. @type {ShaderResourceDescriptor} */
+export const SCREEN_PROBE_COLOR_HISTORY_RESOURCE: ShaderResourceDescriptor;
+/** The TAA's history confidence a pixel, in `r` (`shader_depth_occlusion_clip`). @type {ShaderResourceDescriptor} */
+export const SCREEN_PROBE_OCCLUSION_RESOURCE: ShaderResourceDescriptor;
+/**
+ * Settings of the screen trace.
+ * @type {WebGPUStruct}
+ */
+export const SCREEN_PROBE_TRACE_SCREEN_SETTINGS: WebGPUStruct;
+/**
+ * The screen trace (Lumen's `ScreenProbeTraceScreenTexturesCS`): a thread a ray of the frame's probes, through the
+ * thread-a-ray command; a ray finds its probe and slot from its index, and its direction from its info and its probe's
+ * jitter (`screen_probe_ray_direction`).
+ *
+ * - **Origin**: the probe's surface point, lifted along its face normal by twice the depth half a pixel's offset makes
+ *   along it (Lumen's normal bias): the depth buffer's texels stand proud of the plane they sample. An origin the lift
+ *   moves off the screen traces nothing in it.
+ * - **Reach**: the march covers the probe's reach (`screen_probe_picks`), cut short of the camera's plane, 0.99 of the
+ *   way, for a ray heading toward it, as Lumen's `TraceScreen` cuts it.
+ * - **March**: the depth buffer's hierarchy from the full-resolution level, `ffx_sssr_hierarchical_raymarch`, the
+ *   engine's HZB traversal (SSR's), `SCREEN_PROBE_SCREEN_TRACE_STEPS` steps at most; past the reach's end it is a miss.
+ * - **A hit** stands at most `SCREEN_PROBE_SCREEN_THICKNESS` of the surface's depth behind it, on a surface the ray
+ *   meets from its front (its face normal against the ray), and holds when two dithered tests pass, as Lumen's: the
+ *   screen-edge fade at the hit (`SCREEN_PROBE_SCREEN_EDGE`) and the TAA's confidence in the hit pixel's history, so
+ *   last frame's colour is that surface's. Its radiance is last frame's lit colour of the opaque surfaces at the hit
+ *   pixel's place last frame (its velocity), a bounce more each frame, pre-exposed (`screen_probe_exposure`). It is moving when its speed and the probe's
+ *   differ by `SCREEN_PROBE_MOVING_SPEED` of the probe's depth, held to a metre from below.
+ * - **Anything else** is left to the bricks, appended to their list (one atomic a subgroup) with how far the screen
+ *   showed it clear: to the end of the march, or to a hit the tests refused, so the bricks resume in front of that
+ *   surface. A ray of a probe on no surface ends here, NONE.
+ *
+ * Every lane appends, wanting or not, from uniform control flow.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_screen_probe_trace_screen: ComputeShader;
+import { ShaderResourceDescriptor } from "../../shader/resource/ShaderResourceDescriptor.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_screen_probe_trace_screen.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_screen_probe_trace_screen.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/screen_probe/shader_screen_probe_trace_screen.js"],"names":[],"mappings":"AA0DA,uIAAuI;AACvI,kDAD2G,wBAAwB,CACK;AAExI,qHAAqH;AACrH,8CADyF,wBAAwB,CACG;AAEpH;;;GAGG;AACH,iDAFU,YAAY,CAKe;AA6BrC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,+CAFU,aAAa,CAsJpB;yCA9PsC,mDAAmD;6BAG/D,mCAAmC;8BAJlC,+BAA+B"}