@woosh/meep-engine 3.57.0 → 3.59.0

package/src/shade/renderer/volumetrics/shader_volumetrics_cull_sun_shadow_media.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Threads of a sun-shadow volume cull workgroup, each taking one volume.
+ * @type {number}
+ */
+export const VOLUMETRICS_SUN_SHADOW_CULL_LANES: number;
+/**
+ * Broad-phase cull of the scene's participating-media volumes against one sun optical-depth
+ * cascade's world-space box. One thread per volume. For the outermost cascade, the sun-side face is
+ * extended to `-F32_MAX` so volumes between the sun and the cascade's `w = 0` entry plane are also
+ * retained for the upwind brick layer.
+ *
+ * `cascade_field` starts at a count of zero; the frame graph clears it.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_volumetrics_cull_sun_shadow_media: ComputeShader;
+import { ComputeShader } from "../shader/ComputeShader.js";
+//# sourceMappingURL=shader_volumetrics_cull_sun_shadow_media.d.ts.map

package/src/shade/renderer/volumetrics/shader_volumetrics_cull_sun_shadow_media.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_volumetrics_cull_sun_shadow_media.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_cull_sun_shadow_media.js"],"names":[],"mappings":"AAcA;;;GAGG;AACH,gDAFU,MAAM,CAEoC;AAYpD;;;;;;;;;GASG;AACH,uDAFU,aAAa,CA6CpB;8BAjF2B,4BAA4B"}

package/src/shade/renderer/volumetrics/shader_volumetrics_cull_sun_shadow_media.js

@@ -0,0 +1,84 @@
+import { F32_MAX_DEFINITION } from "../shader/chunk/math/F32_MAX_DEFINITION.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
+import { WebGPUArray } from "../shader/type/WebGPUArray.js";
+import { chunk_participating_media_volumes_iterate } from "./chunk_participating_media_volumes_iterate.js";
+import {
+    chunk_volumetrics_sun_shadow_group_list,
+    VOLUMETRICS_SUN_SHADOW_BIN_SETTINGS
+} from "./chunk_volumetrics_sun_shadow_group_list.js";
+import { VOLUMETRICS_MEDIA_VOLUME_LIST_APPEND } from "./shader_volumetrics_split_participating_media.js";
+import { VOLUMETRICS_METADATA_STRUCT } from "./VOLUMETRICS_METADATA_STRUCT.js";
+import { VOLUMETRICS_SUN_SHADOW_CASCADE_COUNT } from "./VOLUMETRICS_SUN_SHADOW_RESOLUTION.js";
+
+/**
+ * Threads of a sun-shadow volume cull workgroup, each taking one volume.
+ * @type {number}
+ */
+export const VOLUMETRICS_SUN_SHADOW_CULL_LANES = 64;
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", VOLUMETRICS_SUN_SHADOW_BIN_SETTINGS);
+
+resources.createGroup()
+    .addUniform("volumetrics_metadata", VOLUMETRICS_METADATA_STRUCT)
+    .addStorageBuffer("scene_database", WebGPUArray.u32)
+    .addStorageBuffer("cascade_field", VOLUMETRICS_MEDIA_VOLUME_LIST_APPEND, true)
+;
+
+/**
+ * Broad-phase cull of the scene's participating-media volumes against one sun optical-depth
+ * cascade's world-space box. One thread per volume. For the outermost cascade, the sun-side face is
+ * extended to `-F32_MAX` so volumes between the sun and the cascade's `w = 0` entry plane are also
+ * retained for the upwind brick layer.
+ *
+ * `cascade_field` starts at a count of zero; the frame graph clears it.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_volumetrics_cull_sun_shadow_media = ComputeShader.from({
+    label: "Volumetrics / cull sun shadow media",
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(${VOLUMETRICS_SUN_SHADOW_CULL_LANES})
+fn main(
+    @builtin(global_invocation_id) id: vec3<u32>,
+) {
+    let v = id.x;
+
+    if (v >= participating_media_volumes_count(&scene_database)) {
+        return;
+    }
+
+    let cascade = settings.cascade;
+    let ws_to_uvw = volumetrics_metadata.sun_shadow_ws_to_uvw[cascade];
+    let uvw_to_ws = volumetrics_metadata.sun_shadow_uvw_to_ws[cascade];
+
+    let pad = vec3<f32>(0.25) / vec3<f32>(max(settings.resolution, vec3<u32>(1u)));
+    let uvw_min = vec3<f32>(
+        -pad.xy,
+        select(-pad.z, -F32_MAX, cascade == ${VOLUMETRICS_SUN_SHADOW_CASCADE_COUNT - 1}u),
+    );
+    let uvw_max = vec3<f32>(1.0) + pad;
+
+    let volume = participating_media_volume_read(&scene_database, v);
+
+    if (volumetrics_volume_in_sun_box(uvw_min, uvw_max, ws_to_uvw, uvw_to_ws, volume)) {
+        let slot = atomicAdd(&cascade_field.count, 1u);
+
+        if (slot < arrayLength(&cascade_field.indices)) {
+            cascade_field.indices[slot] = v;
+        }
+    }
+}
+        `, [
+            F32_MAX_DEFINITION,
+            chunk_participating_media_volumes_iterate,
+            chunk_volumetrics_sun_shadow_group_list,
+        ]
+    ),
+});

package/src/shade/renderer/volumetrics/shader_volumetrics_split_participating_media.d.ts

@@ -3,6 +3,10 @@
  * count)`, in no particular order.
  */
 export const VOLUMETRICS_MEDIA_VOLUME_LIST: WebGPUStruct;
+/**
+ * {@link VOLUMETRICS_MEDIA_VOLUME_LIST} as the split appends to it, from a count of zero.
+ */
+export const VOLUMETRICS_MEDIA_VOLUME_LIST_APPEND: WebGPUStruct;
 /**
  * Threads of a split workgroup, each taking one volume.
  * @type {number}

package/src/shade/renderer/volumetrics/shader_volumetrics_split_participating_media.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_volumetrics_split_participating_media.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_split_participating_media.js"],"names":[],"mappings":"AAgBA;;;GAGG;AACH,yDAGiC;AAUjC;;;GAGG;AACH,4CAFU,MAAM,CAEgC;AAYhD;;;;;;;;;;;;;;;;GAgBG;AACH,yEAwEG;6BA/H0B,gCAAgC;8BAJ/B,4BAA4B"}
+{"version":3,"file":"shader_volumetrics_split_participating_media.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_split_participating_media.js"],"names":[],"mappings":"AAgBA;;;GAGG;AACH,yDAGiC;AAEjC;;GAEG;AACH,gEAGuC;AAEvC;;;GAGG;AACH,4CAFU,MAAM,CAEgC;AAYhD;;;;;;;;;;;;;;;;GAgBG;AACH,yEAwEG;6BA/H0B,gCAAgC;8BAJ/B,4BAA4B"}

package/src/shade/renderer/volumetrics/shader_volumetrics_split_participating_media.js

@@ -26,7 +26,7 @@ export const VOLUMETRICS_MEDIA_VOLUME_LIST = WebGPUStruct.from({
 /**
  * {@link VOLUMETRICS_MEDIA_VOLUME_LIST} as the split appends to it, from a count of zero.
  */
-const VOLUMETRICS_MEDIA_VOLUME_LIST_APPEND = WebGPUStruct.from({
+export const VOLUMETRICS_MEDIA_VOLUME_LIST_APPEND = WebGPUStruct.from({
     count: atomic_u32,
     indices: WebGPUArray.u32,
 }, "VolumetricsMediaVolumeListAppend");

package/src/shade/renderer/volumetrics/taa/shader_volumetrics_taa.js

@@ -1,5 +1,5 @@
 import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
-import { F16_MAX_DEFINITION } from "../../shader/chunk/math/F16_MAX_DEFINITION.js";
+import { F16_MAX_DEFINITION } from "../../shader/chunk/math/F16_MAX_DEFINITION.js";
 import { F32_MAX_DEFINITION } from "../../shader/chunk/math/F32_MAX_DEFINITION.js";
 import { chunk_rgb_to_YCoCg } from "../../shader/chunk/color/YCoCg/chunk_rgb_to_YCoCg.js";
 import { chunk_YCoCg_to_rgb } from "../../shader/chunk/color/YCoCg/chunk_YCoCg_to_rgb.js";
@@ -128,7 +128,7 @@ fn main(@builtin(global_invocation_id) voxel_id: vec3<u32>) {
      value is history, get_std_dev4 in the neighbourhood box turns Inf - Inf into NaN, the clip
      returns NaN, and mix(NaN, center, 0.05) is NaN for every frame after that. Camera motion does
      not clear it and the aerial LUT reads the whole screen column behind it through it; only a
-     resize or a curve change does, via history_reset.
+     curve change does, via history_reset.
 
      Guarding the STORE rather than the two blend operands is what makes that a closed statement:
      whatever the resolve did, the froxel this frame either carries a finite value or carries this
@@ -142,12 +142,12 @@ fn main(@builtin(global_invocation_id) voxel_id: vec3<u32>) {
 
     let final_finite = all(final_color == final_color) && all(abs(final_color) < vec4f(F32_MAX));
 
-    let final_safe = select(current_safe, clamp(final_color, vec4f(0.0), vec4f(F16_MAX)), final_finite);
+    let final_safe = select(current_safe, clamp(final_color, vec4f(0.0), vec4f(F16_MAX)), final_finite);
     textureStore(t_output, voxel_id, final_safe);
 }
     `,
     [
-        F16_MAX_DEFINITION,
+        F16_MAX_DEFINITION,
         F32_MAX_DEFINITION,
         chunk_rgb_to_YCoCg,
         chunk_YCoCg_to_rgb,

package/src/shade/renderer/water/GPUWaterRenderer.d.ts

@@ -42,7 +42,7 @@ export class GPUWaterRenderer {
     /** Optional single-pixel readback on the next rendered water frame. No per-frame readback. */
     request_probe(uv: any): Promise<any>;
     dispose(): void;
-    avboit_prepare({ graph, view_ctx, camera, color_texture, depth_texture, normal_texture, hzb_texture, environment_texture, light_cluster_parameters, light_cluster_lookup, light_cluster_data, shadowmap_atlas, shader_switches }: {
+    avboit_prepare({ graph, view_ctx, camera, color_texture, depth_texture, normal_texture, hzb_texture, environment_texture, light_cluster_parameters, light_cluster_lookup, light_cluster_data, shadowmap_atlas, shader_switches, probes }: {
         graph: any;
         view_ctx: any;
         camera: any;
@@ -56,6 +56,7 @@ export class GPUWaterRenderer {
         light_cluster_data: any;
         shadowmap_atlas: any;
         shader_switches?: ShaderSwitchSet;
+        probes: any;
     }): {
         background_color: any;
     };

package/src/shade/renderer/water/GPUWaterRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUWaterRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/GPUWaterRenderer.js"],"names":[],"mappings":"AAmBA,sFAAsF;AACtF;IACI,WAAa;IACb,mBAAe;IACf,yBAAqB;IACrB,aAAS;IACT,WAAa;IACb;;;;;;;;;;;MAE6B;IAC7B;;;;OAIG;IACH,QAFU,OAAO,4BAA4B,EAAE,cAAc,GAAC,IAAI,CAEpD;IAmBd;;;OAGG;IACH;;;;;MAA8F;IAC9F;;;OAGG;IACH,wBAAyD;IAMzD,oCAIC;IAED,8FAA8F;IAC9F,qCAgBC;IAED,gBASC;IAuDD;;;;;;;;;;;;;;;;MAoIC;IAQD;;;;;YAMC;IAED;;;;;;;;;;MAOC;IAED;;;;;;;;;;;;;;MAwBC;IAED,gGAAgG;IAChG,mEAYC;;CA2BJ;gCAxX+B,uCAAuC"}
+{"version":3,"file":"GPUWaterRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/GPUWaterRenderer.js"],"names":[],"mappings":"AAoBA,sFAAsF;AACtF;IACI,WAAa;IACb,mBAAe;IACf,yBAAqB;IACrB,aAAS;IACT,WAAa;IACb;;;;;;;;;;;MAE6B;IAC7B;;;;OAIG;IACH,QAFU,OAAO,4BAA4B,EAAE,cAAc,GAAC,IAAI,CAEpD;IAmBd;;;OAGG;IACH;;;;;MAA8F;IAC9F;;;OAGG;IACH,wBAAyD;IAMzD,oCAIC;IAED,8FAA8F;IAC9F,qCAgBC;IAED,gBASC;IAuDD;;;;;;;;;;;;;;;;;MAuIC;IAQD;;;;;YAMC;IAED;;;;;;;;;;MAOC;IAED;;;;;;;;;;;;;;MAwBC;IAED,gGAAgG;IAChG,mEAYC;;CA2BJ;gCA3X+B,uCAAuC"}

package/src/shade/renderer/water/GPUWaterRenderer.js

@@ -1,3 +1,4 @@
+import { assert } from "../../../core/assert.js";
 import { TextureResourceDescriptor } from "../../device/graph/TextureResourceDescriptor.js";
 import { DEFAULT_DEPTH_TEXTURE_VIEW } from "../depth/DEFAULT_DEPTH_TEXTURE_VIEW.js";
 import { graph_compute_pass } from "../shader/graph/compute/graph_compute_pass.js";
@@ -157,7 +158,8 @@ export class GPUWaterRenderer {
 
     avboit_prepare({ graph, view_ctx, camera, color_texture, depth_texture, normal_texture,
         hzb_texture, environment_texture, light_cluster_parameters, light_cluster_lookup, light_cluster_data,
-        shadowmap_atlas, shader_switches = ShaderSwitchSet.EMPTY }) {
+        shadowmap_atlas, shader_switches = ShaderSwitchSet.EMPTY, probes }) {
+        assert.defined(probes, 'probes');
         const scene = view_ctx.scene;
         const settings = { ...this.settings };
         const probe = this.#probe;
@@ -257,6 +259,8 @@ export class GPUWaterRenderer {
                 brick4: view_ctx.scene.volumetric_light_map.buffer,
                 view: view_ctx.uniform_buffer.buffer,
             };
+            // the probes in every mode: a clipmap of no cascade while the probe clipmap has none
+            probes.write_sampling_bindings(shared);
             const bindings = WATER_FINALIZE_RESOURCES.generateBindings(shared, encoder);
             const copy_pipeline = shader_water_background_copy.pipeline;
             const copy_bindings = shader_water_background_copy.descriptor.resources.generateBindings({tScene: shared.tScene}, encoder);

package/src/shade/renderer/water/chunk_water_gi.d.ts

@@ -10,10 +10,20 @@ export const chunk_water_gi_ibl: CodeChunk;
  * @type {CodeChunk}
  */
 export const chunk_water_gi_brick4: CodeChunk;
+/**
+ * The probe clipmap (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §9.5): each call one pick at the point, jittered by a
+ * hash of the point and the normal, as Brick4's is. The irradiance is π × the picked SH resolved at the normal,
+ * the normal standing in for the view, which the irradiance call has none of. The specular is the probes'
+ * radiance picked by the normal and the view (§9.3). Where no probe weighs anything, each is the environment's.
+ * Reads the probes' group, `view` and `tEnvironment`.
+ * @type {CodeChunk}
+ */
+export const chunk_water_gi_probe_clipmap: CodeChunk;
 /**
  * The water's indirect lighting by the renderer's mode ({@link INDIRECT_LIGHTING}): IBL and LPV
- * {@link chunk_water_gi_ibl}, Brick4 {@link chunk_water_gi_brick4}. A pipeline that links it binds
- * `tEnvironment`, `brick4` and `view`, and reads only its own mode's.
+ * {@link chunk_water_gi_ibl}, Brick4 {@link chunk_water_gi_brick4}, ProbeClipmap
+ * {@link chunk_water_gi_probe_clipmap}. A pipeline that links it binds `tEnvironment`, `brick4`, the probes'
+ * group and `view`, and reads only its own mode's.
  * @type {CodeChunkChoice}
  */
 export const chunk_water_gi: CodeChunkChoice;

package/src/shade/renderer/water/chunk_water_gi.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_water_gi.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/chunk_water_gi.js"],"names":[],"mappings":"AAuBA;;;;GAIG;AACH,iCAFU,SAAS,CAUoC;AAEvD;;;;GAIG;AACH,oCAFU,SAAS,CAgBwB;AAE3C;;;;;GAKG;AACH,6BAFU,eAAe,CAE6C;0BA1D5C,iCAAiC;gCAC3B,uCAAuC"}
+{"version":3,"file":"chunk_water_gi.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/chunk_water_gi.js"],"names":[],"mappings":"AAiCA;;;;GAIG;AACH,iCAFU,SAAS,CAUoC;AAEvD;;;;GAIG;AACH,oCAFU,SAAS,CAgBwB;AAE3C;;;;;;;GAOG;AACH,2CAFU,SAAS,CAwB+E;AAElG;;;;;;GAMG;AACH,6BAFU,eAAe,CAE6C;0BA5F5C,iCAAiC;gCAC3B,uCAAuC"}

package/src/shade/renderer/water/chunk_water_gi.js

@@ -3,8 +3,17 @@ import { chunk_get_ibl_radiance } from "../deferred/indirect/chunk_get_ibl_radia
 import {
     chunk_brick4_sample_forward_indirect
 } from "../global_illumination/brick4/gpu/draw/chunk_brick4_sample_forward_indirect.js";
+import { chunk_probe_clipmap_pick } from "../global_illumination/probe_clipmap/probe/chunk_probe_clipmap_pick.js";
+import {
+    chunk_probe_clipmap_sample_radiance
+} from "../global_illumination/probe_clipmap/probe/chunk_probe_clipmap_sample_radiance.js";
 import { INDIRECT_LIGHTING } from "../INDIRECT_LIGHTING.js";
 import { ShadeIndirectLightingMode } from "../ShadeIndirectLightingMode.js";
+import { PI_DECLARATION } from "../shader/chunk/math/PI_DECLARATION.js";
+import { chunk_jitter_from_vectors } from "../shader/chunk/random/chunk_jitter_from_vectors.js";
+import {
+    chunk_resolve_irradiance_sh_to_diffuse
+} from "../shader/chunk/spherical_harmonics/l1i/chunk_resolve_irradiance_sh_to_diffuse.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 import { CodeChunkChoice } from "../shader/compiler/CodeChunkChoice.js";
 
@@ -19,6 +28,7 @@ import { CodeChunkChoice } from "../shader/compiler/CodeChunkChoice.js";
    missed on screen falls back to. view_direction points from the surface to the camera.
 
  LPV has no transparent sampling: like the transparent meshes, water uses the environment under it.
+ The probe clipmap gives both from its probes, the environment where none weighs anything.
 */
 
 /**
@@ -57,10 +67,43 @@ fn water_gi_specular(position: vec3<f32>, normal: vec3<f32>, view_direction: vec
 }
 `, [chunk_brick4_sample_forward_indirect]);
 
+/**
+ * The probe clipmap (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §9.5): each call one pick at the point, jittered by a
+ * hash of the point and the normal, as Brick4's is. The irradiance is π × the picked SH resolved at the normal,
+ * the normal standing in for the view, which the irradiance call has none of. The specular is the probes'
+ * radiance picked by the normal and the view (§9.3). Where no probe weighs anything, each is the environment's.
+ * Reads the probes' group, `view` and `tEnvironment`.
+ * @type {CodeChunk}
+ */
+export const chunk_water_gi_probe_clipmap = CodeChunk.from(/* language=WGSL */ `
+fn water_gi_irradiance(position: vec3<f32>, normal: vec3<f32>) -> vec3<f32> {
+    let probes = probe_clipmap_sample_sh(position, normal, normal, jitter_from_vectors(position, normal));
+
+    if (probes.found) {
+        // the resolve gives E/π
+        return PI * resolve_irradiance_sh_to_diffuse(probes.sh.Y, probes.sh.CoCg, normal);
+    }
+
+    return get_ibl_irradiance(normal);
+}
+
+fn water_gi_specular(position: vec3<f32>, normal: vec3<f32>, view_direction: vec3<f32>, roughness: f32) -> vec3<f32> {
+    let probes = probe_clipmap_sample_radiance(position, normal, view_direction, roughness, jitter_from_vectors(position, normal));
+
+    if (probes.found) {
+        return probes.radiance;
+    }
+
+    return get_ibl_radiance(view_direction, normal, roughness);
+}
+`, [chunk_probe_clipmap_pick, chunk_probe_clipmap_sample_radiance, chunk_resolve_irradiance_sh_to_diffuse,
+    chunk_jitter_from_vectors, PI_DECLARATION, chunk_get_ibl_irradiance, chunk_get_ibl_radiance]);
+
 /**
  * The water's indirect lighting by the renderer's mode ({@link INDIRECT_LIGHTING}): IBL and LPV
- * {@link chunk_water_gi_ibl}, Brick4 {@link chunk_water_gi_brick4}. A pipeline that links it binds
- * `tEnvironment`, `brick4` and `view`, and reads only its own mode's.
+ * {@link chunk_water_gi_ibl}, Brick4 {@link chunk_water_gi_brick4}, ProbeClipmap
+ * {@link chunk_water_gi_probe_clipmap}. A pipeline that links it binds `tEnvironment`, `brick4`, the probes'
+ * group and `view`, and reads only its own mode's.
  * @type {CodeChunkChoice}
  */
 export const chunk_water_gi = CodeChunkChoice.from(INDIRECT_LIGHTING);
@@ -68,3 +111,4 @@ export const chunk_water_gi = CodeChunkChoice.from(INDIRECT_LIGHTING);
 chunk_water_gi.add(ShadeIndirectLightingMode.IBL, chunk_water_gi_ibl);
 chunk_water_gi.add(ShadeIndirectLightingMode.Brick4, chunk_water_gi_brick4);
 chunk_water_gi.add(ShadeIndirectLightingMode.LPV, chunk_water_gi_ibl);
+chunk_water_gi.add(ShadeIndirectLightingMode.ProbeClipmap, chunk_water_gi_probe_clipmap);

package/src/shade/renderer/water/query/GPUWaterQueries.d.ts

@@ -0,0 +1,127 @@
+/**
+ * @typedef {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} FrameGraph
+ * @typedef {import("../surface/GPUWaterSurface.js").GPUWaterSurface} GPUWaterSurface
+ * @typedef {import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
+ */
+/**
+ * Floats a query sample lands as in a request's target: the displaced world height `y`, followed by
+ * the unpacked world-space unit normal `(nx, ny, nz)`.
+ * @type {number}
+ */
+export const WATER_QUERY_SAMPLE_FLOATS: number;
+/**
+ * # The GPU water surface read API, on the device
+ *
+ * Evaluates displaced water height and world-space normal at batches of local `(x, z)` points on
+ * water bodies, reading the compact 8-byte `(f32 height, u32 octahedral_normal)` rows back to the
+ * CPU and unpacking them into the caller's `Float32Array` target as 4 floats per sample
+ * (`[world_height, nx, ny, nz]`).
+ */
+export class GPUWaterQueries {
+    /**
+     * Offer the pipelines the read API dispatches — see {@link PipelineEnquiry}.
+     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry: PipelineEnquiry): void;
+    static "__#273@#execute"(pass: any, resources: any, context: any): void;
+    /**
+     * @param {object} options
+     * @param {GPUDevice} options.device
+     */
+    constructor({ device }: {
+        device: GPUDevice;
+    });
+    /**
+     * The read API's database. For inspection.
+     * @returns {GPUDatabase}
+     */
+    get database(): GPUDatabase;
+    /**
+     * The readback the samples travel through. For inspection.
+     * @returns {GPUDatabaseReadback}
+     */
+    get readback(): GPUDatabaseReadback;
+    /**
+     * Requests holding rows: recorded and not yet delivered or dropped.
+     * @returns {number}
+     */
+    get in_flight_count(): number;
+    /**
+     * Rows of `water_query`: one per request in flight.
+     * @returns {number}
+     */
+    get query_count(): number;
+    /**
+     * Rows of `water_query_sample`: the sample points of every request in flight.
+     * @returns {number}
+     */
+    get sample_count(): number;
+    /**
+     * Requests the last {@link apply} (or {@link destroy}) settled.
+     * @returns {number}
+     */
+    get settled_count(): number;
+    /**
+     * @param {number} index below {@link settled_count}
+     * @returns {number} the tag the settled request was asked with
+     */
+    settled_tag(index: number): number;
+    /**
+     * @param {number} index below {@link settled_count}
+     * @returns {number} a {@link GPUReadbackStatus}: `Delivered`, its samples now unpacked into its
+     *   target, or `Dropped`
+     */
+    settled_status(index: number): number;
+    /**
+     * Ask for `sample_count` water surface samples on `water_bodies` row `body`, at local `(x, z)`
+     * coordinates read from `local_xz` starting at `local_xz_offset`. When settled `Delivered`,
+     * each sample is unpacked into `target` from `target_offset` as {@link WATER_QUERY_SAMPLE_FLOATS}
+     * floats (`[world_height, nx, ny, nz]`).
+     *
+     * @param {number} body row in `water_bodies`
+     * @param {ArrayLike<number>} local_xz interleaved `[x0, z0, x1, z1, ...]`
+     * @param {number} local_xz_offset offset in `local_xz`
+     * @param {number} sample_count number of `(x, z)` points, at least 1
+     * @param {number} footprint spatial filter footprint in metres, at least 0
+     * @param {Float32Array} target
+     * @param {number} target_offset in floats
+     * @param {number} tag the caller's, a u32, reported back when the request settles
+     */
+    request(body: number, local_xz: ArrayLike<number>, local_xz_offset: number, sample_count: number, footprint: number, target: Float32Array, target_offset: number, tag: number): void;
+    /**
+     * Make the frame's requests rows and record their pass into `graph`: the database's upload, the
+     * gather, and the readback's encode. Recorded after `GPUWaterSurface.record` so the frame's
+     * spectrum bands, wave particle hash, and body rows are ready.
+     *
+     * @param {object} options
+     * @param {FrameGraph} options.graph
+     * @param {object} options.scene GPU scene context
+     * @param {GPUWaterSurface} options.surface the water surface producer
+     * @returns {boolean} whether a pass was recorded
+     */
+    record({ graph, scene, surface }: {
+        graph: FrameGraph;
+        scene: object;
+        surface: GPUWaterSurface;
+    }): boolean;
+    /**
+     * The apply point, once a frame (`WaterSystem#update`): the readback delivers every batch whose
+     * mapping has landed, oldest first, and starts the maps of the frames submitted since.
+     * Delivered samples are unpacked from `{ height: f32, normal: u32 }` into the caller's target as
+     * 4 floats (`[world_height, nx, ny, nz]`); rows of settled requests are freed.
+     */
+    apply(): void;
+    /**
+     * Release the database and the readback, discarding any mapping still out. Every request asked
+     * or in flight settles `Dropped`, reported in {@link settled_count} as an {@link apply} would.
+     */
+    destroy(): void;
+    #private;
+}
+export type FrameGraph = import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+export type GPUWaterSurface = import("../surface/GPUWaterSurface.js").GPUWaterSurface;
+export type PipelineEnquiry = import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;
+import { GPUDatabase } from "../../buffer/table/GPUDatabase.js";
+import { GPUDatabaseReadback } from "../../buffer/table/GPUDatabaseReadback.js";
+//# sourceMappingURL=GPUWaterQueries.d.ts.map

package/src/shade/renderer/water/query/GPUWaterQueries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GPUWaterQueries.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/query/GPUWaterQueries.js"],"names":[],"mappings":"AAwBA;;;;GAIG;AAEH;;;;GAIG;AACH,wCAFU,MAAM,CAE2B;AAkE3C;;;;;;;GAOG;AACH;IAEI;;;;OAIG;IACH,iCAFW,eAAe,QAMzB;IA+ZD,wEAYC;IA3UD;;;OAGG;IACH;QAF8B,MAAM;OAyBnC;IAED;;;OAGG;IACH,4BAEC;IAED;;;OAGG;IACH,oCAEC;IAED;;;OAGG;IACH,8BAEC;IAED;;;OAGG;IACH,0BAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,4BAEC;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,sBAJW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;;;;;;;;OAcG;IACH,cATW,MAAM,YACN,UAAU,MAAM,CAAC,mBACjB,MAAM,gBACN,MAAM,aACN,MAAM,UACN,YAAY,iBACZ,MAAM,OACN,MAAM,QAqChB;IA4CD;;;;;;;;;;OAUG;IACH;QAL+B,KAAK,EAAzB,UAAU;QACM,KAAK,EAArB,MAAM;QACmB,OAAO,EAAhC,eAAe;QACb,OAAO,CAwHnB;IAsED;;;;;OAKG;IACH,cAYC;IAwFD;;;OAGG;IACH,gBA0BC;;CACJ;yBA3sBY,OAAO,8DAA8D,EAAE,UAAU;8BACjF,OAAO,+BAA+B,EAAE,eAAe;8BACvD,OAAO,6CAA6C,EAAE,eAAe;4BA1BtD,mCAAmC;oCAC3B,2CAA2C"}