@woosh/meep-engine 3.57.0 → 3.58.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/water/chunk_water_gi.d.ts

@@ -11,8 +11,8 @@ export const chunk_water_gi_ibl: CodeChunk;
  */
 export const chunk_water_gi_brick4: 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
+ * The water's indirect lighting by the renderer's mode ({@link INDIRECT_LIGHTING}): IBL, LPV and
+ * ProbeClipmap {@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.
  * @type {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":"AAwBA;;;;GAIG;AACH,iCAFU,SAAS,CAUoC;AAEvD;;;;GAIG;AACH,oCAFU,SAAS,CAgBwB;AAE3C;;;;;GAKG;AACH,6BAFU,eAAe,CAE6C;0BA3D5C,iCAAiC;gCAC3B,uCAAuC"}

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

@@ -19,6 +19,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.
+ So does the probe clipmap, until it samples its own probes.
 */
 
 /**
@@ -58,8 +59,8 @@ fn water_gi_specular(position: vec3<f32>, normal: vec3<f32>, view_direction: vec
 `, [chunk_brick4_sample_forward_indirect]);
 
 /**
- * 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
+ * The water's indirect lighting by the renderer's mode ({@link INDIRECT_LIGHTING}): IBL, LPV and
+ * ProbeClipmap {@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.
  * @type {CodeChunkChoice}
  */
@@ -68,3 +69,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_ibl);

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 "__#271@#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"}