@woosh/meep-engine 3.65.0 → 3.68.0

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

@@ -0,0 +1,219 @@
+import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { chunk_get_ibl_radiance } from "../../deferred/indirect/chunk_get_ibl_radiance.js";
+import { DEPTH_STENCIL_FOREGROUND_ONLY } from "../../depth/DEPTH_STENCIL_FOREGROUND_ONLY.js";
+import { BSDF_ROUGHNESS_MINIMUM } from "../../light/environment/DEFINES.js";
+import { ENVIRONMENT_MAP_RESOURCE } from "../../light/environment/ENVIRONMENT_MAP_RESOURCE.js";
+import { ENVIRONMENT_MAP_SAMPLER_RESOURCE } from "../../light/environment/ENVIRONMENT_MAP_SAMPLER_RESOURCE.js";
+import { chunk_compute_specular_occlusion_bn } from "../../shader/chunk/brdf/chunk_compute_specular_occlusion_bn.js";
+import { chunk_MIN_DIELECTRICS_F0 } from "../../shader/chunk/brdf/chunk_MIN_DIELECTRICS_F0.js";
+import { chunk_project_position_from_depth } from "../../shader/chunk/camera/chunk_project_position_from_depth.js";
+import { chunk_mat4_extract_position } from "../../shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
+import { chunk_decode_g_buffer_normal } from "../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
+import { chunk_compute_indirect_specular } from "../../shader/chunk/material/chunk_compute_indirect_specular.js";
+import { chunk_decode_g_buffer_metalness } from "../../shader/chunk/material/chunk_decode_g_buffer_metalness.js";
+import { chunk_decode_g_buffer_roughness } from "../../shader/chunk/material/chunk_decode_g_buffer_roughness.js";
+import { chunk_metalness_to_specular_color } from "../../shader/chunk/material/chunk_metalness_to_specular_color.js";
+import { chunk_stbn_sample_vec2 } from "../../shader/chunk/noise/chunk_stbn_sample_vec2.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ImageShader } from "../../shader/ImageShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
+import { STBN_VEC2_RESOURCE } from "../../STATIC_GRAPHICS_ENGINE_ASSET_RESOURCES.js";
+import { SAMPLER_LINEAR_UPSCALE } from "../../texture/SAMPLER_LINEAR_UPSCALE.js";
+import { VIEW_UNIFORM_STRUCT } from "../../view/VIEW_UNIFORM_STRUCT.js";
+import {
+    chunk_probe_clipmap_pick,
+    PROBE_CLIPMAP_SAMPLING_GROUP
+} from "../probe_clipmap/probe/chunk_probe_clipmap_pick.js";
+import { chunk_probe_clipmap_sample_radiance } from "../probe_clipmap/probe/chunk_probe_clipmap_sample_radiance.js";
+import { SCREEN_PROBE_TILE_WORKGROUP_SIZE } from "./SCREEN_PROBE.js";
+import { ShaderResourceDescriptor } from "../../shader/resource/ShaderResourceDescriptor.js";
+
+const fused_resources = new ShaderResourceSetDescriptor();
+
+fused_resources.createGroup()
+    .addTexture("tDepth")
+    .addTexture("tNormals", "uint")
+    .addTexture("tBentNormals", "uint")
+    .addTexture("tGBufferAlbedo")
+    .addTexture("tGBufferPBR")
+    .addTexture("tScreenProbeDiffuse")
+    .add(STBN_VEC2_RESOURCE)
+    .addUniform("view", VIEW_UNIFORM_STRUCT)
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .add(ENVIRONMENT_MAP_RESOURCE)
+    .add(ENVIRONMENT_MAP_SAMPLER_RESOURCE)
+    .addSampler("sLinear", "filtering", SAMPLER_LINEAR_UPSCALE)
+    .addTexture("tSplitSum", "float");
+
+fused_resources.addGroup(PROBE_CLIPMAP_SAMPLING_GROUP);
+
+/**
+ * The screen probes' deferred indirect light in one pass, for SSR off: the diffuse is the screen probes' (the temporal
+ * filter's output, E at the bent normal), and the specular the world-space probes', picked and resolved as the probe
+ * clipmap's fused pass takes it (`probe_clipmap_radiance_of`), the environment's where no probe weighs anything. The
+ * two are resolved as `shader_resolve_indirect_lighting` resolves the IBL pair: AO multiplies the diffuse, the
+ * specular is occluded along its lobe, and the result is added to the scene's colour.
+ *
+ * @type {ImageShader}
+ */
+export const shader_screen_probe_indirect_lighting = ImageShader.from({
+    descriptor: ShaderDescriptor.from({
+        label: "Screen Probe / Indirect Lighting (Fused)",
+        resources: fused_resources,
+        body: CodeChunk.from(
+            //language=WGSL
+            `
+@fragment
+fn main(
+    @builtin(position) coord: vec4<f32>,
+    @location(0) uv: vec2<f32>,
+) -> @location(0) vec4<f32> {
+    let i_coord = vec2<u32>(coord.xy);
+
+    let depth = textureLoad(tDepth, i_coord, 0).r;
+    let texel_pbr = textureLoad(tGBufferPBR, i_coord, 0);
+    let albedo_ao = textureLoad(tGBufferAlbedo, i_coord, 0);
+
+    let albedo = albedo_ao.rgb;
+    let occlusion = albedo_ao.a;
+
+    let f_metalness = decode_g_buffer_metalness(texel_pbr);
+
+    // the radiance is sampled at the surface's roughness, as the IBL pass samples it; the resolve holds it off zero
+    let surface_roughness = decode_g_buffer_roughness(texel_pbr);
+    let roughness = max(surface_roughness, ${BSDF_ROUGHNESS_MINIMUM});
+    let alpha = roughness * roughness;
+
+    let position = project_position_from_depth(uv, depth, camera.view_projection_matrix_inverse);
+    let view_direction = normalize(mat4_extract_position(camera.transform) - position);
+
+    let normal = decode_g_buffer_normal(textureLoad(tNormals, i_coord, 0).x);
+    let bent_normal = decode_g_buffer_normal(textureLoad(tBentNormals, i_coord, 0).x);
+
+    let irradiance = textureLoad(tScreenProbeDiffuse, i_coord, 0).rgb;
+
+    let pick = probe_clipmap_pick(position, normal, view_direction, stbn_sample_vec2(vec3<u32>(i_coord, view.frame_index)));
+    let found = probe_clipmap_radiance_of(pick, position, normal, view_direction, surface_roughness);
+    let radiance = select(get_ibl_radiance(view_direction, normal, surface_roughness), found.radiance, found.found);
+
+    let indirect = compute_indirect_specular(
+        radiance,
+        irradiance * occlusion,
+        normal,
+        view_direction,
+        albedo * (1.0 - f_metalness),
+        metalness_to_specular_color(f_metalness, albedo),
+        vec3(MIN_DIELECTRICS_F0),
+        albedo,
+        1.0,
+        roughness,
+    );
+
+    let spec_direction = normalize(mix(reflect(-view_direction, normal), normal, alpha));
+    let specular_occlusion = compute_specular_occlusion_bn(spec_direction, bent_normal, occlusion, roughness);
+
+    return vec4(indirect[0] * specular_occlusion + indirect[1], 1.0);
+}
+`, [
+                chunk_project_position_from_depth,
+                chunk_mat4_extract_position,
+                chunk_decode_g_buffer_normal,
+                chunk_decode_g_buffer_metalness,
+                chunk_decode_g_buffer_roughness,
+                chunk_metalness_to_specular_color,
+                chunk_MIN_DIELECTRICS_F0,
+                chunk_stbn_sample_vec2,
+                chunk_probe_clipmap_pick,
+                chunk_probe_clipmap_sample_radiance,
+                chunk_get_ibl_radiance,
+                chunk_compute_indirect_specular,
+                chunk_compute_specular_occlusion_bn,
+            ]),
+    }),
+    targets: [
+        {
+            format: "rgba16float",
+            blend: {
+                color: {
+                    operation: "add",
+                    srcFactor: "one",
+                    dstFactor: "one",
+                },
+                alpha: {
+                    operation: "add",
+                    srcFactor: "zero",
+                    dstFactor: "one",
+                }
+            }
+        }
+    ],
+    depthStencil: DEPTH_STENCIL_FOREGROUND_ONLY,
+});
+
+const diffuse_resources = new ShaderResourceSetDescriptor();
+
+diffuse_resources.createGroup()
+    .addTexture("tGBufferAlbedo")
+    .addTexture("tScreenProbeDiffuse");
+
+/**
+ * The screen probes' deferred diffuse, for SSR on: the temporal filter's output, E at the bent normal, times AO, as
+ * the IBL pass bakes AO in at the source, so `shader_resolve_indirect_lighting` and SSR's hits read it as any mode's.
+ *
+ * @type {ImageShader}
+ */
+export const shader_screen_probe_diffuse = ImageShader.from({
+    descriptor: ShaderDescriptor.from({
+        label: "Screen Probe / Indirect Diffuse",
+        resources: diffuse_resources,
+        body: CodeChunk.from(
+            //language=WGSL
+            `
+@fragment
+fn main(
+    @builtin(position) coord: vec4<f32>,
+    @location(0) uv: vec2<f32>,
+) -> @location(0) vec4<f32> {
+    let i_coord = vec2<u32>(coord.xy);
+
+    return vec4<f32>(textureLoad(tScreenProbeDiffuse, i_coord, 0).rgb * textureLoad(tGBufferAlbedo, i_coord, 0).a, 0.0);
+}
+`),
+    }),
+    depthStencil: DEPTH_STENCIL_FOREGROUND_ONLY,
+    targets: [{
+        label: "Diffuse Indirect lighting",
+        format: "rgba16float"
+    }]
+});
+
+const capture_resources = new ShaderResourceSetDescriptor();
+
+capture_resources.createGroup()
+    .add(ShaderResourceDescriptor.texture("tColor", "unfilterable-float"))
+    .add(ShaderResourceDescriptor.storageTexture("screen_probe_color_history", "rgba16float", "2d", "write-only"));
+
+/**
+ * Keep the frame's lit colour of the opaque surfaces for the next frame's screen traces: a thread a pixel, copied as
+ * it stands once the indirect light is added, before fog and transparencies, which are not the surfaces' radiance.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_screen_probe_color_capture = ComputeShader.from({
+    label: "Screen Probe Color Capture",
+    resources: capture_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>) {
+    if (any(id.xy >= textureDimensions(tColor, 0))) {
+        return;
+    }
+
+    textureStore(screen_probe_color_history, id.xy, textureLoad(tColor, id.xy, 0));
+}
+`),
+});

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

@@ -0,0 +1,22 @@
+/**
+ * Where a screen probe's rays leave from in the bricks, and what answers for them past their reach (Lumen's radiance
+ * cache coverage), a thread a probe, dispatched through the frame's thread-a-probe command:
+ *
+ * - **The origin** (`screen_probe_brick_origin`): off the probe's surface point along its face normal, and on along
+ *   the bricks' field until it reads a voxel clear, so its rays do not start in the solid they leave.
+ * - **The pick**: the world-space probes around the probe's surface point, picked as a pixel there picks them for its
+ *   own light (`probe_clipmap_pick`): by the face normal and the view, two of a cage's eight by the visibility of the
+ *   point, with the frame's blue noise at the probe's pixel. Every ray of the probe that reaches its reach unoccluded
+ *   reads their radiance along its own direction.
+ * - **The reach**: `SCREEN_PROBE_REACH_SPACINGS` spacings of the coarsest cascade the pick drew from, the furthest a
+ *   corner it reads stands from the point. Where nothing weighs anything, a ray is traced through the whole world
+ *   (`brick_t_max`) and nothing stands in for what it does not reach.
+ * - **Its wants**: each probe on a surface wants the cages its pick reads, in the world-space probes' late set, so a
+ *   probe its rays read is there whether or not a pixel's pick wants it. Every lane calls `probe_clipmap_want`,
+ *   wanting or not, from uniform control flow.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_screen_probe_pick: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_screen_probe_pick.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_screen_probe_pick.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/screen_probe/shader_screen_probe_pick.js"],"names":[],"mappings":"AAyDA;;;;;;;;;;;;;;;;;;GAkBG;AACH,uCAFU,aAAa,CA4EpB;8BA/I2B,+BAA+B"}

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

@@ -0,0 +1,151 @@
+import { chunk_mat4_extract_position } from "../../shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
+import {
+    chunk_uv_octahedral_unit_decode
+} from "../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_decode.js";
+import { chunk_folded_workgroup_index } from "../../shader/chunk/grid/chunk_folded_workgroup_index.js";
+import { chunk_stbn_sample_vec2 } from "../../shader/chunk/noise/chunk_stbn_sample_vec2.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { STBN_VEC2_RESOURCE } from "../../STATIC_GRAPHICS_ENGINE_ASSET_RESOURCES.js";
+import {
+    BRICK_ATLAS_TEXTURE_RESOURCE,
+    BRICK_LEVELS_RESOURCE,
+    BRICK_MAP_TEXTURE_RESOURCE,
+    BRICK_SAMPLER_RESOURCE
+} from "../probe_clipmap/brick/chunk_brick_clipmap_trace.js";
+import { PROBE_WANTED_BITS_RESOURCE, PROBE_WANTED_WRITE_RESOURCE } from "../probe_clipmap/probe/chunk_probe_clipmap.js";
+import {
+    chunk_probe_clipmap_pick,
+    PROBE_CLIPMAP_SAMPLING_GROUP
+} from "../probe_clipmap/probe/chunk_probe_clipmap_pick.js";
+import { chunk_probe_clipmap_want } from "../probe_clipmap/probe/chunk_probe_clipmap_want.js";
+import { PROBE_RECEIVER_BIAS_VIEW } from "../probe_clipmap/probe/PROBE_CLIPMAP.js";
+import { PROBE_WANT_SETTINGS } from "../probe_clipmap/probe/shader_probe_clipmap_want.js";
+import {
+    chunk_screen_probe,
+    chunk_screen_probe_counts,
+    SCREEN_PROBE_DISPATCH_READ_RESOURCE,
+    SCREEN_PROBE_FRAME_RESOURCE,
+    SCREEN_PROBE_PICKS_WRITE_RESOURCE,
+    SCREEN_PROBES_READ_RESOURCE
+} from "./chunk_screen_probe.js";
+import { chunk_screen_probe_brick_origin } from "./chunk_screen_probe_brick_origin.js";
+import { SCREEN_PROBE_CAMERA_RESOURCE } from "./chunk_screen_probe_surface.js";
+import { SCREEN_PROBE_REACH_SPACINGS, SCREEN_PROBE_THREAD_WORKGROUP_SIZE } from "./SCREEN_PROBE.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+// the world-space probes' late wants, as `GPUProbeClipmap#write_want_bindings` hands them
+resources.setImmediate("settings", PROBE_WANT_SETTINGS);
+
+resources.createGroup()
+    .add(SCREEN_PROBE_FRAME_RESOURCE)
+    .add(SCREEN_PROBE_CAMERA_RESOURCE)
+    .add(SCREEN_PROBES_READ_RESOURCE)
+    .add(SCREEN_PROBE_PICKS_WRITE_RESOURCE)
+    .add(SCREEN_PROBE_DISPATCH_READ_RESOURCE)
+    .add(STBN_VEC2_RESOURCE)
+    .add(PROBE_WANTED_WRITE_RESOURCE)
+    .add(PROBE_WANTED_BITS_RESOURCE)
+    .add(BRICK_LEVELS_RESOURCE)
+    .add(BRICK_MAP_TEXTURE_RESOURCE)
+    .add(BRICK_ATLAS_TEXTURE_RESOURCE)
+    .add(BRICK_SAMPLER_RESOURCE);
+
+resources.addGroup(PROBE_CLIPMAP_SAMPLING_GROUP);
+
+/**
+ * Where a screen probe's rays leave from in the bricks, and what answers for them past their reach (Lumen's radiance
+ * cache coverage), a thread a probe, dispatched through the frame's thread-a-probe command:
+ *
+ * - **The origin** (`screen_probe_brick_origin`): off the probe's surface point along its face normal, and on along
+ *   the bricks' field until it reads a voxel clear, so its rays do not start in the solid they leave.
+ * - **The pick**: the world-space probes around the probe's surface point, picked as a pixel there picks them for its
+ *   own light (`probe_clipmap_pick`): by the face normal and the view, two of a cage's eight by the visibility of the
+ *   point, with the frame's blue noise at the probe's pixel. Every ray of the probe that reaches its reach unoccluded
+ *   reads their radiance along its own direction.
+ * - **The reach**: `SCREEN_PROBE_REACH_SPACINGS` spacings of the coarsest cascade the pick drew from, the furthest a
+ *   corner it reads stands from the point. Where nothing weighs anything, a ray is traced through the whole world
+ *   (`brick_t_max`) and nothing stands in for what it does not reach.
+ * - **Its wants**: each probe on a surface wants the cages its pick reads, in the world-space probes' late set, so a
+ *   probe its rays read is there whether or not a pixel's pick wants it. Every lane calls `probe_clipmap_want`,
+ *   wanting or not, from uniform control flow.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_screen_probe_pick = ComputeShader.from({
+    label: "Screen Probe Pick",
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+// the spacing of a picked probe's cascade, or zero for a share of nothing
+fn screen_probe_picked_spacing(slot: u32, weight: f32) -> f32 {
+    if (weight <= 0.0) {
+        return 0.0;
+    }
+
+    return probe_levels[probe_record_cascade(probe_records[slot].flags)].cell_size;
+}
+
+@compute @workgroup_size(${SCREEN_PROBE_THREAD_WORKGROUP_SIZE})
+fn main(
+    @builtin(workgroup_id) workgroup_id: vec3<u32>,
+    @builtin(local_invocation_index) lane: u32,
+) {
+    let probe = folded_workgroup_index(workgroup_id) * ${SCREEN_PROBE_THREAD_WORKGROUP_SIZE}u + lane;
+
+    var wants = false;
+    var position = vec3<f32>(0.0);
+    var bias_direction = vec3<f32>(0.0, 0.0, 1.0);
+
+    if (probe < screen_probe_count()) {
+        let record = screen_probes[probe];
+
+        var pick: ScreenProbePick;
+
+        pick.reach = screen_probe_frame.brick_t_max;
+
+        if (record.depth > 0.0) {
+            let normal = uv_octahedral_unit_decode(unpack2x16unorm(record.normal));
+            let view_direction = normalize(mat4_extract_position(camera.transform) - record.position);
+            let noise = stbn_sample_vec2(vec3<u32>(screen_probe_pixel_decode(record.pixel), screen_probe_frame.frame_index));
+            let found = probe_clipmap_pick(record.position, normal, view_direction, noise);
+
+            pick.slots = found.slots;
+            pick.weights = found.weights;
+            pick.origin = screen_probe_brick_origin(record.position, normal, screen_probe_frame.brick_cascade_count, screen_probe_frame.brick_atlas_shift);
+
+            // each share by name: an index into the vectors would put them in local memory
+            let spacing = max(
+                max(screen_probe_picked_spacing(found.slots.x, found.weights.x), screen_probe_picked_spacing(found.slots.y, found.weights.y)),
+                max(screen_probe_picked_spacing(found.slots.z, found.weights.z), screen_probe_picked_spacing(found.slots.w, found.weights.w)),
+            );
+
+            if (spacing > 0.0) {
+                pick.reach = ${SCREEN_PROBE_REACH_SPACINGS} * spacing;
+            }
+
+            wants = true;
+            position = record.position;
+            bias_direction = mix(normal, view_direction, ${PROBE_RECEIVER_BIAS_VIEW});
+        }
+
+        screen_probe_picks[probe] = pick;
+    }
+
+    probe_clipmap_want(wants, position, bias_direction, settings.cascade_count, settings.resolution, settings.anchor, settings.select_half, settings.wanted_capacity);
+}
+`, [
+            chunk_screen_probe,
+            chunk_screen_probe_counts,
+            chunk_folded_workgroup_index,
+            chunk_uv_octahedral_unit_decode,
+            chunk_mat4_extract_position,
+            chunk_stbn_sample_vec2,
+            chunk_probe_clipmap_pick,
+            chunk_probe_clipmap_want,
+            chunk_screen_probe_brick_origin,
+        ]),
+});

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

@@ -0,0 +1,66 @@
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * Settings of one level of adaptive placement.
+ * @type {WebGPUStruct}
+ */
+export const SCREEN_PROBE_ADAPTIVE_SETTINGS: WebGPUStruct;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * Settings of the bricks' command.
+ * @type {WebGPUStruct}
+ */
+export const SCREEN_PROBE_BRICK_COMMAND_SETTINGS: WebGPUStruct;
+/**
+ * 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;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+//# sourceMappingURL=shader_screen_probe_place.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_screen_probe_place.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/screen_probe/shader_screen_probe_place.js"],"names":[],"mappings":"AA+CA;;;;;;;;;;GAUG;AACH,wCAFU,SAAS,CAQhB;AAkBH;;;;;;GAMG;AACH,gDAFU,aAAa,CA2BpB;AAEH;;;GAGG;AACH,6CAFU,YAAY,CAKY;AAclC;;;;;;;;;;;;;;;GAeG;AACH,iDAFU,aAAa,CAyDpB;AASH;;;;;;GAMG;AACH,0CAFU,aAAa,CAiCpB;AAEH;;;GAGG;AACH,kDAFU,YAAY,CAKgB;AAUtC;;;;;GAKG;AACH,gDAFU,aAAa,CAsBpB;0BAnSuB,oCAAoC;8BAChC,+BAA+B;6BAGhC,mCAAmC"}