@woosh/meep-engine 3.65.0 → 3.68.0

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

@@ -0,0 +1,301 @@
+import { chunk_folded_dispatch } from "../../gpu_primitive/indirect/chunk_folded_dispatch.js";
+import {
+    chunk_uv_octahedral_unit_decode
+} from "../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_decode.js";
+import { chunk_divide_round_up_u32 } from "../../shader/chunk/math/chunk_divide_round_up_u32.js";
+import {
+    chunk_subgroup_append_slot,
+    SUBGROUP_APPEND_NONE
+} from "../../shader/chunk/subgroup/chunk_subgroup_append_slot.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import {
+    chunk_screen_probe,
+    SCREEN_PROBE_COUNTERS_READ_RESOURCE,
+    SCREEN_PROBE_COUNTERS_RESOURCE,
+    SCREEN_PROBE_DISPATCH_WRITE_RESOURCE,
+    SCREEN_PROBE_FRAME_RESOURCE,
+    SCREEN_PROBE_TILE_COUNTS_WRITE_RESOURCE,
+    SCREEN_PROBE_TILE_PROBES_WRITE_RESOURCE,
+    SCREEN_PROBES_WRITE_RESOURCE
+} from "./chunk_screen_probe.js";
+import { chunk_screen_probe_interpolate } from "./chunk_screen_probe_interpolate.js";
+import {
+    chunk_screen_probe_surface,
+    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 {
+    SCREEN_PROBE_COUNTER_ADAPTIVE,
+    SCREEN_PROBE_COUNTER_BRICK_RAYS,
+    SCREEN_PROBE_DISPATCH_BRICK_RAY_COUNT,
+    SCREEN_PROBE_DISPATCH_BRICK_RAYS,
+    SCREEN_PROBE_DISPATCH_PROBE_COUNT,
+    SCREEN_PROBE_DISPATCH_PROBES,
+    SCREEN_PROBE_DISPATCH_RAYS,
+    SCREEN_PROBE_DISPATCH_THREADS,
+    SCREEN_PROBE_THREAD_WORKGROUP_SIZE,
+    SCREEN_PROBE_TILE_WORKGROUP_SIZE,
+    SCREEN_PROBE_WEIGHT_EPSILON
+} from "./SCREEN_PROBE.js";
+
+/**
+ * Whether a point's interpolation weights cover it, Lumen's rule: the weights normalised by their sum held to
+ * `SCREEN_PROBE_WEIGHT_EPSILON` from below sum to at least 1 − ε, that is the raw sum is at least ε·(1 − ε). Adaptive
+ * placement puts a probe where they do not; integration gives no light there.
+ *
+ * ```wgsl
+ * fn screen_probe_covers(weights: vec4<f32>) -> bool
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_screen_probe_covers = CodeChunk.from(
+    //language=WGSL
+    `
+fn screen_probe_covers(weights: vec4<f32>) -> bool {
+    return dot(weights, vec4<f32>(1.0)) >= ${SCREEN_PROBE_WEIGHT_EPSILON * (1 - SCREEN_PROBE_WEIGHT_EPSILON)};
+}
+`);
+
+const surface_group = (resources) => resources.createGroup()
+    .add(SCREEN_PROBE_FRAME_RESOURCE)
+    .add(SCREEN_PROBE_CAMERA_RESOURCE)
+    .add(SCREEN_PROBE_CAMERA_PREVIOUS_RESOURCE)
+    .add(SCREEN_PROBE_DEPTH_RESOURCE)
+    .add(SCREEN_PROBE_PBR_RESOURCE)
+    .add(SCREEN_PROBE_VELOCITY_RESOURCE);
+
+const uniform_resources = new ShaderResourceSetDescriptor();
+
+surface_group(uniform_resources);
+
+uniform_resources.createGroup()
+    .add(SCREEN_PROBES_WRITE_RESOURCE)
+    .add(SCREEN_PROBE_TILE_COUNTS_WRITE_RESOURCE);
+
+/**
+ * Uniform placement (Lumen's `ScreenProbeDownsampleDepthUniformCS`): a thread a tile of D × D pixels, the probe on the
+ * pixel at the frame's jitter in it, held inside the view (`screen_probe_surface_at`), written to its tile's place in
+ * the atlas. A tile over the sky gets a record of depth zero. Each tile's count of adaptive probes starts at zero.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_screen_probe_place_uniform = ComputeShader.from({
+    label: "Screen Probe Place Uniform",
+    resources: uniform_resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@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.tile_count)) {
+        return;
+    }
+
+    let probe = id.y * frame.tile_count.x + id.x;
+    let pixel = min((id.xy << vec2<u32>(frame.downsample_shift)) + frame.jitter, frame.view_size - 1u);
+
+    screen_probes[probe] = screen_probe_surface_at(pixel);
+
+    atomicStore(&screen_probe_tile_counts[probe], 0u);
+}
+`, [
+            chunk_screen_probe,
+            chunk_screen_probe_surface,
+        ]),
+});
+
+/**
+ * Settings of one level of adaptive placement.
+ * @type {WebGPUStruct}
+ */
+export const SCREEN_PROBE_ADAPTIVE_SETTINGS = WebGPUStruct.from({
+    /** the level, 1 for half the downsample factor, 2 for a quarter, … */
+    level: u32,
+}, "ScreenProbeAdaptiveSettings");
+
+const adaptive_resources = new ShaderResourceSetDescriptor();
+
+adaptive_resources.setImmediate("settings", SCREEN_PROBE_ADAPTIVE_SETTINGS);
+
+surface_group(adaptive_resources);
+
+adaptive_resources.createGroup()
+    .add(SCREEN_PROBES_WRITE_RESOURCE)
+    .add(SCREEN_PROBE_TILE_COUNTS_WRITE_RESOURCE)
+    .add(SCREEN_PROBE_TILE_PROBES_WRITE_RESOURCE)
+    .add(SCREEN_PROBE_COUNTERS_RESOURCE);
+
+/**
+ * Adaptive placement, one level (Lumen's `ScreenProbeAdaptivePlacementCS`): a thread a point of the grid at the
+ * level's spacing, D >> level, with the frame's jitter. A point that a coarser level's grid already holds, both its
+ * indices even, is skipped. A point on a surface that the probes placed so far do not cover (`screen_probe_interpolate`,
+ * `screen_probe_covers`), the uniform ones and the coarser levels' adaptive ones, gets a probe:
+ *
+ * - its slot from the frame's count of adaptive probes, one atomic a subgroup; past `adaptive_capacity` no probe is
+ *   placed, so where the view wants more than the slots hold, the coarser levels, placed first, keep theirs;
+ * - its record at probe `uniform_count + slot`, and its slot on its tile's list, whose count of
+ *   `adaptive_tile_capacity` it cannot pass, since the tile holds that many of the grids' points.
+ *
+ * The levels run one dispatch each, coarsest first, so a level sees every coarser one's probes; within a level,
+ * another workgroup's placement may not be seen yet, as in Lumen.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_screen_probe_place_adaptive = ComputeShader.from({
+    label: "Screen Probe Place Adaptive",
+    resources: adaptive_resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+fn screen_probe_tile_adaptive_count(tile: u32) -> u32 {
+    return atomicLoad(&screen_probe_tile_counts[tile]);
+}
+
+@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;
+    let level = settings.level;
+    let pixel = (id.xy << vec2<u32>(frame.downsample_shift - level)) + frame.jitter;
+
+    var wants = false;
+    var record: ScreenProbe;
+
+    // a point a coarser grid holds has both indices even
+    if (all(pixel < frame.view_size) && any((id.xy & vec2<u32>(1u)) != vec2<u32>(0u))) {
+        record = screen_probe_surface_at(pixel);
+
+        if (record.depth > 0.0) {
+            let normal = uv_octahedral_unit_decode(unpack2x16unorm(record.normal));
+            let sample = screen_probe_interpolate(pixel, vec2<f32>(0.0), record.position, record.depth, normal);
+
+            wants = !screen_probe_covers(sample.weights);
+        }
+    }
+
+    // every lane, wanting or not, for the subgroup's one atomic
+    let slot = subgroup_append_slot(&screen_probe_counters[${SCREEN_PROBE_COUNTER_ADAPTIVE}u], wants, frame.adaptive_capacity);
+
+    if (slot == ${SUBGROUP_APPEND_NONE}u) {
+        return;
+    }
+
+    screen_probes[frame.uniform_count + slot] = record;
+
+    // the tile of a point of this level's grid: its index over the level's subdivision of a tile
+    let tile = id.xy >> vec2<u32>(level);
+    let tile_index = tile.y * frame.tile_count.x + tile.x;
+    let place = atomicAdd(&screen_probe_tile_counts[tile_index], 1u);
+
+    screen_probe_tile_probes[tile_index * frame.adaptive_tile_capacity + place] = slot;
+}
+`, [
+            chunk_screen_probe,
+            chunk_screen_probe_surface,
+            chunk_screen_probe_interpolate,
+            chunk_screen_probe_covers,
+            chunk_subgroup_append_slot,
+            chunk_uv_octahedral_unit_decode,
+        ]),
+});
+
+const command_resources = new ShaderResourceSetDescriptor();
+
+command_resources.createGroup()
+    .add(SCREEN_PROBE_FRAME_RESOURCE)
+    .add(SCREEN_PROBE_COUNTERS_READ_RESOURCE)
+    .add(SCREEN_PROBE_DISPATCH_WRITE_RESOURCE);
+
+/**
+ * The commands of the frame's passes over its probes, one thread after placement: the frame's probes, the uniform ones
+ * and the adaptive ones placed, held to their slots; a workgroup a probe, a thread a probe and a thread a ray, folded
+ * (`folded_dispatch`), and the count.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_screen_probe_command = ComputeShader.from({
+    label: "Screen Probe Command",
+    resources: command_resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+fn screen_probe_command_write(at: u32, groups: u32) {
+    let folded = folded_dispatch(groups);
+
+    screen_probe_dispatch[at] = folded.x;
+    screen_probe_dispatch[at + 1u] = folded.y;
+    screen_probe_dispatch[at + 2u] = folded.z;
+}
+
+@compute @workgroup_size(1, 1, 1)
+fn main() {
+    let frame = screen_probe_frame;
+    let count = frame.uniform_count + min(screen_probe_counters[${SCREEN_PROBE_COUNTER_ADAPTIVE}u], frame.adaptive_capacity);
+    let rays = count << (2u * frame.octahedron_shift);
+
+    screen_probe_command_write(${SCREEN_PROBE_DISPATCH_PROBES}u, count);
+    screen_probe_command_write(${SCREEN_PROBE_DISPATCH_THREADS}u, divide_round_up_u32(count, ${SCREEN_PROBE_THREAD_WORKGROUP_SIZE}u));
+    screen_probe_command_write(${SCREEN_PROBE_DISPATCH_RAYS}u, divide_round_up_u32(rays, ${SCREEN_PROBE_THREAD_WORKGROUP_SIZE}u));
+
+    screen_probe_dispatch[${SCREEN_PROBE_DISPATCH_PROBE_COUNT}u] = count;
+}
+`, [
+            chunk_screen_probe,
+            chunk_folded_dispatch,
+            chunk_divide_round_up_u32,
+        ]),
+});
+
+/**
+ * Settings of the bricks' command.
+ * @type {WebGPUStruct}
+ */
+export const SCREEN_PROBE_BRICK_COMMAND_SETTINGS = WebGPUStruct.from({
+    /** slots of the list of rays left to the bricks */
+    capacity: u32,
+}, "ScreenProbeBrickCommandSettings");
+
+const brick_command_resources = new ShaderResourceSetDescriptor();
+
+brick_command_resources.setImmediate("settings", SCREEN_PROBE_BRICK_COMMAND_SETTINGS);
+
+brick_command_resources.createGroup()
+    .add(SCREEN_PROBE_COUNTERS_READ_RESOURCE)
+    .add(SCREEN_PROBE_DISPATCH_WRITE_RESOURCE);
+
+/**
+ * The command of the passes over the rays the screen left to the bricks, one thread after the screen trace: the count,
+ * held to the list's slots, and a thread a ray, folded.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_screen_probe_brick_command = ComputeShader.from({
+    label: "Screen Probe Brick Command",
+    resources: brick_command_resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(1, 1, 1)
+fn main() {
+    let count = min(screen_probe_counters[${SCREEN_PROBE_COUNTER_BRICK_RAYS}u], settings.capacity);
+    let folded = folded_dispatch(divide_round_up_u32(count, ${SCREEN_PROBE_THREAD_WORKGROUP_SIZE}u));
+
+    screen_probe_dispatch[${SCREEN_PROBE_DISPATCH_BRICK_RAYS}u] = folded.x;
+    screen_probe_dispatch[${SCREEN_PROBE_DISPATCH_BRICK_RAYS}u + 1u] = folded.y;
+    screen_probe_dispatch[${SCREEN_PROBE_DISPATCH_BRICK_RAYS}u + 2u] = folded.z;
+    screen_probe_dispatch[${SCREEN_PROBE_DISPATCH_BRICK_RAY_COUNT}u] = count;
+}
+`, [
+            chunk_folded_dispatch,
+            chunk_divide_round_up_u32,
+        ]),
+});

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

@@ -0,0 +1,59 @@
+/** 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;
+/** 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;
+/** @type {ShaderResourceDescriptor} */
+export const SCREEN_PROBE_INTEGRATED_WRITE_RESOURCE: ShaderResourceDescriptor;
+/** Last frame's filtered diffuse, `rgba16float`. @type {ShaderResourceDescriptor} */
+export const SCREEN_PROBE_DIFFUSE_HISTORY_RESOURCE: ShaderResourceDescriptor;
+/** This frame's, the temporal filter's output. @type {ShaderResourceDescriptor} */
+export const SCREEN_PROBE_DIFFUSE_WRITE_RESOURCE: ShaderResourceDescriptor;
+/** Last frame's frames and fast update a pixel, two unorm16 in `r32uint`. @type {ShaderResourceDescriptor} */
+export const SCREEN_PROBE_FRAMES_HISTORY_RESOURCE: ShaderResourceDescriptor;
+/** @type {ShaderResourceDescriptor} */
+export const SCREEN_PROBE_FRAMES_WRITE_RESOURCE: ShaderResourceDescriptor;
+/** Last frame's reverse-Z depth. @type {ShaderResourceDescriptor} */
+export const SCREEN_PROBE_DEPTH_PREVIOUS_RESOURCE: ShaderResourceDescriptor;
+/**
+ * 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;
+/**
+ * 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;
+import { ShaderResourceDescriptor } from "../../shader/resource/ShaderResourceDescriptor.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_screen_probe_resolve.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_screen_probe_resolve.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/screen_probe/shader_screen_probe_resolve.js"],"names":[],"mappings":"AA+CA,6HAA6H;AAC7H,gDADiG,wBAAwB,CACf;AAE1G,gLAAgL;AAChL,oDADoJ,wBAAwB,CACrC;AACvI,uCAAuC;AACvC,qDADW,wBAAwB,CACyH;AAE5J,qFAAqF;AACrF,oDADyD,wBAAwB,CAC2D;AAC5I,mFAAmF;AACnF,kDADuD,wBAAwB,CACuE;AAEtJ,8GAA8G;AAC9G,mDADkF,wBAAwB,CACkB;AAC5H,uCAAuC;AACvC,iDADW,wBAAwB,CAC6G;AAEhJ,qEAAqE;AACrE,mDADyC,wBAAwB,CACsC;AAmBvG;;;;;;;;;;;;;;;;;GAiBG;AACH,4CAFU,aAAa,CA2FpB;AAmBH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,2CAFU,aAAa,CAsIpB;yCA5VsC,mDAAmD;8BAD9D,+BAA+B"}