@woosh/meep-engine 3.49.0 → 3.50.0

package/src/shade/renderer/fluid/GPUFluidCascade.d.ts

@@ -0,0 +1,383 @@
+/**
+ * How much of a deviation from the far field stored as of `Λ = from` is left as of `Λ = to`:
+ * `e^(from − to)`, its exponent held at {@link GPU_FLUID_CASCADE_GROWTH_EXPONENT_LIMIT}.
+ *
+ * @param {number} from
+ * @param {number} to
+ * @returns {number}
+ */
+export function gpu_fluid_cascade_frame_keep(from: number, to: number): number;
+/**
+ * How a cascade's step solves for pressure (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §8, D5).
+ */
+export type GPUFluidCascadePressureArm = number;
+/**
+ * @typedef {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} FrameGraph
+ * @typedef {import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext} ShadeGPUCommandContext
+ */
+/**
+ * How a cascade's step solves for pressure (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §8, D5).
+ * @readonly
+ * @enum {number}
+ */
+export const GPUFluidCascadePressureArm: Readonly<{
+    /** {@link GPUFluidPressureSolve#encode_v_cycles}: the count is V-cycles. */
+    VCycles: 0;
+    /** {@link GPUFluidPressureSolve#encode_sor}: the count is red-black sweeps. */
+    SOR: 1;
+}>;
+/**
+ * V-cycles a step runs by default: the fewest that hold the CPU fluid's projection gate
+ * (`GPUFluidCascade.quality.slow.spec.js`, 16³, max |div| of a random field). One V-cycle a step left
+ * 1.62× the divergence of `FluidSimulator` with one projection after advection after the first step
+ * and 4.96× after ten, against the gate's 1.25; two left 0.40× and 0.34×. On an RTX 4090 the second
+ * costs 10 dispatches and 38 µs at 64×32×64 (a step 77 µs against 115), 72 µs at 128×32×128 (173
+ * against 245).
+ *
+ * The arm is the V-cycle on measurement: from a cold start at 64×32×64, with the coarsest level still
+ * at 32 sweeps, it reached a tenth of the residual in 59 µs (1 cycle, 14 dispatches) against SOR's
+ * 173 µs (26 sweeps, 53), and a hundredth in 110 against 327 (2 cycles; 49 sweeps), open or with
+ * obstacles.
+ * @type {number}
+ */
+export const GPU_FLUID_CASCADE_V_CYCLES: number;
+/**
+ * Most cells a cascade has on an axis.
+ * @type {number}
+ */
+export const GPU_FLUID_CASCADE_RESOLUTION_LIMIT: number;
+/**
+ * The largest exponent a frame conversion grows a deviation by: `e^x` is held at `e^64` past it.
+ *
+ * A value stored as of one instant is read as of another through `e^(−(Λ(t_read) − Λ(t_stored)))`
+ * (§6). Read at a later instant that is at most 1; read at an EARLIER one, as a cascade reads a parent
+ * that stepped since it did, it exceeds 1, by how much the drag acted between the two records. The
+ * device then multiplies back down by the step's own `e^(−ΔΛ)`. Past `e^64` (6e27, which keeps a
+ * deviation of 1e10 m/s finite in f32) the deviation being carried has decayed below 1.6e-28 of
+ * itself, under any f32 velocity's resolution, so holding the factor there changes nothing a read
+ * can see, and an infinity never reaches the device.
+ * @type {number}
+ */
+export const GPU_FLUID_CASCADE_GROWTH_EXPONENT_LIMIT: number;
+/**
+ * One cascade window of the GPU fluid (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §7, §8), and the step
+ * that advances it.
+ *
+ * The window is N = `resolution` cells of `cell_size` metres, powers of two (32 to 256 on an axis in
+ * production; a spec runs smaller), with world cell `corner` at window-local 0. World cell `g` of a
+ * cascade covers `[g·h, (g + 1)·h)` on each axis, so cascades of every cell size share the world's
+ * origin, and a cascade of twice the cell holds child cells `2G` and `2G + 1` in its cell `G`.
+ *
+ * **What it keeps between steps:**
+ * - {@link velocity}, A: three toroidal `r32float` face textures (`FluidMacVelocitySet`);
+ * - {@link pressure}: kinematic pressure, m²/s², `array<f32>` of N cells, toroidal, the solve's warm
+ *   start;
+ * - {@link solid}: window-local solid flags, all fluid at creation: `FLUID_SOLID_FLAG`, and
+ *   `FLUID_FORCED_FLAG` where the tick's forcing was written for the cell's faces. A step reads these
+ *   unless it is handed another buffer. `GPUFluidForcing` writes them before each step of the
+ *   cascade, with {@link solid_bricks} saying which bricks it last wrote;
+ * - **its read record**: the instant its velocity was last brought to, `t_s`, with `v_far(t_s)`
+ *   ({@link read_far_velocity}, rounded to f32 as the device holds it) and `Λ(t_s)`
+ *   ({@link read_lambda}), on the CPU. The velocity is a deviation from `v_far(t_s)`, so every read of
+ *   it at an instant `t` is `v_far(t) + (v − v_far(t_s))·e^(−(Λ(t) − Λ(t_s)))` (§6); {@link update_read}
+ *   computes that factor, {@link read_keep}, on the CPU, and the device never sees `Λ`.
+ *
+ * It is created at the far field of a {@link FluidAtmosphere} record: velocity `v_far`, pressure 0,
+ * the read record that instant.
+ *
+ * **One step** ({@link record_step}) is one frame-graph pass, in the order of §8, from `t₀`, its read
+ * record, to `t₁`, the atmosphere it is handed:
+ *
+ *     ghosts             parent → G: its identity read at the faces and its pressure at the cells
+ *                        just past the window, once (shader_fluid_cascade_ghosts)
+ *     curl               A → C, the vorticity confinement's force per cell (shader_fluid_mac_curl),
+ *                        only for a step with confinement
+ *     advect predict     A → F
+ *     advect correct     A + F → B, then per face the atmosphere identity, the confinement from C,
+ *                        the relaxation band and the deviation clamp (chunk_fluid_cascade_epilogue),
+ *                        and the tick's forcing where the flags say it was written
+ *     divergence         B → rhs = div/dt
+ *     pressure solve     rhs → pressure (V-cycles or SOR)
+ *     gradient           B + pressure → A
+ *
+ * and moves the read record to `t₁`. Beyond the window, velocity is the parent's identity read at
+ * `t₀` and pressure the parent's: a `parent` cascade's, of twice the cell and the same resolution, or
+ * the far field's (`v_far(t₀)`, 0), a parent with no window. The step's passes read it from G, the
+ * step's ghosts, which hold it as of the step's start for every face a trace can reach and every
+ * ghost cell; a trace past the shell reads the parent itself.
+ *
+ * F and B (three textures each), G (three shell textures and a buffer), the RHS and C are the step's
+ * transients: the pass creates them in the frame graph, which pools them, so the steps of every
+ * cascade of one resolution share one set of memory. The pressure solve keeps its level buffers itself (`GPUFluidPressureSolve`).
+ *
+ * At 64×32×64 a step dispatches the ghosts, 4 MAC passes, the solve's 4 weight passes and 10 a
+ * V-cycle: 29 at {@link GPU_FLUID_CASCADE_V_CYCLES}, and the curl with confinement.
+ *
+ * A face with a solid cell on either side is pinned: every pass carries its value in A through, so A
+ * holds the wall's velocity there. Whoever writes the solid flags writes that velocity too: the
+ * forcing writes it into A at every face it pins, before the step, so a face that just became pinned
+ * carries the wall and never the fluid value it held.
+ *
+ * **Placement** ({@link place}) moves the window's corner and writes nothing: storage wraps, so every
+ * value still inside the window stays where it is, and what the move exposed holds stale values until
+ * {@link record_fill} writes it from the parent (one dispatch, `shader_fluid_cascade_fill`).
+ *
+ * **Feedback** ({@link record_restrict}): before a cascade steps, its child's interior is restricted
+ * into it, each parent face the mean of the four child faces on it (one dispatch,
+ * `shader_fluid_cascade_restrict`). A step records the corner, and its parent's, as they are
+ * when the step is recorded, so several ticks may be recorded into one graph.
+ *
+ * Nothing is allocated per step once the first has been recorded: the step's parameters and the
+ * solve's inputs live in retained records, and several steps may be recorded into one graph.
+ */
+export class GPUFluidCascade {
+    /**
+     * @param {object} record
+     * @param {*} _resources
+     * @param {{encoder: ShadeGPUCommandContext}} context
+     */
+    static "__#263@#execute_restrict"(record: object, _resources: any, context: {
+        encoder: ShadeGPUCommandContext;
+    }): void;
+    /**
+     * @param {object} record
+     * @param {*} _resources
+     * @param {{encoder: ShadeGPUCommandContext}} context
+     */
+    static "__#263@#execute_fill"(record: object, _resources: any, context: {
+        encoder: ShadeGPUCommandContext;
+    }): void;
+    /**
+     * @param {object} record
+     * @param {import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources} resources
+     * @param {{encoder: ShadeGPUCommandContext}} context
+     */
+    static "__#263@#execute"(record: object, resources: import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
+        encoder: ShadeGPUCommandContext;
+    }): void;
+    /**
+     * @param {object} options
+     * @param {GPUDevice} options.device
+     * @param {ArrayLike<number>} options.resolution cells on each axis, powers of two
+     * @param {number} options.cell_size metres
+     * @param {ArrayLike<number>} options.corner the world cell at window-local (0, 0, 0)
+     * @param {Float64Array|number[]} options.atmosphere a {@link FluidAtmosphere} record, world units:
+     *   the velocity starts at its `v_far`, and the read record is its instant
+     * @param {number} options.atmosphere_offset where the record starts in `atmosphere`
+     */
+    constructor({ device, resolution, cell_size, corner, atmosphere, atmosphere_offset }: {
+        device: GPUDevice;
+        resolution: ArrayLike<number>;
+        cell_size: number;
+        corner: ArrayLike<number>;
+        atmosphere: Float64Array | number[];
+        atmosphere_offset: number;
+    });
+    /**
+     * Cells on each axis.
+     * @returns {Readonly<Uint32Array>}
+     */
+    get resolution(): Readonly<Uint32Array>;
+    /**
+     * The world cell at window-local (0, 0, 0).
+     * @returns {Readonly<Int32Array>}
+     */
+    get corner(): Readonly<Int32Array>;
+    /**
+     * A cell's edge, metres.
+     * @returns {number}
+     */
+    get cell_size(): number;
+    /**
+     * The persistent velocity, A: u, v and w faces, toroidal through the window, each a deviation from
+     * {@link read_far_velocity}.
+     * @returns {FluidMacVelocitySet}
+     */
+    get velocity(): FluidMacVelocitySet;
+    /**
+     * The persistent pressure, m²/s², `array<f32>` of N cells, toroidal with period N.
+     * @returns {GPUBuffer}
+     */
+    get pressure(): GPUBuffer;
+    /**
+     * The cascade's own solid flags, `array<u32>` of N cells, window-local, x fastest; all fluid unless
+     * written. What a step reads when it is handed no other.
+     * @returns {GPUBuffer}
+     */
+    get solid(): GPUBuffer;
+    /**
+     * Which bricks of {@link solid} hold anything, one u32 a brick of `FLUID_FORCING_BRICK`³ cells,
+     * window-local, x fastest: 1 where the forcing last wrote the brick's flags, so that the next
+     * forcing of this cascade clears them if nothing meets the brick then. All 0 at creation. The
+     * forcing's (`GPUFluidForcing`), beside the flags it writes.
+     * @returns {GPUBuffer}
+     */
+    get solid_bricks(): GPUBuffer;
+    /**
+     * How many non-finite values the pressure solves read and zeroed; made by the first step.
+     * @returns {GPUBuffer|null}
+     */
+    get nonfinite_counter(): any;
+    /**
+     * The read record's instant `t_s`, seconds, as the atmosphere records count them.
+     * @returns {number}
+     */
+    get read_time(): number;
+    /**
+     * `Λ(t_s)`.
+     * @returns {number}
+     */
+    get read_lambda(): number;
+    /**
+     * `v_far(t_s)`, m/s, rounded to f32: what the stored velocity is a deviation from.
+     * @returns {Readonly<Float32Array>}
+     */
+    get read_far_velocity(): Readonly<Float32Array>;
+    /**
+     * `k = e^(−(Λ(t) − Λ(t_s)))` for the instant of the last {@link update_read}, in [0, 1]: a read of
+     * the stored velocity `v` at that instant is `v_far(t) + (v − v_far(t_s))·k`. 1 until the first.
+     * @returns {number}
+     */
+    get read_keep(): number;
+    /**
+     * Compute {@link read_keep} for the instant a {@link FluidAtmosphere} record describes: what a
+     * reader of the cascade takes, each frame, as one number. A record before the cascade's own reads
+     * 1.
+     *
+     * @param {Float64Array|number[]} atmosphere
+     * @param {number} offset
+     */
+    update_read(atmosphere: Float64Array | number[], offset: number): void;
+    /**
+     * Where the pressure is stored now, as a {@link GRID_TILE_WINDOW_STRUCT} value: period N, the
+     * storage corner the corner modulo N. A retained object, rewritten on every call.
+     * @returns {{corner: Int32Array, corner_storage: Uint32Array, size: Uint32Array, period: Uint32Array}}
+     */
+    get cells_window(): {
+        corner: Int32Array;
+        corner_storage: Uint32Array;
+        size: Uint32Array;
+        period: Uint32Array;
+    };
+    /**
+     * Where a component's faces are stored now: period N plus one along its own axis. A retained
+     * object, rewritten on every call.
+     *
+     * @param {number} component 0, 1 or 2 for u, v or w
+     * @returns {{corner: Int32Array, corner_storage: Uint32Array, size: Uint32Array, period: Uint32Array}}
+     */
+    faces_window(component: number): {
+        corner: Int32Array;
+        corner_storage: Uint32Array;
+        size: Uint32Array;
+        period: Uint32Array;
+    };
+    /**
+     * Move the window: `corner` becomes the world cell at window-local 0. Nothing is written; the
+     * storage wraps, so values still inside the window keep their place, and the cells the move exposed
+     * hold what the cells it left held until a fill writes them.
+     *
+     * @param {ArrayLike<number>} corner
+     */
+    place(corner: ArrayLike<number>): void;
+    /**
+     * Fill a {@link FLUID_CASCADE_PARENT_STRUCT} value and its bindings with what this cascade reads
+     * beyond its window as of its read record: `parent`'s identity read at `t_s`, or the far field's
+     * (a parent with no window, beside this cascade's own stand-ins). What its step, its fill and its
+     * publish (`FluidWindPublish`) read there.
+     *
+     * @param {object} out the value
+     * @param {{u: GPUTextureView|null, v: GPUTextureView|null, w: GPUTextureView|null, pressure: GPUBuffer|null}} out_bindings
+     * @param {GPUFluidCascade|null} parent a cascade of twice the cell and the same resolution, or `null`
+     */
+    describe_parent(out: object, out_bindings: {
+        u: GPUTextureView | null;
+        v: GPUTextureView | null;
+        w: GPUTextureView | null;
+        pressure: GPUBuffer | null;
+    }, parent: GPUFluidCascade | null): void;
+    /**
+     * Record one step into `graph`, from the read record to the instant `atmosphere` describes, and
+     * move the read record there. Nothing is recorded for `dt = 0`, and the record stays.
+     *
+     * @param {object} options
+     * @param {FrameGraph} options.graph
+     * @param {number} options.dt seconds, the step the advection and the solve take
+     * @param {Float64Array|number[]} options.atmosphere a {@link FluidAtmosphere} record, world units:
+     *   `t₁`, at or after the read record
+     * @param {number} options.atmosphere_offset where the record starts in `atmosphere`
+     * @param {GPUFluidCascade|null} options.parent what lies beyond the window: a cascade of twice the
+     *   cell and the same resolution, or `null` for the far field
+     * @param {boolean} options.relaxation_band whether rows 2..5 relax toward the parent (§9)
+     * @param {GPUBuffer} [options.solid] the window's solid flags, `array<u32>`, bit 0; {@link solid} by default
+     * @param {number|null} [options.forcing] the tick's forcing for this cascade, a buffer resource of
+     *   `graph` that `GPUFluidForcing` wrote, read under `FLUID_FORCED_FLAG` of `solid`; `null`, the
+     *   default, for none
+     * @param {number} [options.vorticity_confinement] its strength ε, per second, ≥ 0, as
+     *   `FluidSimulator#vorticity_confinement` reads it: the step records the curl pass and the correct
+     *   pass adds `ε·dt·(N × ω)`, ω per cell. 0, the default, records no curl pass
+     * @param {GPUFluidCascadePressureArm} [options.arm]
+     * @param {number} [options.count] V-cycles under {@link GPUFluidCascadePressureArm.VCycles}, red-black
+     *   sweeps under {@link GPUFluidCascadePressureArm.SOR}
+     */
+    record_step({ graph, dt, atmosphere, atmosphere_offset, parent, relaxation_band, solid, forcing, vorticity_confinement, arm, count, }: {
+        graph: FrameGraph;
+        dt: number;
+        atmosphere: Float64Array | number[];
+        atmosphere_offset: number;
+        parent: GPUFluidCascade | null;
+        relaxation_band: boolean;
+        solid?: GPUBuffer;
+        forcing?: number | null;
+        vorticity_confinement?: number;
+        arm?: GPUFluidCascadePressureArm;
+        count?: number;
+    }): void;
+    /**
+     * Record a fill into `graph`: the cells a placement exposed take the parent's identity read as of
+     * the read record, faces and pressure (§7, §8 pass 0). One dispatch over the boxes' bricks; nothing
+     * for no box.
+     *
+     * @param {object} options
+     * @param {FrameGraph} options.graph
+     * @param {ArrayLike<number>} options.boxes world cells of this cascade, six a box as
+     *   `window_scroll_regions` writes them (smallest cell on x, y, z, then one past the largest), every
+     *   one inside the window and on the 4-cell lattice
+     * @param {number} options.box_count 0 to 3
+     * @param {GPUFluidCascade|null} options.parent the parent to fill from, or `null` for the far field
+     */
+    record_fill({ graph, boxes, box_count, parent }: {
+        graph: FrameGraph;
+        boxes: ArrayLike<number>;
+        box_count: number;
+        parent: GPUFluidCascade | null;
+    }): void;
+    /**
+     * Record the feedback of `child` into this cascade (§8 pass 7, §9), as it must run before this
+     * cascade steps: every face of the parent cells whose children lie
+     * {@link FLUID_CASCADE_FEEDBACK_MARGIN} child cells or more inside the child's window takes the mean
+     * of the four child faces on it, carried from the child's record to this cascade's. One dispatch.
+     *
+     * The child's corner must lie on the even cells of its lattice, so the two lattices' faces coincide,
+     * and its interior inside this window: the nesting a stack keeps.
+     *
+     * @param {object} options
+     * @param {FrameGraph} options.graph
+     * @param {GPUFluidCascade} options.child a cascade of half the cell and the same resolution
+     */
+    record_restrict({ graph, child }: {
+        graph: FrameGraph;
+        child: GPUFluidCascade;
+    }): void;
+    /**
+     * Release everything the cascade made. A step recorded into a graph that has not run yet encodes
+     * nothing; work already submitted keeps what it holds, as WebGPU keeps a destroyed resource for
+     * the commands that use it. Nothing may be recorded after.
+     */
+    destroy(): void;
+    #private;
+}
+export type FrameGraph = import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+export type ShadeGPUCommandContext = import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
+import { FluidMacVelocitySet } from "./mac/FluidMacVelocitySet.js";
+//# sourceMappingURL=GPUFluidCascade.d.ts.map

package/src/shade/renderer/fluid/GPUFluidCascade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GPUFluidCascade.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/fluid/GPUFluidCascade.js"],"names":[],"mappings":"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"}