@woosh/meep-engine 3.49.0 → 3.50.0

package/src/shade/renderer/fluid/forcing/FLUID_FORCING_APPLY_STRUCT.js

@@ -0,0 +1,35 @@
+import { GRID_TILE_WINDOW_STRUCT } from "../../shader/chunk/grid/GRID_TILE_WINDOW_STRUCT.js";
+import { f32, u32, vec3u } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+
+/**
+ * What a stepping cascade's forcing (`shader_fluid_forcing_apply`, Q3) reads.
+ *
+ * - `cells`: the window, `corner` its world cell at window-local 0 and `size` its cells;
+ * - `faces_u`, `faces_v`, `faces_w`: where the cascade's persistent faces are stored, toroidally, as
+ *   the step reads them (`GPUFluidCascade#faces_window`), which a pinned face's wall velocity is
+ *   written through;
+ * - `bricks`: bricks on each axis of the window;
+ * - `query_base`: the slot's first query, its brick 0;
+ * - `cell_size`: `h_c`, metres;
+ * - `dt`: `dt_c`, the step's seconds, which the deposits are over;
+ * - `inverse_frame_dt`: `1 / (frame_dt · fixedStepTimeScale)`, 0 when no game time passed, which a
+ *   wake's node velocity is taken with;
+ * - `forcing_v`, `forcing_w`: where the v and w faces start in the forcing buffer, which holds the u
+ *   faces from 0, each component's faces laid out over its own face lattice, x fastest.
+ *
+ * @type {WebGPUStruct}
+ */
+export const FLUID_FORCING_APPLY_STRUCT = WebGPUStruct.from({
+    cells: GRID_TILE_WINDOW_STRUCT,
+    faces_u: GRID_TILE_WINDOW_STRUCT,
+    faces_v: GRID_TILE_WINDOW_STRUCT,
+    faces_w: GRID_TILE_WINDOW_STRUCT,
+    bricks: vec3u,
+    query_base: u32,
+    cell_size: f32,
+    dt: f32,
+    inverse_frame_dt: f32,
+    forcing_v: u32,
+    forcing_w: u32,
+}, "FluidForcingApply");

package/src/shade/renderer/fluid/forcing/FLUID_FORCING_EXTRACT_STRUCT.d.ts

@@ -0,0 +1,18 @@
+/**
+ * What the GPU fluid's leaf extraction (`shader_fluid_forcing_extract`, L1) reads for a frame.
+ *
+ * - `clip_low`, `clip_high`: the box every leaf is clipped into, world metres;
+ * - `leaf_count`: leaves, the rows of the CPU-compacted list;
+ * - `obstacle_leaf_count`: how many of them, from the first, are obstacle records; the rest are
+ *   effectors;
+ * - `dilation`: metres an obstacle's box grows on its + sides;
+ * - `sweep_time`: seconds a wake's box is swept back over, the longest step of the frame's stepping
+ *   cascades;
+ * - `inverse_frame_dt`: `1 / (frame_dt · fixedStepTimeScale)`, 0 when no game time passed, which a
+ *   wake's node velocity is taken with.
+ *
+ * @type {WebGPUStruct}
+ */
+export const FLUID_FORCING_EXTRACT_STRUCT: WebGPUStruct;
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+//# sourceMappingURL=FLUID_FORCING_EXTRACT_STRUCT.d.ts.map

package/src/shade/renderer/fluid/forcing/FLUID_FORCING_EXTRACT_STRUCT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FLUID_FORCING_EXTRACT_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/forcing/FLUID_FORCING_EXTRACT_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH,2CAFU,YAAY,CAUI;6BAzBG,mCAAmC"}

package/src/shade/renderer/fluid/forcing/FLUID_FORCING_EXTRACT_STRUCT.js

@@ -0,0 +1,27 @@
+import { f32, u32, vec3f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+
+/**
+ * What the GPU fluid's leaf extraction (`shader_fluid_forcing_extract`, L1) reads for a frame.
+ *
+ * - `clip_low`, `clip_high`: the box every leaf is clipped into, world metres;
+ * - `leaf_count`: leaves, the rows of the CPU-compacted list;
+ * - `obstacle_leaf_count`: how many of them, from the first, are obstacle records; the rest are
+ *   effectors;
+ * - `dilation`: metres an obstacle's box grows on its + sides;
+ * - `sweep_time`: seconds a wake's box is swept back over, the longest step of the frame's stepping
+ *   cascades;
+ * - `inverse_frame_dt`: `1 / (frame_dt · fixedStepTimeScale)`, 0 when no game time passed, which a
+ *   wake's node velocity is taken with.
+ *
+ * @type {WebGPUStruct}
+ */
+export const FLUID_FORCING_EXTRACT_STRUCT = WebGPUStruct.from({
+    clip_low: vec3f,
+    leaf_count: u32,
+    clip_high: vec3f,
+    obstacle_leaf_count: u32,
+    dilation: f32,
+    sweep_time: f32,
+    inverse_frame_dt: f32,
+}, "FluidForcingExtract");

package/src/shade/renderer/fluid/forcing/FLUID_FORCING_QUERY_STRUCT.d.ts

@@ -0,0 +1,17 @@
+/**
+ * What a tick's brick queries (`shader_fluid_forcing_query`, Q1) read: the stepping cascades, at most
+ * two, as slots 0 and 1, and each slot's tree's leaf split.
+ *
+ * - `corner_0`, `cell_size_0`: slot 0's window, the world cell at window-local 0 and its edge in
+ *   metres; `corner_1`, `cell_size_1` slot 1's, unused on a tick that steps one cascade;
+ * - `bricks`: bricks on each axis of a window, every stepping cascade's (they share a resolution);
+ * - `brick_count`: their product, the queries of a slot;
+ * - `query_count`: the dispatch's queries, `brick_count` times the stepping cascades;
+ * - `obstacle_leaf_count_0`, `obstacle_leaf_count_1`: leaves of slot 0's and slot 1's tree below it
+ *   are obstacle records, the rest effectors.
+ *
+ * @type {WebGPUStruct}
+ */
+export const FLUID_FORCING_QUERY_STRUCT: WebGPUStruct;
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+//# sourceMappingURL=FLUID_FORCING_QUERY_STRUCT.d.ts.map

package/src/shade/renderer/fluid/forcing/FLUID_FORCING_QUERY_STRUCT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FLUID_FORCING_QUERY_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/forcing/FLUID_FORCING_QUERY_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH,yCAFU,YAAY,CAYE;6BA1BK,mCAAmC"}

package/src/shade/renderer/fluid/forcing/FLUID_FORCING_QUERY_STRUCT.js

@@ -0,0 +1,28 @@
+import { f32, u32, vec3i, vec3u } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+
+/**
+ * What a tick's brick queries (`shader_fluid_forcing_query`, Q1) read: the stepping cascades, at most
+ * two, as slots 0 and 1, and each slot's tree's leaf split.
+ *
+ * - `corner_0`, `cell_size_0`: slot 0's window, the world cell at window-local 0 and its edge in
+ *   metres; `corner_1`, `cell_size_1` slot 1's, unused on a tick that steps one cascade;
+ * - `bricks`: bricks on each axis of a window, every stepping cascade's (they share a resolution);
+ * - `brick_count`: their product, the queries of a slot;
+ * - `query_count`: the dispatch's queries, `brick_count` times the stepping cascades;
+ * - `obstacle_leaf_count_0`, `obstacle_leaf_count_1`: leaves of slot 0's and slot 1's tree below it
+ *   are obstacle records, the rest effectors.
+ *
+ * @type {WebGPUStruct}
+ */
+export const FLUID_FORCING_QUERY_STRUCT = WebGPUStruct.from({
+    corner_0: vec3i,
+    cell_size_0: f32,
+    corner_1: vec3i,
+    cell_size_1: f32,
+    bricks: vec3u,
+    brick_count: u32,
+    query_count: u32,
+    obstacle_leaf_count_0: u32,
+    obstacle_leaf_count_1: u32,
+}, "FluidForcingQuery");

package/src/shade/renderer/fluid/forcing/FLUID_OBSTACLE_PLANE_STRUCT.d.ts

@@ -0,0 +1,12 @@
+/**
+ * One hull plane of a fluid obstacle, a row of the `fluid_obstacle_planes` table
+ * (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §10): core's shape-record plane layout, the outward unit
+ * normal and the offset, a point being inside when `n·p − offset ≤ 0`. What
+ * `fluid_obstacle_write_gpu_shape` writes four floats of, and `shape_record_plane(index)` hands
+ * `chunk_shape_record_signed_distance`. 16 bytes.
+ *
+ * @type {WebGPUStruct}
+ */
+export const FLUID_OBSTACLE_PLANE_STRUCT: WebGPUStruct;
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+//# sourceMappingURL=FLUID_OBSTACLE_PLANE_STRUCT.d.ts.map

package/src/shade/renderer/fluid/forcing/FLUID_OBSTACLE_PLANE_STRUCT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FLUID_OBSTACLE_PLANE_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/forcing/FLUID_OBSTACLE_PLANE_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,0CAFU,YAAY,CAKG;6BAdI,mCAAmC"}

package/src/shade/renderer/fluid/forcing/FLUID_OBSTACLE_PLANE_STRUCT.js

@@ -0,0 +1,16 @@
+import { vec4f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+
+/**
+ * One hull plane of a fluid obstacle, a row of the `fluid_obstacle_planes` table
+ * (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §10): core's shape-record plane layout, the outward unit
+ * normal and the offset, a point being inside when `n·p − offset ≤ 0`. What
+ * `fluid_obstacle_write_gpu_shape` writes four floats of, and `shape_record_plane(index)` hands
+ * `chunk_shape_record_signed_distance`. 16 bytes.
+ *
+ * @type {WebGPUStruct}
+ */
+export const FLUID_OBSTACLE_PLANE_STRUCT = WebGPUStruct.from({
+    /** `(nx, ny, nz, offset)`. */
+    plane: vec4f,
+}, "FluidObstaclePlane");

package/src/shade/renderer/fluid/forcing/GPUFluidForcing.d.ts

@@ -0,0 +1,289 @@
+/**
+ * # The GPU fluid's forcing
+ *
+ * What turns the scene's local fluid effectors and obstacles into what a cascade step reads
+ * (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §10): the fluid database, an LBVH over its rows for each
+ * resolution of cascade that steps, and per tick a brick query and the forcing of each stepping
+ * cascade.
+ *
+ * ## Rows: the host API
+ *
+ * One {@link GPUDatabase} of {@link FLUID_DATABASE_SPEC}. A row is written whole, through a generated
+ * writer, when its caller says it changed (an effector's `write_gpu_record` and an obstacle's
+ * `fluid_obstacle_write_gpu_shape` / `_motion` compare every field while they assign it), and the
+ * database uploads only what was written, before the frame's first extraction reads it.
+ *
+ *     add_effector(record) → row          set_effector(row, record)        remove_effector(row)
+ *     add_obstacles(records) → first      set_obstacle(row, record)        remove_obstacles(first, count)
+ *     add_planes(count) → first           planes, set_planes(first, count) remove_planes(first, count)
+ *
+ * A collider is a run of obstacle rows (`add_run`), and its hulls' planes a run of plane rows, which
+ * its records name in core's layout: `fluid_obstacle_write_gpu_shape(record, forcing.planes, first +
+ * cursor, shape, i)` writes a hull's planes into {@link planes}, the CPU mirror of the plane table
+ * indexed by row, and names them there; {@link set_planes} then uploads the rows. A record's `node`
+ * is its caller's to set, the scene's `transforms` row that poses it (0 for none).
+ *
+ * ## The resolution cull is the trees
+ *
+ * Cascade `c` of cell `h_c` resolves an obstacle at least `h_c/2` wide, by the record's own extent
+ * (`fluid_obstacle_record_extent`, kept per row as its record is written), and every effector. Its
+ * brick queries search a tree of exactly those leaves, so an obstacle too small for a cascade never
+ * takes a place on a coarse query's frontier and crowds out one that is not. The sets are nested,
+ * finest largest; a cascade whose set is the finer one's shares that one's tree.
+ *
+ * ## Once a frame: {@link record_frame}; per tick, the trees the tick needs
+ *
+ * {@link record_frame} takes the frame's numbers. The first tick of the frame that steps a cascade of
+ * a level records that level's tree, L1 and L2, before its queries; a later tick of the frame reuses it,
+ * and a level no tick steps builds nothing.
+ *
+ * - **The leaf list**, rebuilt on the CPU when the rows or an obstacle's extent changed: the level's
+ *   obstacle rows ascending, then every effector row ascending, so the tree's leaf order, its Morton
+ *   tie-break and every brick's survivors follow the rows.
+ * - **L1** (`shader_fluid_forcing_extract`): the database's uploads (the frame's first extraction),
+ *   then one thread a leaf, its world box clipped into the frame's clip box, and the centroids' bound.
+ * - **L2**: `graph_bvh_build_lbvh`, at most one sort tile of leaves (1,024) the one-dispatch build,
+ *   every frame. Above that the 19-dispatch build on a frame whose list changed (so whose count may
+ *   have) or every {@link FLUID_FORCING_REBUILD_AGE}th frame of that tree, and otherwise
+ *   `graph_bvh_refit_lbvh` through the stored tree. Each tree keeps its own cadence. Runtime facts
+ *   only: a count, a list version, an age.
+ *
+ * ## Per tick, called by `GPUFluidCascadeStack#record_tick`: Q1–Q3
+ *
+ * - {@link record_queries}: the trees, then Q1, every brick of the tick's stepping cascades queries its
+ *   cascade's tree in one dispatch (`shader_fluid_forcing_query`), and Q2, the forcing's indirect
+ *   commands (`shader_fluid_forcing_command`);
+ * - {@link record_forcing}, once for each stepping cascade, before its step: Q3
+ *   (`shader_fluid_forcing_apply`) over the bricks its query listed, writing the cascade's solid
+ *   flags, the wall's velocity into its pinned faces, and the tick's forcing, which it returns for
+ *   the step.
+ *
+ * ## With no rows
+ *
+ * Nothing is recorded: no upload, no tree, no query, and the steps read their cascades' own flags
+ * with no forcing. The one exception is the tick after the last row went: a cascade whose flags the
+ * forcing wrote has them cleared once, before its next step.
+ *
+ * At a fixed row count and resolution this class makes no object per frame or tick: its trees, pass
+ * records, bindings and transient descriptors are retained and rewritten. What a frame still
+ * allocates (measured with the sampling heap profiler, SoftwareGPUDevice, 16 rows, one tick with
+ * two stepping cascades): ~0.4 KB here, the f64 stores into the retained records, and ~0.9 KB in
+ * `graph_bvh_build_lbvh`'s recorder for each tree, beside what the frame graph and the bindings
+ * allocate for every pass.
+ */
+export class GPUFluidForcing {
+    /**
+     * Offer the pipelines the forcing dispatches — see {@link PipelineEnquiry}.
+     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry: PipelineEnquiry): void;
+    /**
+     * The descriptor of a transient of `role`, `size` bytes, from `kept` (by role): the one kept for
+     * the role while its size holds, a new one when it moves. A role's usage and clear range never
+     * change.
+     *
+     * @param {BufferResourceDescriptor[]} kept
+     * @param {number} role
+     * @param {number} size
+     * @param {number} usage
+     * @param {number} clear_size bytes cleared from 0 when the pool reuses the buffer
+     * @returns {BufferResourceDescriptor}
+     */
+    static "__#266@#descriptor"(kept: BufferResourceDescriptor[], role: number, size: number, usage: number, clear_size: number): BufferResourceDescriptor;
+    /**
+     * @param {object} record
+     * @param {FramePassResources} resources
+     * @param {{encoder: ShadeGPUCommandContext}} context
+     */
+    static "__#266@#execute_extract"(record: object, resources: FramePassResources, context: {
+        encoder: ShadeGPUCommandContext;
+    }): void;
+    static "__#266@#execute_clear"(record: any, _resources: any, context: any): void;
+    static "__#266@#execute_query"(record: any, resources: any, context: any): void;
+    static "__#266@#execute_command"(record: any, resources: any, context: any): void;
+    static "__#266@#execute_apply"(record: any, resources: any, context: any): void;
+    /**
+     * @param {object} options
+     * @param {GPUDevice} options.device
+     */
+    constructor({ device }: {
+        device: GPUDevice;
+    });
+    /**
+     * The fluid database.
+     * @returns {GPUDatabase}
+     */
+    get database(): GPUDatabase;
+    /**
+     * Rows of the effector table.
+     * @returns {number}
+     */
+    get effector_count(): number;
+    /**
+     * Rows of the obstacle table.
+     * @returns {number}
+     */
+    get obstacle_count(): number;
+    /**
+     * Every obstacle and effector row: the leaves of the finest tree, before its resolution cull.
+     * @returns {number}
+     */
+    get leaf_count(): number;
+    /**
+     * What the last {@link record_frame}'s frame did to the tree cascade `level` queries (the stack's
+     * cascade `level`, whose cell is `2^level` times the frame's `cell_size`): `'build'`, `'refit'`, or
+     * `'none'` when no tick of the frame stepped a cascade that queries it, or it holds no leaves.
+     *
+     * @param {number} level
+     * @returns {string}
+     */
+    tree_update(level: number): string;
+    /**
+     * What the brick queries could not keep, accumulated since creation, four u32: obstacle candidates
+     * past `FLUID_FORCING_OBSTACLE_LIMIT`, effector candidates past `FLUID_FORCING_EFFECTOR_LIMIT`,
+     * candidates past the query's list, nodes the query never tested.
+     * @returns {GPUBuffer}
+     */
+    get statistics(): GPUBuffer;
+    /**
+     * The CPU mirror of the plane table, four floats a row, `(nx, ny, nz, offset)`, indexed by row:
+     * what `fluid_obstacle_write_gpu_shape` writes a hull's planes into. Replaced, not grown in place,
+     * by {@link add_planes}: read it after.
+     * @returns {Float32Array}
+     */
+    get planes(): Float32Array;
+    /**
+     * Add an effector row.
+     *
+     * @param {FluidEffectorRecord} record
+     * @returns {number} its row
+     */
+    add_effector(record: FluidEffectorRecord): number;
+    /**
+     * Write an effector row whole, for the next frame's upload.
+     *
+     * @param {number} row
+     * @param {FluidEffectorRecord} record
+     */
+    set_effector(row: number, record: FluidEffectorRecord): void;
+    /**
+     * @param {number} row
+     */
+    remove_effector(row: number): void;
+    /**
+     * Add a collider's obstacle records as a run of consecutive rows.
+     *
+     * @param {FluidObstacleRecord[]} records at least one
+     * @returns {number} the run's first row
+     */
+    add_obstacles(records: FluidObstacleRecord[]): number;
+    /**
+     * Write an obstacle row whole, for the next frame's upload.
+     *
+     * @param {number} row
+     * @param {FluidObstacleRecord} record
+     */
+    set_obstacle(row: number, record: FluidObstacleRecord): void;
+    /**
+     * @param {number} first
+     * @param {number} count
+     */
+    remove_obstacles(first: number, count: number): void;
+    /**
+     * Take a run of plane rows, zero, for a collider's hulls; {@link planes} grows to hold them.
+     *
+     * @param {number} count at least one
+     * @returns {number} the run's first row
+     */
+    add_planes(count: number): number;
+    /**
+     * Upload plane rows from {@link planes}.
+     *
+     * @param {number} first
+     * @param {number} count
+     */
+    set_planes(first: number, count: number): void;
+    /**
+     * @param {number} first
+     * @param {number} count
+     */
+    remove_planes(first: number, count: number): void;
+    /**
+     * Record the frame's numbers, before any tick of it, for the trees its ticks record. Call once a
+     * frame that records ticks; with no rows, the frame's ticks record no tree and no query.
+     *
+     * @param {object} options
+     * @param {FrameGraph} options.graph
+     * @param {GPUDatabase} options.scene_database the scene's database, whose `transforms` the rows'
+     *   nodes are; its buffer is read when the graph runs
+     * @param {ArrayLike<number>} options.bounds world metres, `[x0, y0, z0, x1, y1, z1]`: the union of
+     *   the coarsest windows of the stacks the frame steps. Every leaf is clipped to it grown by its
+     *   own extent on every side, so a placement during the frame's ticks stays inside, and a plane, a
+     *   heightmap's box or a far row stays finite
+     * @param {number} options.sweep_time seconds: the longest step of the frame's stepping cascades,
+     *   `dt·2^c` over its ticks, which a wake's box is swept back over
+     * @param {number} options.inverse_frame_dt `1 / (frame_dt · fixedStepTimeScale)`, 0 when no game
+     *   time passed: what a wake's node velocity is taken with
+     * @param {number} options.cell_size metres: the finest cascade cell of the frame, cascade 0's, by
+     *   which every obstacle box is dilated on its + sides, and against which a cascade's level is
+     *   counted
+     */
+    record_frame({ graph, scene_database, bounds, sweep_time, inverse_frame_dt, cell_size }: {
+        graph: FrameGraph;
+        scene_database: GPUDatabase;
+        bounds: ArrayLike<number>;
+        sweep_time: number;
+        inverse_frame_dt: number;
+        cell_size: number;
+    }): void;
+    /**
+     * Record Q1 and Q2 of a tick into `graph`, after its placement and fills: the trees the stepping
+     * cascades search, if the frame has not recorded them yet, then every brick of the stepping
+     * cascades queries its cascade's tree, and the forcing's commands are written. `second` is the
+     * ruler's coarse cascade, `null` on a tick that steps cascade 0 alone; both share a resolution.
+     * With no rows, nothing is queried; a stepping cascade whose flags the forcing wrote then has them
+     * cleared.
+     *
+     * @param {object} options
+     * @param {FrameGraph} options.graph the graph {@link record_frame} recorded into this frame
+     * @param {GPUFluidCascade} options.first cascade 0, slot 0
+     * @param {GPUFluidCascade|null} options.second the tick's coarse cascade, slot 1, or `null`
+     */
+    record_queries({ graph, first, second }: {
+        graph: FrameGraph;
+        first: GPUFluidCascade;
+        second: GPUFluidCascade | null;
+    }): void;
+    /**
+     * Record Q3 for one stepping cascade of the tick {@link record_queries} recorded, before that
+     * cascade's step (after its restriction): its solid flags, the wall's velocity at every face it
+     * pins, and the tick's forcing.
+     *
+     * @param {object} options
+     * @param {FrameGraph} options.graph
+     * @param {GPUFluidCascade} options.cascade the tick's `first` (slot 0) or `second` (slot 1)
+     * @param {number} options.dt seconds, the cascade's step, `dt·2^c`
+     * @returns {number|null} the forcing, a buffer resource of `graph` for the cascade's
+     *   `record_step`; `null` when nothing was recorded (no rows)
+     */
+    record_forcing({ graph, cascade, dt }: {
+        graph: FrameGraph;
+        cascade: GPUFluidCascade;
+        dt: number;
+    }): number | null;
+    /**
+     * Release the database, the trees and the buffers. Passes recorded into a graph that has not run
+     * yet encode nothing.
+     */
+    destroy(): void;
+    #private;
+}
+export type FrameGraph = import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+export type PipelineEnquiry = import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;
+export type GPUFluidCascade = import("../GPUFluidCascade.js").GPUFluidCascade;
+export type FluidEffectorRecord = import("../../../../engine/physics/fluid/effector/record/fluid_effector_record_create.js").FluidEffectorRecord;
+export type FluidObstacleRecord = import("../../../../engine/physics/fluid/obstacle/fluid_obstacle_record_create.js").FluidObstacleRecord;
+import { GPUDatabase } from "../../buffer/table/GPUDatabase.js";
+import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
+//# sourceMappingURL=GPUFluidForcing.d.ts.map

package/src/shade/renderer/fluid/forcing/GPUFluidForcing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GPUFluidForcing.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/forcing/GPUFluidForcing.js"],"names":[],"mappings":"AAuIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwEG;AACH;IAEI;;;;OAIG;IACH,iCAFW,eAAe,QAUzB;IA2ID;;;;;;;;;;;OAWG;IACH,kCAPW,wBAAwB,EAAE,QAC1B,MAAM,QACN,MAAM,SACN,MAAM,cACN,MAAM,GACJ,wBAAwB,CAcpC;IAylBD;;;;OAIG;IACH,yCAJW,MAAM,0CAEN;QAAC,OAAO,yBAAwB;KAAC,QAc3C;IA+MD,iFAcC;IAWD,gFAiCC;IAWD,kFAsBC;IA+GD,gFA0CC;IAjnCD;;;OAGG;IACH;QAF8B,MAAM;OAwCnC;IA4BD;;;OAGG;IACH,4BAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;;;;;OAOG;IACH,mBAHW,MAAM,GACJ,MAAM,CAiBlB;IAED;;;;;OAKG;IACH,4BAEC;IAED;;;;;OAKG;IACH,2BAEC;IAED;;;;;OAKG;IACH,qBAHW,mBAAmB,GACjB,MAAM,CAQlB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,UACN,mBAAmB,QAQ7B;IAED;;OAEG;IACH,qBAFW,MAAM,QAUhB;IAED;;;;;OAKG;IACH,uBAHW,mBAAmB,EAAE,GACnB,MAAM,CAsBlB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,UACN,mBAAmB,QAgB7B;IAED;;;OAGG;IACH,wBAHW,MAAM,SACN,MAAM,QAYhB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,MAAM,CAuBlB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,SACN,MAAM,QAmBhB;IAED;;;OAGG;IACH,qBAHW,MAAM,SACN,MAAM,QAUhB;IAyID;;;;;;;;;;;;;;;;;;;OAmBG;IACH;QAf+B,KAAK,EAAzB,UAAU;QACW,cAAc,EAAnC,WAAW;QAEgB,MAAM,EAAjC,UAAU,MAAM,CAAC;QAID,UAAU,EAA1B,MAAM;QAEU,gBAAgB,EAAhC,MAAM;QAEU,SAAS,EAAzB,MAAM;aA4ChB;IAyND;;;;;;;;;;;;OAYG;IACH;QAJ+B,KAAK,EAAzB,UAAU;QACe,KAAK,EAA9B,eAAe;QACe,MAAM,EAApC,eAAe,GAAC,IAAI;aA8H9B;IAmHD;;;;;;;;;;;OAWG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACe,OAAO,EAAhC,eAAe;QACC,EAAE,EAAlB,MAAM;QACJ,MAAM,GAAC,IAAI,CAuFvB;IAyDD;;;OAGG;IACH,gBAwBC;;CACJ;yBA16CY,OAAO,8DAA8D,EAAE,UAAU;8BACjF,OAAO,6CAA6C,EAAE,eAAe;8BACrE,OAAO,uBAAuB,EAAE,eAAe;kCAC/C,OAAO,kFAAkF,EAAE,mBAAmB;kCAC9G,OAAO,2EAA2E,EAAE,mBAAmB;4BAtCxF,mCAAmC;yCADtB,mDAAmD"}