@woosh/meep-engine 3.49.0 → 3.50.0

package/src/shade/renderer/fluid/pressure/chunk_fluid_mg_level0_word.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_fluid_mg_level0_word.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/pressure/chunk_fluid_mg_level0_word.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH,yCAFU,SAAS,CA+BO;0BA9CA,oCAAoC"}

package/src/shade/renderer/fluid/pressure/chunk_fluid_mg_level0_word.js

@@ -0,0 +1,47 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_fluid_mg_word } from "./chunk_fluid_mg_word.js";
+
+/**
+ * The finest level's weight word of a cell, from the solid flags (`chunk_fluid_mg_word`).
+ *
+ * `fn fluid_mg_level0_word(cell: vec3<i32>, size: vec3<u32>) -> u32` — for a window-local cell of a
+ * window of `size` cells: 0 when the cell is solid; otherwise a face is open all over when the cell
+ * beyond it is fluid, and a cell beyond the window is fluid.
+ *
+ * ## What the enclosing shader defines
+ *
+ * `fn fluid_mg_read_solid(cell: vec3<i32>) -> bool` — the solid flag of a window-local cell inside the
+ * window.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_fluid_mg_level0_word = CodeChunk.from(
+    //language=WGSL
+    `
+// whether the finest-level cell is solid; a cell beyond the window is fluid
+fn fluid_mg_level0_solid(cell: vec3<i32>, size: vec3<u32>) -> bool {
+    if (any(cell < vec3<i32>(0)) || any(cell >= vec3<i32>(size))) {
+        return false;
+    }
+
+    return fluid_mg_read_solid(cell);
+}
+
+// a face's field, placed, from whether the cell beyond it is solid
+fn fluid_mg_level0_face(far_solid: bool, face: u32) -> u32 {
+    return select(FLUID_MG_FACE_OPEN, 0u, far_solid) << (face * FLUID_MG_FACE_BITS);
+}
+
+fn fluid_mg_level0_word(cell: vec3<i32>, size: vec3<u32>) -> u32 {
+    if (fluid_mg_level0_solid(cell, size)) {
+        return 0u;
+    }
+
+    return fluid_mg_level0_face(fluid_mg_level0_solid(cell - vec3<i32>(1, 0, 0), size), 0u)
+        | fluid_mg_level0_face(fluid_mg_level0_solid(cell + vec3<i32>(1, 0, 0), size), 1u)
+        | fluid_mg_level0_face(fluid_mg_level0_solid(cell - vec3<i32>(0, 1, 0), size), 2u)
+        | fluid_mg_level0_face(fluid_mg_level0_solid(cell + vec3<i32>(0, 1, 0), size), 3u)
+        | fluid_mg_level0_face(fluid_mg_level0_solid(cell - vec3<i32>(0, 0, 1), size), 4u)
+        | fluid_mg_level0_face(fluid_mg_level0_solid(cell + vec3<i32>(0, 0, 1), size), 5u);
+}
+`, [chunk_fluid_mg_word]);

package/src/shade/renderer/fluid/pressure/chunk_fluid_mg_prolong.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The pressure V-cycle's prolongation: the coarse error, trilinearly at a fine cell.
+ *
+ * `fn fluid_mg_prolong(fine: vec3<i32>, coarse_size: vec3<u32>) -> f32` — the fine cell (on its level,
+ * inside it) lies in coarse cell `fine >> 1`, a quarter of a coarse cell from its centre toward the
+ * neighbour `o = ±1` per axis. The answer weighs that cell and its neighbours along `o` by 3/4 and 1/4
+ * per axis: 27/64, 9/64 (three), 3/64 (three), 1/64. A coarse cell beyond the coarse level is 0: the
+ * error's ghost.
+ *
+ * It is pointwise, so a smoother can add it in its tile load (`fetch = p + P·e`) instead of a separate
+ * pass writing it first; the two are the same arithmetic.
+ *
+ * ## What the enclosing shader defines
+ *
+ * `fn fluid_mg_read_coarse(cell: vec3<i32>) -> f32` — the coarse error at a coarse cell inside its level.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_fluid_mg_prolong: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_fluid_mg_prolong.d.ts.map

package/src/shade/renderer/fluid/pressure/chunk_fluid_mg_prolong.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_fluid_mg_prolong.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/pressure/chunk_fluid_mg_prolong.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,qCAFU,SAAS,CA4BhB;0BA9CuB,oCAAoC"}

package/src/shade/renderer/fluid/pressure/chunk_fluid_mg_prolong.js

@@ -0,0 +1,47 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * The pressure V-cycle's prolongation: the coarse error, trilinearly at a fine cell.
+ *
+ * `fn fluid_mg_prolong(fine: vec3<i32>, coarse_size: vec3<u32>) -> f32` — the fine cell (on its level,
+ * inside it) lies in coarse cell `fine >> 1`, a quarter of a coarse cell from its centre toward the
+ * neighbour `o = ±1` per axis. The answer weighs that cell and its neighbours along `o` by 3/4 and 1/4
+ * per axis: 27/64, 9/64 (three), 3/64 (three), 1/64. A coarse cell beyond the coarse level is 0: the
+ * error's ghost.
+ *
+ * It is pointwise, so a smoother can add it in its tile load (`fetch = p + P·e`) instead of a separate
+ * pass writing it first; the two are the same arithmetic.
+ *
+ * ## What the enclosing shader defines
+ *
+ * `fn fluid_mg_read_coarse(cell: vec3<i32>) -> f32` — the coarse error at a coarse cell inside its level.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_fluid_mg_prolong = CodeChunk.from(
+    //language=WGSL
+    `
+fn fluid_mg_prolong_tap(cell: vec3<i32>, coarse_size: vec3<u32>) -> f32 {
+    if (any(cell < vec3<i32>(0)) || any(cell >= vec3<i32>(coarse_size))) {
+        return 0.0;
+    }
+
+    return fluid_mg_read_coarse(cell);
+}
+
+fn fluid_mg_prolong(fine: vec3<i32>, coarse_size: vec3<u32>) -> f32 {
+    let c = fine >> vec3<u32>(1u);
+    let o = select(vec3<i32>(-1), vec3<i32>(1), (fine & vec3<i32>(1)) == vec3<i32>(1));
+
+    var v = 0.421875 * fluid_mg_prolong_tap(c, coarse_size);
+    v += 0.140625 * fluid_mg_prolong_tap(c + vec3<i32>(o.x, 0, 0), coarse_size);
+    v += 0.140625 * fluid_mg_prolong_tap(c + vec3<i32>(0, o.y, 0), coarse_size);
+    v += 0.046875 * fluid_mg_prolong_tap(c + vec3<i32>(o.x, o.y, 0), coarse_size);
+    v += 0.140625 * fluid_mg_prolong_tap(c + vec3<i32>(0, 0, o.z), coarse_size);
+    v += 0.046875 * fluid_mg_prolong_tap(c + vec3<i32>(o.x, 0, o.z), coarse_size);
+    v += 0.046875 * fluid_mg_prolong_tap(c + vec3<i32>(0, o.y, o.z), coarse_size);
+    v += 0.015625 * fluid_mg_prolong_tap(c + o, coarse_size);
+
+    return v;
+}
+`);

package/src/shade/renderer/fluid/pressure/chunk_fluid_mg_relax.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The pressure V-cycle's per-cell operator, `Σ_f w_f·(p_nb − p) / H² = f`, as its smoother and its
+ * residual use it.
+ *
+ * - `fn fluid_mg_stencil(local: vec3<i32>, cell: vec3<u32>, size: vec3<u32>, word: u32, edge_weight: f32) -> vec2<f32>`
+ *   — `(Σ w·p_nb, Σ w)` of a cell: its six neighbours read through `tile_read_p` at the tile-local
+ *   cells around `local`, weighted by its word (`chunk_fluid_mg_word`). `cell` is the cell on its
+ *   level of `size` cells, which says which faces lie on the window's edge. The faces are summed in
+ *   the word's order, −x, +x, −y, +y, −z, +z.
+ * - `fn fluid_mg_relax(p: f32, stencil: vec2<f32>, f: f32, h2: f32, omega: f32) -> f32` — the smoother's
+ *   update, `(1 − ω)·p + ω·(Σ w·p_nb − H²·f) / Σ w`; `p` itself for a cell with no degree of freedom
+ *   (`Σ w = 0`). At ω = 1 it is the Gauss–Seidel value exactly.
+ * - `fn fluid_mg_residual(p: f32, stencil: vec2<f32>, f: f32, h2: f32) -> f32` — `f − (Σ w·p_nb − Σ w·p) / H²`;
+ *   0 for a cell with no degree of freedom.
+ *
+ * ## What the enclosing shader defines
+ *
+ * `fn tile_read_p(local: vec3<i32>) -> f32` — the pressure or error at a tile-local cell, from the
+ * tile's halo where the cell is outside it, where a cell beyond the window holds its ghost value. A
+ * kernel backs it with its workgroup tile (`chunk_grid_tile_halo_f32`); a spec with a buffer. It must
+ * answer a finite value: a closed face weighs its neighbour by 0, and 0·NaN is NaN.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_fluid_mg_relax: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_fluid_mg_relax.d.ts.map

package/src/shade/renderer/fluid/pressure/chunk_fluid_mg_relax.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_fluid_mg_relax.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/pressure/chunk_fluid_mg_relax.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,mCAFU,SAAS,CAqDO;0BA9EA,oCAAoC"}

package/src/shade/renderer/fluid/pressure/chunk_fluid_mg_relax.js

@@ -0,0 +1,79 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_fluid_mg_word } from "./chunk_fluid_mg_word.js";
+
+/**
+ * The pressure V-cycle's per-cell operator, `Σ_f w_f·(p_nb − p) / H² = f`, as its smoother and its
+ * residual use it.
+ *
+ * - `fn fluid_mg_stencil(local: vec3<i32>, cell: vec3<u32>, size: vec3<u32>, word: u32, edge_weight: f32) -> vec2<f32>`
+ *   — `(Σ w·p_nb, Σ w)` of a cell: its six neighbours read through `tile_read_p` at the tile-local
+ *   cells around `local`, weighted by its word (`chunk_fluid_mg_word`). `cell` is the cell on its
+ *   level of `size` cells, which says which faces lie on the window's edge. The faces are summed in
+ *   the word's order, −x, +x, −y, +y, −z, +z.
+ * - `fn fluid_mg_relax(p: f32, stencil: vec2<f32>, f: f32, h2: f32, omega: f32) -> f32` — the smoother's
+ *   update, `(1 − ω)·p + ω·(Σ w·p_nb − H²·f) / Σ w`; `p` itself for a cell with no degree of freedom
+ *   (`Σ w = 0`). At ω = 1 it is the Gauss–Seidel value exactly.
+ * - `fn fluid_mg_residual(p: f32, stencil: vec2<f32>, f: f32, h2: f32) -> f32` — `f − (Σ w·p_nb − Σ w·p) / H²`;
+ *   0 for a cell with no degree of freedom.
+ *
+ * ## What the enclosing shader defines
+ *
+ * `fn tile_read_p(local: vec3<i32>) -> f32` — the pressure or error at a tile-local cell, from the
+ * tile's halo where the cell is outside it, where a cell beyond the window holds its ghost value. A
+ * kernel backs it with its workgroup tile (`chunk_grid_tile_halo_f32`); a spec with a buffer. It must
+ * answer a finite value: a closed face weighs its neighbour by 0, and 0·NaN is NaN.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_fluid_mg_relax = CodeChunk.from(
+    //language=WGSL
+    `
+fn fluid_mg_stencil(local: vec3<i32>, cell: vec3<u32>, size: vec3<u32>, word: u32, edge_weight: f32) -> vec2<f32> {
+    let last = size - vec3<u32>(1u);
+
+    var s = 0.0;
+    var d = 0.0;
+
+    var w = fluid_mg_face_weight(word, 0u, cell.x == 0u, edge_weight);
+    s += w * tile_read_p(local - vec3<i32>(1, 0, 0));
+    d += w;
+
+    w = fluid_mg_face_weight(word, 1u, cell.x == last.x, edge_weight);
+    s += w * tile_read_p(local + vec3<i32>(1, 0, 0));
+    d += w;
+
+    w = fluid_mg_face_weight(word, 2u, cell.y == 0u, edge_weight);
+    s += w * tile_read_p(local - vec3<i32>(0, 1, 0));
+    d += w;
+
+    w = fluid_mg_face_weight(word, 3u, cell.y == last.y, edge_weight);
+    s += w * tile_read_p(local + vec3<i32>(0, 1, 0));
+    d += w;
+
+    w = fluid_mg_face_weight(word, 4u, cell.z == 0u, edge_weight);
+    s += w * tile_read_p(local - vec3<i32>(0, 0, 1));
+    d += w;
+
+    w = fluid_mg_face_weight(word, 5u, cell.z == last.z, edge_weight);
+    s += w * tile_read_p(local + vec3<i32>(0, 0, 1));
+    d += w;
+
+    return vec2<f32>(s, d);
+}
+
+fn fluid_mg_relax(p: f32, stencil: vec2<f32>, f: f32, h2: f32, omega: f32) -> f32 {
+    if (stencil.y == 0.0) {
+        return p;
+    }
+
+    return (1.0 - omega) * p + omega * ((stencil.x - h2 * f) / stencil.y);
+}
+
+fn fluid_mg_residual(p: f32, stencil: vec2<f32>, f: f32, h2: f32) -> f32 {
+    if (stencil.y == 0.0) {
+        return 0.0;
+    }
+
+    return f - (stencil.x - stencil.y * p) / h2;
+}
+`, [chunk_fluid_mg_word]);

package/src/shade/renderer/fluid/pressure/chunk_fluid_mg_restrict.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The pressure V-cycle's restriction: the 8-child mean of the residual.
+ *
+ * `fn fluid_mg_restrict(coarse: vec3<i32>) -> f32` — the mean over the children
+ * `2·coarse + (k & 1, (k >> 1) & 1, k >> 2)`, summed in `k` order and scaled by 1/8. A child with no
+ * degree of freedom has residual 0, and counts as one of the eight.
+ *
+ * ## What the enclosing shader defines
+ *
+ * `fn tile_read_r(local: vec3<i32>) -> f32` — the residual of a fine cell, by its coordinate relative to
+ * whatever `coarse` is relative to: a kernel restricting a tile passes tile-local coarse cells and
+ * reads its workgroup's residuals.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_fluid_mg_restrict: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_fluid_mg_restrict.d.ts.map

package/src/shade/renderer/fluid/pressure/chunk_fluid_mg_restrict.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_fluid_mg_restrict.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/pressure/chunk_fluid_mg_restrict.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,sCAFU,SAAS,CAmBhB;0BAlCuB,oCAAoC"}

package/src/shade/renderer/fluid/pressure/chunk_fluid_mg_restrict.js

@@ -0,0 +1,35 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * The pressure V-cycle's restriction: the 8-child mean of the residual.
+ *
+ * `fn fluid_mg_restrict(coarse: vec3<i32>) -> f32` — the mean over the children
+ * `2·coarse + (k & 1, (k >> 1) & 1, k >> 2)`, summed in `k` order and scaled by 1/8. A child with no
+ * degree of freedom has residual 0, and counts as one of the eight.
+ *
+ * ## What the enclosing shader defines
+ *
+ * `fn tile_read_r(local: vec3<i32>) -> f32` — the residual of a fine cell, by its coordinate relative to
+ * whatever `coarse` is relative to: a kernel restricting a tile passes tile-local coarse cells and
+ * reads its workgroup's residuals.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_fluid_mg_restrict = CodeChunk.from(
+    //language=WGSL
+    `
+fn fluid_mg_restrict(coarse: vec3<i32>) -> f32 {
+    let base = coarse * 2;
+
+    var s = tile_read_r(base);
+    s += tile_read_r(base + vec3<i32>(1, 0, 0));
+    s += tile_read_r(base + vec3<i32>(0, 1, 0));
+    s += tile_read_r(base + vec3<i32>(1, 1, 0));
+    s += tile_read_r(base + vec3<i32>(0, 0, 1));
+    s += tile_read_r(base + vec3<i32>(1, 0, 1));
+    s += tile_read_r(base + vec3<i32>(0, 1, 1));
+    s += tile_read_r(base + vec3<i32>(1, 1, 1));
+
+    return s * 0.125;
+}
+`);

package/src/shade/renderer/fluid/pressure/chunk_fluid_mg_word.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Reading the pressure V-cycle's weight words (see `FLUID_MG.js`): one `u32` a cell, six faces of
+ * {@link FLUID_MG_FACE_BITS} bits in the order −x, +x, −y, +y, −z, +z, each the face's open area in
+ * sixteenths, {@link FLUID_MG_FACE_OPEN} when open all over.
+ *
+ * - `fn fluid_mg_face(word: u32, face: u32) -> u32` — a face's field.
+ * - `fn fluid_mg_face_weight(word: u32, face: u32, at_edge: bool, edge_weight: f32) -> f32` — its weight
+ *   in the operator: the open fraction, times the level's edge weight `2 / (1 + h/H)` when the face
+ *   lies on the window's edge.
+ *
+ * @see chunk_fluid_mg_level0_word
+ * @see chunk_fluid_mg_coarse_word
+ * @type {CodeChunk}
+ */
+export const chunk_fluid_mg_word: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_fluid_mg_word.d.ts.map

package/src/shade/renderer/fluid/pressure/chunk_fluid_mg_word.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_fluid_mg_word.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/pressure/chunk_fluid_mg_word.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH,kCAFU,SAAS,CAkBhB;0BAjCuB,oCAAoC"}

package/src/shade/renderer/fluid/pressure/chunk_fluid_mg_word.js

@@ -0,0 +1,34 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { FLUID_MG_FACE_BITS, FLUID_MG_FACE_OPEN } from "./FLUID_MG.js";
+
+/**
+ * Reading the pressure V-cycle's weight words (see `FLUID_MG.js`): one `u32` a cell, six faces of
+ * {@link FLUID_MG_FACE_BITS} bits in the order −x, +x, −y, +y, −z, +z, each the face's open area in
+ * sixteenths, {@link FLUID_MG_FACE_OPEN} when open all over.
+ *
+ * - `fn fluid_mg_face(word: u32, face: u32) -> u32` — a face's field.
+ * - `fn fluid_mg_face_weight(word: u32, face: u32, at_edge: bool, edge_weight: f32) -> f32` — its weight
+ *   in the operator: the open fraction, times the level's edge weight `2 / (1 + h/H)` when the face
+ *   lies on the window's edge.
+ *
+ * @see chunk_fluid_mg_level0_word
+ * @see chunk_fluid_mg_coarse_word
+ * @type {CodeChunk}
+ */
+export const chunk_fluid_mg_word = CodeChunk.from(
+    //language=WGSL
+    `
+const FLUID_MG_FACE_BITS = ${FLUID_MG_FACE_BITS}u;
+const FLUID_MG_FACE_MASK = ${(1 << FLUID_MG_FACE_BITS) - 1}u;
+const FLUID_MG_FACE_OPEN = ${FLUID_MG_FACE_OPEN}u;
+
+fn fluid_mg_face(word: u32, face: u32) -> u32 {
+    return (word >> (face * FLUID_MG_FACE_BITS)) & FLUID_MG_FACE_MASK;
+}
+
+fn fluid_mg_face_weight(word: u32, face: u32, at_edge: bool, edge_weight: f32) -> f32 {
+    let open = f32(fluid_mg_face(word, face)) * ${1 / FLUID_MG_FACE_OPEN};
+
+    return select(open, open * edge_weight, at_edge);
+}
+`);

package/src/shade/renderer/fluid/pressure/chunk_fluid_pressure_ghost.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The pressure beyond a cascade's window: a Dirichlet value at the centre of the ghost cell, in the
+ * cascade's physical units (m²/s²).
+ *
+ * `fn fluid_pressure_ghost(world_cell: vec3<i32>) -> f32`
+ *
+ * It is the parent's pressure at the ghost cell's centre (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §9),
+ * evaluated once a step into the step's pressure ghosts (`shader_fluid_cascade_ghosts`) and read here
+ * from `ghost_pressure`, `array<f32>` over the window grown by one cell on every side, x fastest. The
+ * coarsest cascade's parent is the far field, whose pressure is 0. Only the finest level asks, and
+ * only one cell past the window; a coarse level solves for an error, whose ghost is 0.
+ *
+ * A shader including this chunk binds `ghost_pressure` and defines where the window is:
+ * `fn fluid_pressure_ghost_corner() -> vec3<i32>`, the world cell at window-local 0, and
+ * `fn fluid_pressure_ghost_size() -> vec3<u32>`, its cells.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_fluid_pressure_ghost: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_fluid_pressure_ghost.d.ts.map

package/src/shade/renderer/fluid/pressure/chunk_fluid_pressure_ghost.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_fluid_pressure_ghost.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/pressure/chunk_fluid_pressure_ghost.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,yCAFU,SAAS,CAehB;0BAjCuB,oCAAoC"}

package/src/shade/renderer/fluid/pressure/chunk_fluid_pressure_ghost.js

@@ -0,0 +1,34 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * The pressure beyond a cascade's window: a Dirichlet value at the centre of the ghost cell, in the
+ * cascade's physical units (m²/s²).
+ *
+ * `fn fluid_pressure_ghost(world_cell: vec3<i32>) -> f32`
+ *
+ * It is the parent's pressure at the ghost cell's centre (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §9),
+ * evaluated once a step into the step's pressure ghosts (`shader_fluid_cascade_ghosts`) and read here
+ * from `ghost_pressure`, `array<f32>` over the window grown by one cell on every side, x fastest. The
+ * coarsest cascade's parent is the far field, whose pressure is 0. Only the finest level asks, and
+ * only one cell past the window; a coarse level solves for an error, whose ghost is 0.
+ *
+ * A shader including this chunk binds `ghost_pressure` and defines where the window is:
+ * `fn fluid_pressure_ghost_corner() -> vec3<i32>`, the world cell at window-local 0, and
+ * `fn fluid_pressure_ghost_size() -> vec3<u32>`, its cells.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_fluid_pressure_ghost = CodeChunk.from(
+    //language=WGSL
+    `
+fn fluid_pressure_ghost(world_cell: vec3<i32>) -> f32 {
+    let cell = world_cell - fluid_pressure_ghost_corner() + vec3<i32>(1);
+    let n = vec3<i32>(fluid_pressure_ghost_size()) + vec3<i32>(2);
+
+    if (any(cell < vec3<i32>(0)) || any(cell >= n)) {
+        return 0.0;
+    }
+
+    return ghost_pressure[u32(cell.x + n.x * (cell.y + n.y * cell.z))];
+}
+`);

package/src/shade/renderer/fluid/pressure/shader_fluid_mg_coarse_weights.d.ts

@@ -0,0 +1,10 @@
+/**
+ * A coarse level's weight words from the level above's, one invocation a coarse cell
+ * (`chunk_fluid_mg_coarse_word`). `size` is the coarse level; the level above is twice it on every axis.
+ * Run once a solve per coarse level, finest first.
+ *
+ * Dispatched as `ceil(size / (8, 8, 4))` workgroups.
+ */
+export const shader_fluid_mg_coarse_weights: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_fluid_mg_coarse_weights.d.ts.map

package/src/shade/renderer/fluid/pressure/shader_fluid_mg_coarse_weights.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_fluid_mg_coarse_weights.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/pressure/shader_fluid_mg_coarse_weights.js"],"names":[],"mappings":"AAeA;;;;;;GAMG;AACH,2DAsBG;8BA3C2B,+BAA+B"}

package/src/shade/renderer/fluid/pressure/shader_fluid_mg_coarse_weights.js

@@ -0,0 +1,45 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { chunk_fluid_mg_coarse_word } from "./chunk_fluid_mg_coarse_word.js";
+import { FLUID_MG_PASS_STRUCT } from "./FLUID_MG_PASS_STRUCT.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .addUniform('params', FLUID_MG_PASS_STRUCT)
+    .addStorageBuffer('fine_words', WebGPUArray.from(u32), false)
+    .addStorageBuffer('words', WebGPUArray.from(u32), true);
+
+/**
+ * A coarse level's weight words from the level above's, one invocation a coarse cell
+ * (`chunk_fluid_mg_coarse_word`). `size` is the coarse level; the level above is twice it on every axis.
+ * Run once a solve per coarse level, finest first.
+ *
+ * Dispatched as `ceil(size / (8, 8, 4))` workgroups.
+ */
+export const shader_fluid_mg_coarse_weights = ComputeShader.from({
+    label: 'Fluid / pressure / coarse weights',
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+fn fluid_mg_read_child_word(cell: vec3<i32>) -> u32 {
+    let c = vec3<u32>(cell);
+    let fine = params.size * 2u;
+
+    return fine_words[c.x + fine.x * (c.y + fine.y * c.z)];
+}
+
+@compute @workgroup_size(8, 8, 4)
+fn main(@builtin(global_invocation_id) cell: vec3<u32>) {
+    if (any(cell >= params.size)) {
+        return;
+    }
+
+    words[cell.x + params.size.x * (cell.y + params.size.y * cell.z)] = fluid_mg_coarse_word(vec3<i32>(cell));
+}
+`, [chunk_fluid_mg_coarse_word]),
+});

package/src/shade/renderer/fluid/pressure/shader_fluid_mg_coarsest.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The pressure V-cycle's coarsest level (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §8): one workgroup
+ * holding the whole level, at most 256 cells, one invocation a cell, in workgroup memory.
+ *
+ * It loads `values` (non-finite as 0), runs {@link FLUID_MG_COARSEST_SWEEPS} red-black Gauss–Seidel
+ * sweeps with a barrier after each colour (`chunk_fluid_mg_relax`, ω = 1), and writes the level back in
+ * place. Below the finest level `values` is the level's error, zeroed by the restriction, and a cell
+ * beyond the level is 0; a solve whose finest level already fits is this pass alone, on the pressure,
+ * with the cascade's Dirichlet ghosts (`chunk_fluid_pressure_ghost`, from the step's `ghost_pressure`).
+ *
+ * Non-finite values and RHS are counted into `nonfinite[0]`, as the smoother does.
+ *
+ * Dispatched as one workgroup. Workgroup memory: 1,024 bytes.
+ */
+export const shader_fluid_mg_coarsest: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_fluid_mg_coarsest.d.ts.map

package/src/shade/renderer/fluid/pressure/shader_fluid_mg_coarsest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_fluid_mg_coarsest.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/pressure/shader_fluid_mg_coarsest.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;GAaG;AACH,qDAuFG;8BA5H2B,+BAA+B"}

package/src/shade/renderer/fluid/pressure/shader_fluid_mg_coarsest.js

@@ -0,0 +1,126 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { chunk_grid_tile_window } from "../../shader/chunk/grid/chunk_grid_tile_window.js";
+import { chunk_index_to_grid3d } from "../../shader/chunk/grid/chunk_index_to_grid3d.js";
+import { chunk_is_finite } from "../../shader/chunk/math/chunk_is_finite.js";
+import { chunk_subgroup_atomic_add } from "../../shader/chunk/subgroup/chunk_subgroup_atomic_add.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { atomic_u32, f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { chunk_fluid_mg_relax } from "./chunk_fluid_mg_relax.js";
+import { chunk_fluid_pressure_ghost } from "./chunk_fluid_pressure_ghost.js";
+import { FLUID_MG_COARSEST_CELL_LIMIT, FLUID_MG_COARSEST_SWEEPS } from "./FLUID_MG.js";
+import { FLUID_MG_PASS_STRUCT } from "./FLUID_MG_PASS_STRUCT.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .addUniform('params', FLUID_MG_PASS_STRUCT)
+    .addStorageBuffer('values', WebGPUArray.from(f32), true)
+    .addStorageBuffer('rhs', WebGPUArray.from(f32), false)
+    .addStorageBuffer('words', WebGPUArray.from(u32), false)
+    .addStorageBuffer('nonfinite', WebGPUArray.from(atomic_u32), true)
+    .addStorageBuffer('ghost_pressure', WebGPUArray.from(f32), false);
+
+/**
+ * The pressure V-cycle's coarsest level (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §8): one workgroup
+ * holding the whole level, at most 256 cells, one invocation a cell, in workgroup memory.
+ *
+ * It loads `values` (non-finite as 0), runs {@link FLUID_MG_COARSEST_SWEEPS} red-black Gauss–Seidel
+ * sweeps with a barrier after each colour (`chunk_fluid_mg_relax`, ω = 1), and writes the level back in
+ * place. Below the finest level `values` is the level's error, zeroed by the restriction, and a cell
+ * beyond the level is 0; a solve whose finest level already fits is this pass alone, on the pressure,
+ * with the cascade's Dirichlet ghosts (`chunk_fluid_pressure_ghost`, from the step's `ghost_pressure`).
+ *
+ * Non-finite values and RHS are counted into `nonfinite[0]`, as the smoother does.
+ *
+ * Dispatched as one workgroup. Workgroup memory: 1,024 bytes.
+ */
+export const shader_fluid_mg_coarsest = ComputeShader.from({
+    label: 'Fluid / pressure / coarsest',
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+const FLUID_MG_COARSEST_CELL_LIMIT = ${FLUID_MG_COARSEST_CELL_LIMIT}u;
+const FLUID_MG_COARSEST_SWEEPS = ${FLUID_MG_COARSEST_SWEEPS}u;
+
+var<workgroup> level_values: array<f32, FLUID_MG_COARSEST_CELL_LIMIT>;
+
+
+// where the finest level's window is, for its pressure ghosts
+fn fluid_pressure_ghost_corner() -> vec3<i32> {
+    return params.corner;
+}
+
+fn fluid_pressure_ghost_size() -> vec3<u32> {
+    return params.size;
+}
+fn tile_read_p(local: vec3<i32>) -> f32 {
+    if (any(local < vec3<i32>(0)) || any(local >= vec3<i32>(params.size))) {
+        if (params.level == 0u) {
+            return fluid_pressure_ghost(params.corner + local);
+        }
+
+        return 0.0;
+    }
+
+    let c = vec3<u32>(local);
+
+    return level_values[c.x + params.size.x * (c.y + params.size.y * c.z)];
+}
+
+@compute @workgroup_size(${FLUID_MG_COARSEST_CELL_LIMIT})
+fn main(@builtin(local_invocation_index) lane: u32) {
+    let inside = lane < params.size.x * params.size.y * params.size.z;
+    let cell = index_to_grid3d(lane, params.size.xy);
+
+    var storage_index = 0u;
+    var word = 0u;
+    var f = 0.0;
+    var zeroed = 0u;
+
+    if (inside) {
+        let storage = grid_tile_window_storage(vec3<i32>(cell), params.input_corner_storage, params.input_period);
+        let held = values[storage.x + params.input_period.x * (storage.y + params.input_period.y * storage.z)];
+        let rhs_value = rhs[lane];
+
+        storage_index = storage.x + params.input_period.x * (storage.y + params.input_period.y * storage.z);
+        word = words[lane];
+        f = select(0.0, rhs_value, is_finite(rhs_value));
+        level_values[lane] = select(0.0, held, is_finite(held));
+        zeroed = select(0u, 1u, !is_finite(held)) + select(0u, 1u, !is_finite(rhs_value));
+    }
+
+    subgroup_atomic_add_u32(&nonfinite[0], zeroed);
+
+    workgroupBarrier();
+
+    let local = vec3<i32>(cell);
+    let parity = (cell.x + cell.y + cell.z) & 1u;
+
+    for (var sweep = 0u; sweep < FLUID_MG_COARSEST_SWEEPS; sweep++) {
+        for (var colour = 0u; colour < 2u; colour++) {
+            if (inside && word != 0u && parity == colour) {
+                let stencil = fluid_mg_stencil(local, cell, params.size, word, params.edge_weight);
+
+                level_values[lane] = fluid_mg_relax(level_values[lane], stencil, f, params.h2, 1.0);
+            }
+
+            workgroupBarrier();
+        }
+    }
+
+    if (inside) {
+        values[storage_index] = level_values[lane];
+    }
+}
+`, [
+            chunk_grid_tile_window,
+            chunk_index_to_grid3d,
+            chunk_fluid_mg_relax,
+            chunk_fluid_pressure_ghost,
+            chunk_is_finite,
+            chunk_subgroup_atomic_add,
+        ]),
+});

package/src/shade/renderer/fluid/pressure/shader_fluid_mg_level0_weights.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The finest level's weight words from the step's solid flags (bit 0 of each, window-local and
+ * linear), one invocation a cell (`chunk_fluid_mg_level0_word`). Run once a solve, before anything reads
+ * the words.
+ *
+ * Dispatched as `ceil(size / (8, 8, 4))` workgroups.
+ */
+export const shader_fluid_mg_level0_weights: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_fluid_mg_level0_weights.d.ts.map

package/src/shade/renderer/fluid/pressure/shader_fluid_mg_level0_weights.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_fluid_mg_level0_weights.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/pressure/shader_fluid_mg_level0_weights.js"],"names":[],"mappings":"AAeA;;;;;;GAMG;AACH,2DAqBG;8BA1C2B,+BAA+B"}