@woosh/meep-engine 3.49.0 → 3.50.0

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

@@ -0,0 +1,208 @@
+import { WebGPUExtensionType } from "../../../descriptor/WebGPUExtensionType.js";
+import { chunk_collection_u32_append } from "../../gpu_primitive/chunk_collection_u32_append.js";
+import { COLLECTION_U32_STRUCT_WRITE } from "../../gpu_primitive/COLLECTION_U32_STRUCT_WRITE.js";
+import { BVH2_NODE_STRUCT } from "../../shader/chunk/bvh/BVH2_NODE_STRUCT.js";
+import { BVH_STRUCT } from "../../shader/chunk/bvh/BVH_STRUCT.js";
+import { chunk_bvh_query_aabb_cooperative } from "../../shader/chunk/bvh/chunk_bvh_query_aabb_cooperative.js";
+import { BVH_QUERY_AABB_WORKGROUP_SIZE } from "../../shader/chunk/bvh/chunk_bvh_query_aabb_frontier.js";
+import { chunk_folded_workgroup_index } from "../../shader/chunk/grid/chunk_folded_workgroup_index.js";
+import { chunk_index_to_grid3d } from "../../shader/chunk/grid/chunk_index_to_grid3d.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { atomic_u32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { chunk_fluid_forcing_query_select } from "./chunk_fluid_forcing_query_select.js";
+import { FLUID_FORCING_QUERY_STRUCT } from "./FLUID_FORCING_QUERY_STRUCT.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .addUniform("settings", FLUID_FORCING_QUERY_STRUCT)
+    // each slot's tree, over the effectors and the obstacles its cascade resolves; one buffer twice
+    // when the two cascades resolve the same obstacles
+    .addStorageBuffer("tree_0", BVH_STRUCT, false)
+    .addStorageBuffer("tree_1", BVH_STRUCT, false)
+    // the bricks each stepping cascade's forcing runs over, as query indices
+    .addStorageBuffer("list_0", COLLECTION_U32_STRUCT_WRITE, true)
+    .addStorageBuffer("list_1", COLLECTION_U32_STRUCT_WRITE, true)
+    // FLUID_FORCING_SURVIVOR_STRIDE words a query
+    .addStorageBuffer("survivors", WebGPUArray.from(u32), true)
+    // a word a brick of each stepping cascade, persistent: 1 while its solid flags hold something
+    .addStorageBuffer("bricks_0", WebGPUArray.from(u32), true)
+    .addStorageBuffer("bricks_1", WebGPUArray.from(u32), true)
+    // what was dropped, accumulated: obstacles and effectors past their limits, candidates past the
+    // list, nodes never tested
+    .addStorageBuffer("statistics", WebGPUArray.from(atomic_u32), true);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+// the querying slot, the same for the whole workgroup: which tree it walks
+var<private> fluid_forcing_slot: u32;
+
+fn bvh_query_aabb_node(index: u32) -> ${BVH2_NODE_STRUCT.wgsl_ref} {
+    if (fluid_forcing_slot == 0u) {
+        return tree_0.nodes[index];
+    }
+
+    return tree_1.nodes[index];
+}
+
+// the resolution cull is the tree: it holds only the obstacles its cascade resolves
+fn bvh_query_aabb_accept_leaf(payload: u32, bounds: array<f32, 6>) -> bool {
+    return true;
+}
+
+fn fluid_forcing_candidate(index: u32) -> u32 {
+    return bvh_query_aabb_candidates[index];
+}
+
+fn fluid_forcing_brick_state(slot: u32, brick: u32) -> u32 {
+    if (slot == 0u) {
+        return bricks_0[brick];
+    }
+
+    return bricks_1[brick];
+}
+
+fn fluid_forcing_set_brick_state(slot: u32, brick: u32, value: u32) {
+    if (slot == 0u) {
+        bricks_0[brick] = value;
+    } else {
+        bricks_1[brick] = value;
+    }
+}
+
+@compute @workgroup_size(BVH_QUERY_AABB_WORKGROUP_SIZE, 1, 1)
+fn main(
+    @builtin(workgroup_id) workgroup_id: vec3<u32>,
+    @builtin(local_invocation_index) lane: u32,
+) {
+    let query = folded_workgroup_index(workgroup_id);
+
+    if (query >= settings.query_count) {
+        return;
+    }
+
+    let slot = query / settings.brick_count;
+    let brick = query - slot * settings.brick_count;
+
+    var corner = settings.corner_0;
+    var cell_size = settings.cell_size_0;
+    var root = tree_0.root;
+    var obstacle_leaf_count = settings.obstacle_leaf_count_0;
+
+    if (slot != 0u) {
+        corner = settings.corner_1;
+        cell_size = settings.cell_size_1;
+        root = tree_1.root;
+        obstacle_leaf_count = settings.obstacle_leaf_count_1;
+    }
+
+    fluid_forcing_slot = slot;
+
+    let box = fluid_forcing_brick_box(corner, cell_size, index_to_grid3d(brick, settings.bricks.xy));
+    let result = bvh_query_aabb_cooperative(root, box, lane);
+
+    // obstacles sort first; the lowest of each are the survivors
+    let obstacles = fluid_forcing_obstacle_split(result.candidate_count, obstacle_leaf_count);
+    let effectors = result.candidate_count - obstacles;
+
+    let kept_obstacles = min(obstacles, FLUID_FORCING_OBSTACLE_LIMIT);
+    let kept_effectors = min(effectors, FLUID_FORCING_EFFECTOR_LIMIT);
+
+    let touched = kept_obstacles + kept_effectors > 0u;
+    let base = query * FLUID_FORCING_SURVIVOR_STRIDE;
+
+    if (touched) {
+        if (lane < kept_obstacles) {
+            survivors[base + 1u + lane] = bvh_query_aabb_candidates[lane];
+        }
+
+        if (lane < kept_effectors) {
+            survivors[base + 1u + FLUID_FORCING_OBSTACLE_LIMIT + lane] = bvh_query_aabb_candidates[obstacles + lane];
+        }
+    }
+
+    var want = false;
+
+    if (lane == 0u) {
+        // a brick whose flags still hold an earlier tick's is forced too, to clear them
+        let held = fluid_forcing_brick_state(slot, brick);
+        let holds = select(0u, 1u, touched);
+
+        want = touched || held != 0u;
+
+        if (want) {
+            survivors[base] = fluid_forcing_survivor_header(kept_obstacles, kept_effectors);
+        }
+
+        if (held != holds) {
+            fluid_forcing_set_brick_state(slot, brick, holds);
+        }
+
+        if (obstacles > kept_obstacles) {
+            atomicAdd(&statistics[0], obstacles - kept_obstacles);
+        }
+        if (effectors > kept_effectors) {
+            atomicAdd(&statistics[1], effectors - kept_effectors);
+        }
+        if (result.candidates_dropped > 0u) {
+            atomicAdd(&statistics[2], result.candidates_dropped);
+        }
+        if (result.nodes_dropped > 0u) {
+            atomicAdd(&statistics[3], result.nodes_dropped);
+        }
+    }
+
+    // slot is uniform across the workgroup, so each subgroup appends in uniform control flow
+    if (slot == 0u) {
+        collection_u32_append(&list_0, want, query, settings.brick_count);
+    } else {
+        collection_u32_append(&list_1, want, query, settings.brick_count);
+    }
+}
+`, [
+    chunk_folded_workgroup_index,
+    chunk_index_to_grid3d,
+    chunk_bvh_query_aabb_cooperative,
+    chunk_collection_u32_append,
+    chunk_fluid_forcing_query_select,
+]);
+
+body.addExtension(WebGPUExtensionType.Subgroups);
+
+/**
+ * Q1 of a tick (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §10): every brick of every stepping cascade
+ * asks its cascade's LBVH of the frame which leaves meet it, one workgroup a brick, one dispatch for
+ * the tick.
+ *
+ * Query `q` is brick `q mod B` of stepping slot `q / B` (`B` bricks a window; at most two slots, cascade
+ * 0 and the ruler's coarse cascade). Its box is the brick's cells grown by the kernel floor, two of
+ * the cascade's cells (`fluid_forcing_brick_box`), and `chunk_bvh_query_aabb_cooperative` walks the
+ * slot's tree (`tree_0` or `tree_1`) a level at a time in workgroup memory, so a thread's work is
+ * bounded by the tree's depth. The resolution cull is the tree itself: a slot's tree holds the
+ * effectors and only the obstacles its cascade resolves (`GPUFluidForcing`), so no leaf is filtered
+ * here and an obstacle too small for the cascade never takes a place on the frontier. The candidates
+ * come back sorted by leaf, so obstacles (the first leaves) come first and each kind by row; the brick
+ * keeps the first
+ * `FLUID_FORCING_OBSTACLE_LIMIT` obstacles and the first `FLUID_FORCING_EFFECTOR_LIMIT` effectors in
+ * `survivors[q·FLUID_FORCING_SURVIVOR_STRIDE ...]`, and what it could not keep is added to
+ * `statistics`.
+ *
+ * A brick that kept anything, or whose cascade's solid flags still hold what an earlier tick wrote
+ * there (`bricks_s`, one word a brick the cascade keeps), is appended to its slot's list
+ * (`collection_u32_append`, one atomic a subgroup), with its survivor header; the forcing then runs
+ * over exactly those, and writes a held brick's flags to nothing.
+ *
+ * Per invocation: the query's 204 node reads at most and its sort, eight candidate reads for the
+ * split, two survivor writes.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_fluid_forcing_query = ComputeShader.from({
+    label: "Fluid / forcing / brick query",
+    resources,
+    body,
+});

package/src/shade/renderer/fluid/mac/FLUID_MAC_STEP_STRUCT.d.ts

@@ -0,0 +1,35 @@
+/**
+ * What the MAC passes of one cascade step read, as the uniform `step`.
+ *
+ * A cascade is a window of N = (nx, ny, nz) cells. Window-local cell `c ∈ [0, N)` has its centre at
+ * `corner_world + (c + 0.5)·h`; u face `(i, j, k)`, `i ∈ [0, nx]`, sits at cell coordinate
+ * `(i − 0.5, j, k)`, and likewise v along y and w along z.
+ *
+ * Persistent fields are stored toroidally and addressed through the windows (S0's
+ * {@link GRID_TILE_WINDOW_STRUCT}, `grid_tile_window_storage`):
+ * - `cells`: pressure, `array<f32>` of N cells, period N; `size` is N, which is also the window every
+ *   window-local transient (the solid flags, the right-hand side) is laid out over, x fastest.
+ * - `faces_u`, `faces_v`, `faces_w`: the persistent velocity, one `r32float` 3-D texture a component,
+ *   (nx + 1)·ny·nz, nx·(ny + 1)·nz and nx·ny·(nz + 1); size and period are N plus one along the
+ *   component's own axis.
+ *
+ * Each window's `corner` is the world cell (or face) at window-local 0, and `corner_storage` that
+ * corner modulo the window's period.
+ *
+ * The step runs from `t₀`, the instant the cascade's velocity was last brought to (its read record),
+ * to `t₁` (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §6, §8):
+ * - `far_velocity`: `v_far(t₀)`, m/s: what the velocity the step starts from is a deviation from.
+ * - `far_velocity_end`: `v_far(t₁)`, m/s.
+ * - `keep`: `e^(−(Λ(t₁) − Λ(t₀)))`, the deviation the atmosphere leaves over the step.
+ * - `deviation_limit`: m/s, `FLUID_CASCADE_DEVIATION_CELLS·h/dt`, the clamp on `|v − v_far(t₁)|`.
+ * - `band`: 1 when the faces of rows 2..5 relax toward the parent, 0 when they do not.
+ * - `dt_over_h`: dt/h, s/m: cells a velocity of 1 m/s crosses in the step, and the gradient's scale
+ *   `u −= (dt/h)·(p_R − p_L)`.
+ * - `rhs_scale`: 1/(h·dt): the face-difference sum times this is the pressure solve's right-hand
+ *   side, `div/dt` with `div = Σ/h`.
+ * - `confinement_dt`: ε·dt, the vorticity confinement's strength times the step (§8 passes 1 and 3);
+ *   0 when it is off, and then no curl pass ran and the correct pass adds nothing for it.
+ */
+export const FLUID_MAC_STEP_STRUCT: WebGPUStruct;
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+//# sourceMappingURL=FLUID_MAC_STEP_STRUCT.d.ts.map

package/src/shade/renderer/fluid/mac/FLUID_MAC_STEP_STRUCT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FLUID_MAC_STEP_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/mac/FLUID_MAC_STEP_STRUCT.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,iDAamB;6BA/CU,mCAAmC"}

package/src/shade/renderer/fluid/mac/FLUID_MAC_STEP_STRUCT.js

@@ -0,0 +1,50 @@
+import { GRID_TILE_WINDOW_STRUCT } from "../../shader/chunk/grid/GRID_TILE_WINDOW_STRUCT.js";
+import { f32, u32, vec3f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+
+/**
+ * What the MAC passes of one cascade step read, as the uniform `step`.
+ *
+ * A cascade is a window of N = (nx, ny, nz) cells. Window-local cell `c ∈ [0, N)` has its centre at
+ * `corner_world + (c + 0.5)·h`; u face `(i, j, k)`, `i ∈ [0, nx]`, sits at cell coordinate
+ * `(i − 0.5, j, k)`, and likewise v along y and w along z.
+ *
+ * Persistent fields are stored toroidally and addressed through the windows (S0's
+ * {@link GRID_TILE_WINDOW_STRUCT}, `grid_tile_window_storage`):
+ * - `cells`: pressure, `array<f32>` of N cells, period N; `size` is N, which is also the window every
+ *   window-local transient (the solid flags, the right-hand side) is laid out over, x fastest.
+ * - `faces_u`, `faces_v`, `faces_w`: the persistent velocity, one `r32float` 3-D texture a component,
+ *   (nx + 1)·ny·nz, nx·(ny + 1)·nz and nx·ny·(nz + 1); size and period are N plus one along the
+ *   component's own axis.
+ *
+ * Each window's `corner` is the world cell (or face) at window-local 0, and `corner_storage` that
+ * corner modulo the window's period.
+ *
+ * The step runs from `t₀`, the instant the cascade's velocity was last brought to (its read record),
+ * to `t₁` (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §6, §8):
+ * - `far_velocity`: `v_far(t₀)`, m/s: what the velocity the step starts from is a deviation from.
+ * - `far_velocity_end`: `v_far(t₁)`, m/s.
+ * - `keep`: `e^(−(Λ(t₁) − Λ(t₀)))`, the deviation the atmosphere leaves over the step.
+ * - `deviation_limit`: m/s, `FLUID_CASCADE_DEVIATION_CELLS·h/dt`, the clamp on `|v − v_far(t₁)|`.
+ * - `band`: 1 when the faces of rows 2..5 relax toward the parent, 0 when they do not.
+ * - `dt_over_h`: dt/h, s/m: cells a velocity of 1 m/s crosses in the step, and the gradient's scale
+ *   `u −= (dt/h)·(p_R − p_L)`.
+ * - `rhs_scale`: 1/(h·dt): the face-difference sum times this is the pressure solve's right-hand
+ *   side, `div/dt` with `div = Σ/h`.
+ * - `confinement_dt`: ε·dt, the vorticity confinement's strength times the step (§8 passes 1 and 3);
+ *   0 when it is off, and then no curl pass ran and the correct pass adds nothing for it.
+ */
+export const FLUID_MAC_STEP_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,
+    far_velocity: vec3f,
+    dt_over_h: f32,
+    far_velocity_end: vec3f,
+    rhs_scale: f32,
+    keep: f32,
+    deviation_limit: f32,
+    band: u32,
+    confinement_dt: f32,
+}, 'FluidMacStep');

package/src/shade/renderer/fluid/mac/FluidMacPasses.d.ts

@@ -0,0 +1,162 @@
+/**
+ * @typedef {import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext} ShadeGPUCommandContext
+ * @typedef {import("./FluidMacVelocitySet.js").FluidMacVelocitySet} FluidMacVelocitySet
+ * @typedef {{u: GPUTextureView, v: GPUTextureView, w: GPUTextureView}} FluidMacVelocityViews a MAC
+ *   velocity field's three component views: a {@link FluidMacVelocitySet}'s, or a frame graph's
+ *   transient textures'
+ * @typedef {{uniform: GPUBuffer, u: GPUTextureView, v: GPUTextureView, w: GPUTextureView, pressure: GPUBuffer}} FluidCascadeParentBindings
+ *   what a step reads of its parent beyond its window: `uniform`, the parent as
+ *   {@link FLUID_CASCADE_PARENT_STRUCT}; `u`, `v`, `w`, its persistent faces; `pressure`, its pressure.
+ *   A far-field parent binds stand-ins it never reads.
+ * @typedef {{u: GPUTextureView, v: GPUTextureView, w: GPUTextureView, pressure: GPUBuffer}} FluidCascadeGhostBindings
+ *   a step's ghosts (`shader_fluid_cascade_ghosts`): `u`, `v`, `w`, the velocity shells, transient
+ *   `r32float` textures of each face lattice grown by `FLUID_CASCADE_GHOST_DEPTH` on every side;
+ *   `pressure`, the pressure ghosts over the window grown by one cell.
+ */
+/**
+ * Records the MAC passes of one cascade's step (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §8): the
+ * advection (predict, then correct), the right-hand side of the pressure solve, and the gradient
+ * subtraction that writes the step's end velocity. The pressure solve between the last two is not
+ * here.
+ *
+ * One instance a cascade. {@link place} puts its window, {@link set_step} sets a step's h, dt and far
+ * field, and each `record_*` records into the encoder a frame-graph pass hands its callback. Each
+ * record serialises the step's parameters into a transient uniform of its own (pooled by the
+ * encoder), so a step recorded later in the frame cannot change what an earlier one reads.
+ *
+ * The step's order and what moves between the passes, A the cascade's persistent velocity:
+ *
+ *     record_ghosts(encoder, parent, G)                                parent → G (the step's ghosts)
+ *     record_curl(encoder, A, solid, C)                                A → C, the confinement force (with confinement)
+ *     record_advect(encoder, A, F, B, solid, forcing, C, parent, G)    A → F (predict), A + F + C + forcing → B (correct)
+ *     record_divergence(encoder, B, solid, rhs)                        B → rhs = div/dt
+ *     (the pressure solve: rhs → pressure, its ghosts G)
+ *     record_gradient(encoder, B, pressure, solid, A, G)               B + pressure → A
+ *
+ * so A is the only velocity a cascade keeps between steps, and F and B are transients. Beyond the
+ * window, the advection reads the step's ghosts of the parent's faces and the gradient those of its
+ * pressure ({@link FluidCascadeGhostBindings}), each written once a step from the parent
+ * ({@link FluidCascadeParentBindings}).
+ *
+ * Every pass dispatches `(nx / 8, ny / 8, nz / 4)` workgroups, the ghosts `ceil((n + 1 + 2·depth) / 4)`
+ * on each axis, a texel of the largest shell an invocation. Nothing here allocates once placed:
+ * the parameters, bindings and dispatch arguments are retained and rewritten in place.
+ */
+export class FluidMacPasses {
+    /**
+     * Where the cascade's window is.
+     *
+     * @param {ArrayLike<number>} resolution cells on each axis, each a power of two, at least 8, 8, 4
+     * @param {ArrayLike<number>} corner the world cell at window-local (0, 0, 0)
+     */
+    place(resolution: ArrayLike<number>, corner: ArrayLike<number>): void;
+    /**
+     * The step about to be recorded, from `t₀` to `t₁` (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §6, §8).
+     *
+     * @param {number} h cell size, m
+     * @param {number} dt time step, s
+     * @param {ArrayLike<number>} far_velocity `v_far(t₀)`, m/s: what the velocity the step starts from
+     *   is a deviation from
+     * @param {ArrayLike<number>} far_velocity_end `v_far(t₁)`, m/s
+     * @param {number} keep `e^(−(Λ(t₁) − Λ(t₀)))`, in [0, 1]
+     * @param {boolean} band whether the faces of rows 2..5 relax toward the parent
+     * @param {number} confinement the vorticity confinement's strength ε, per second, ≥ 0: 0 for none,
+     *   and then {@link record_curl} is not recorded for the step
+     */
+    set_step(h: number, dt: number, far_velocity: ArrayLike<number>, far_velocity_end: ArrayLike<number>, keep: number, band: boolean, confinement: number): void;
+    /**
+     * The step's vorticity confinement, pass 1 (`shader_fluid_mac_curl`): the curl of the persistent
+     * velocity and the force it makes in every cell, for the correct pass. Recorded only for a step whose
+     * confinement is not 0, before {@link record_advect}.
+     *
+     * @param {ShadeGPUCommandContext} encoder
+     * @param {FluidMacVelocityViews} source the persistent velocity, toroidal; read
+     * @param {GPUBuffer} solid the window-local solid flags, `array<u32>`, bit 0
+     * @param {GPUBuffer} confinement written, `array<f32>` of 3·N cells, window-local
+     */
+    record_curl(encoder: ShadeGPUCommandContext, source: FluidMacVelocityViews, solid: GPUBuffer, confinement: GPUBuffer): void;
+    /**
+     * MacCormack advection of the persistent velocity by itself: predict into `forward`, then correct
+     * into `out`, which adds the step's confinement and the tick's forcing.
+     *
+     * @param {ShadeGPUCommandContext} encoder
+     * @param {FluidMacVelocityViews} source the persistent velocity, toroidal; read
+     * @param {FluidMacVelocityViews} forward a transient, window-local; written, then read
+     * @param {FluidMacVelocityViews} out a transient, window-local; written
+     * @param {GPUBuffer} solid the window-local solid flags, `array<u32>`: bit 0 solid, bit 1
+     *   (`FLUID_FORCED_FLAG`) forcing written for the cell's faces
+     * @param {GPUBuffer} forcing the tick's forcing, `array<f32>` over the three face lattices
+     *   (`shader_fluid_mac_advect_correct`); read only where `solid` says it was written
+     * @param {GPUBuffer} confinement what {@link record_curl} wrote for the step; read only when the
+     *   step's confinement is not 0
+     * @param {FluidCascadeParentBindings} parent what lies beyond the window, past its ghosts
+     * @param {FluidCascadeGhostBindings} ghosts the step's ghosts, written by {@link record_ghosts}
+     */
+    record_advect(encoder: ShadeGPUCommandContext, source: FluidMacVelocityViews, forward: FluidMacVelocityViews, out: FluidMacVelocityViews, solid: GPUBuffer, forcing: GPUBuffer, confinement: GPUBuffer, parent: FluidCascadeParentBindings, ghosts: FluidCascadeGhostBindings): void;
+    /**
+     * The step's ghosts (`shader_fluid_cascade_ghosts`): the parent's identity read at every face of the
+     * velocity shells and its pressure at every cell one past the window, once, for the step's passes.
+     *
+     * @param {ShadeGPUCommandContext} encoder
+     * @param {FluidCascadeParentBindings} parent
+     * @param {FluidCascadeGhostBindings} ghosts written
+     */
+    record_ghosts(encoder: ShadeGPUCommandContext, parent: FluidCascadeParentBindings, ghosts: FluidCascadeGhostBindings): void;
+    /**
+     * The right-hand side of the pressure solve, `div/dt` at every cell, 0 in solid cells.
+     *
+     * @param {ShadeGPUCommandContext} encoder
+     * @param {FluidMacVelocityViews} velocity the advected velocity, window-local; read
+     * @param {GPUBuffer} solid the window-local solid flags, `array<u32>`, bit 0
+     * @param {GPUBuffer} rhs written, `array<f32>` of N cells, window-local, x fastest
+     */
+    record_divergence(encoder: ShadeGPUCommandContext, velocity: FluidMacVelocityViews, solid: GPUBuffer, rhs: GPUBuffer): void;
+    /**
+     * The pressure gradient taken from the advected velocity, into the persistent velocity.
+     *
+     * @param {ShadeGPUCommandContext} encoder
+     * @param {FluidMacVelocityViews} velocity the advected velocity, window-local; read
+     * @param {GPUBuffer} pressure kinematic pressure, m²/s², `array<f32>` of N cells, toroidal; read
+     * @param {GPUBuffer} solid the window-local solid flags, `array<u32>`, bit 0
+     * @param {FluidMacVelocityViews} out the persistent velocity, toroidal; written
+     * @param {FluidCascadeGhostBindings} ghosts the step's ghosts: `pressure` is the pressure beyond the window
+     */
+    record_gradient(encoder: ShadeGPUCommandContext, velocity: FluidMacVelocityViews, pressure: GPUBuffer, solid: GPUBuffer, out: FluidMacVelocityViews, ghosts: FluidCascadeGhostBindings): void;
+    #private;
+}
+export type ShadeGPUCommandContext = import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
+export type FluidMacVelocitySet = import("./FluidMacVelocitySet.js").FluidMacVelocitySet;
+/**
+ * a MAC
+ * velocity field's three component views: a {@link FluidMacVelocitySet }'s, or a frame graph's
+ * transient textures'
+ */
+export type FluidMacVelocityViews = {
+    u: GPUTextureView;
+    v: GPUTextureView;
+    w: GPUTextureView;
+};
+/**
+ * what a step reads of its parent beyond its window: `uniform`, the parent as
+ * {@link FLUID_CASCADE_PARENT_STRUCT }; `u`, `v`, `w`, its persistent faces; `pressure`, its pressure.
+ * A far-field parent binds stand-ins it never reads.
+ */
+export type FluidCascadeParentBindings = {
+    uniform: GPUBuffer;
+    u: GPUTextureView;
+    v: GPUTextureView;
+    w: GPUTextureView;
+    pressure: GPUBuffer;
+};
+/**
+ * a step's ghosts (`shader_fluid_cascade_ghosts`): `u`, `v`, `w`, the velocity shells, transient
+ * `r32float` textures of each face lattice grown by `FLUID_CASCADE_GHOST_DEPTH` on every side;
+ * `pressure`, the pressure ghosts over the window grown by one cell.
+ */
+export type FluidCascadeGhostBindings = {
+    u: GPUTextureView;
+    v: GPUTextureView;
+    w: GPUTextureView;
+    pressure: GPUBuffer;
+};
+//# sourceMappingURL=FluidMacPasses.d.ts.map

package/src/shade/renderer/fluid/mac/FluidMacPasses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FluidMacPasses.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/mac/FluidMacPasses.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAsEI;;;;;OAKG;IACH,kBAHW,UAAU,MAAM,CAAC,UACjB,UAAU,MAAM,CAAC,QAkC3B;IAED;;;;;;;;;;;;OAYG;IACH,YAVW,MAAM,MACN,MAAM,gBACN,UAAU,MAAM,CAAC,oBAEjB,UAAU,MAAM,CAAC,QACjB,MAAM,QACN,OAAO,eACP,MAAM,QA+BhB;IAaD;;;;;;;;;OASG;IACH,qBALW,sBAAsB,UACtB,qBAAqB,kDAmB/B;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,uBAbW,sBAAsB,UACtB,qBAAqB,WACrB,qBAAqB,OACrB,qBAAqB,wEAOrB,0BAA0B,UAC1B,yBAAyB,QA0CnC;IAED;;;;;;;OAOG;IACH,uBAJW,sBAAsB,UACtB,0BAA0B,UAC1B,yBAAyB,QAgBnC;IAED;;;;;;;OAOG;IACH,2BALW,sBAAsB,YACtB,qBAAqB,0CAgB/B;IAED;;;;;;;;;OASG;IACH,yBAPW,sBAAsB,YACtB,qBAAqB,8CAGrB,qBAAqB,UACrB,yBAAyB,QAmBnC;;CACJ;qCAhXY,OAAO,2CAA2C,EAAE,sBAAsB;kCAC1E,OAAO,0BAA0B,EAAE,mBAAmB;;;;;;oCACtD;IAAC,CAAC,iBAAiB;IAAC,CAAC,iBAAiB;IAAC,CAAC,iBAAgB;CAAC;;;;;;yCAGzD;IAAC,OAAO,YAAY;IAAC,CAAC,iBAAiB;IAAC,CAAC,iBAAiB;IAAC,CAAC,iBAAiB;IAAC,QAAQ,YAAW;CAAC;;;;;;wCAIlG;IAAC,CAAC,iBAAiB;IAAC,CAAC,iBAAiB;IAAC,CAAC,iBAAiB;IAAC,QAAQ,YAAW;CAAC"}