@woosh/meep-engine 3.69.0 → 3.70.0

package/src/shade/renderer/fluid/coupling/chunk_fluid_cascade_parent.js

@@ -1,335 +1,371 @@
-import { chunk_grid3d_to_index } from "../../shader/chunk/grid/chunk_grid3d_to_index.js";
-import { chunk_grid_tile_window } from "../../shader/chunk/grid/chunk_grid_tile_window.js";
-import { chunk_is_finite } from "../../shader/chunk/math/chunk_is_finite.js";
-import { chunk_texture3d_trilinear_interpolate } from "../../shader/chunk/texture/sample/chunk_texture3d_trilinear_corners.js";
-import { TEXTURE3D_TRILINEAR_CORNERS_STRUCT } from "../../shader/chunk/texture/TEXTURE3D_TRILINEAR_CORNERS_STRUCT.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-
-/*
- What a cascade reads of its parent (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §7, §9), through the
- uniform `parent` (FLUID_CASCADE_PARENT_STRUCT), which every shader including one of these chunks
- declares under that name.
-
- A child addresses its parent by `offset = step.cells.corner − parent.origin` (or its pass's own copy
- of the child's corner): child-lattice cells from the parent's window start to the child's, a
- multiple of 4. With it, child window-local lattice points become parent window-local coordinates
- by halving, so nothing here sees a world coordinate.
-
- Both reads are trilinear with weights of 0, ¼, ½ or ¾, which f32 holds exactly. The velocity read
- blends the parent's DEVIATIONS from the far field and adds the far field after, so air the far field
- alone moves (a deviation of exactly 0 at every corner) reads as the far field exactly.
-*/
-
-/**
- * The parent's identity read at a face of the child, one concrete function per component:
- * `fluid_parent_face_u(face, offset)`, `_v`, `_w`, `face` a window-local face of the child's lattice
- * for that component (u face `(i, j, k)` at cell coordinate `(i − ½, j, k)`).
- *
- * Child u face `i` lies on parent u lattice coordinate `(i + offset)/2` along x and
- * `(j + offset − ½)/2` across it; likewise v along y and w along z. The tap's eight parent faces are
- * read as deviations, `v − parent.far_velocity`, and one beyond the parent's window as 0; the read is
- * `parent.read_far_velocity + parent.keep · trilinear(deviations)`.
- *
- * Binds `parent_u`, `parent_v`, `parent_w`: the parent's persistent faces, `texture_3d<f32>`
- * (`r32float`), toroidal through `parent.faces_*`. A far-field parent binds stand-ins it never reads.
- *
- * Reads 8 texels a call; beside the far field (a window of size 0) none, and it answers
- * `parent.read_far_velocity` before any window test. That early answer is measured: a lone 64×32×64
- * cascade's predict went from 56.3 to 27.6 µs and its correct from 84.0 to 44.0 on an RTX 4090
- * (pipelines swapped in one run, per-dispatch medians), the seams' empty-window tests and blend being
- * most of what a beyond-window read cost there.
- *
- * @type {CodeChunk}
- */
-export const chunk_fluid_cascade_parent_velocity = CodeChunk.from(
-    //language=WGSL
-    `
-fn fluid_parent_deviation_u(lattice: vec3<i32>) -> f32 {
-    if (!grid_tile_window_contains(lattice, parent.faces_u.size)) {
-        return 0.0;
-    }
-
-    let storage = grid_tile_window_storage(lattice, parent.faces_u.corner_storage, parent.faces_u.period);
-
-    return textureLoad(parent_u, storage, 0).r - parent.far_velocity.x;
-}
-
-fn fluid_parent_deviation_v(lattice: vec3<i32>) -> f32 {
-    if (!grid_tile_window_contains(lattice, parent.faces_v.size)) {
-        return 0.0;
-    }
-
-    let storage = grid_tile_window_storage(lattice, parent.faces_v.corner_storage, parent.faces_v.period);
-
-    return textureLoad(parent_v, storage, 0).r - parent.far_velocity.y;
-}
-
-fn fluid_parent_deviation_w(lattice: vec3<i32>) -> f32 {
-    if (!grid_tile_window_contains(lattice, parent.faces_w.size)) {
-        return 0.0;
-    }
-
-    let storage = grid_tile_window_storage(lattice, parent.faces_w.corner_storage, parent.faces_w.period);
-
-    return textureLoad(parent_w, storage, 0).r - parent.far_velocity.z;
-}
-
-fn fluid_parent_face_u(face: vec3<i32>, offset: vec3<i32>) -> f32 {
-    // the far field: nothing to read, every corner would count 0
-    if (parent.faces_u.size.x == 0u) {
-        return parent.read_far_velocity.x;
-    }
-
-    let lattice = (vec3<f32>(face + offset) - vec3<f32>(0.0, 0.5, 0.5)) * 0.5;
-    let base = floor(lattice);
-    let lo = vec3<i32>(base);
-    let hi = lo + vec3<i32>(1);
-
-    var z0: vec4<f32>;
-    var z1: vec4<f32>;
-
-    if (all(lo >= vec3<i32>(0)) && all(vec3<u32>(hi) < parent.faces_u.size)) {
-        let s0 = grid_tile_window_storage(lo, parent.faces_u.corner_storage, parent.faces_u.period);
-        let s1_raw = s0 + vec3<u32>(1u);
-        let s1 = select(s1_raw, vec3<u32>(0u), s1_raw == parent.faces_u.period);
-        let far = vec4<f32>(parent.far_velocity.x);
-
-        z0 = vec4<f32>(
-            textureLoad(parent_u, s0, 0).r,
-            textureLoad(parent_u, vec3<u32>(s1.x, s0.y, s0.z), 0).r,
-            textureLoad(parent_u, vec3<u32>(s0.x, s1.y, s0.z), 0).r,
-            textureLoad(parent_u, vec3<u32>(s1.x, s1.y, s0.z), 0).r
-        ) - far;
-        z1 = vec4<f32>(
-            textureLoad(parent_u, vec3<u32>(s0.x, s0.y, s1.z), 0).r,
-            textureLoad(parent_u, vec3<u32>(s1.x, s0.y, s1.z), 0).r,
-            textureLoad(parent_u, vec3<u32>(s0.x, s1.y, s1.z), 0).r,
-            textureLoad(parent_u, s1, 0).r
-        ) - far;
-    } else {
-        z0 = vec4<f32>(
-            fluid_parent_deviation_u(lo),
-            fluid_parent_deviation_u(vec3<i32>(hi.x, lo.y, lo.z)),
-            fluid_parent_deviation_u(vec3<i32>(lo.x, hi.y, lo.z)),
-            fluid_parent_deviation_u(vec3<i32>(hi.x, hi.y, lo.z))
-        );
-        z1 = vec4<f32>(
-            fluid_parent_deviation_u(vec3<i32>(lo.x, lo.y, hi.z)),
-            fluid_parent_deviation_u(vec3<i32>(hi.x, lo.y, hi.z)),
-            fluid_parent_deviation_u(vec3<i32>(lo.x, hi.y, hi.z)),
-            fluid_parent_deviation_u(hi)
-        );
-    }
-
-    let corners = ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(z0, z1, lattice - base);
-
-    return parent.read_far_velocity.x + parent.keep * texture3d_trilinear_interpolate(corners);
-}
-
-fn fluid_parent_face_v(face: vec3<i32>, offset: vec3<i32>) -> f32 {
-    // the far field: nothing to read, every corner would count 0
-    if (parent.faces_v.size.x == 0u) {
-        return parent.read_far_velocity.y;
-    }
-
-    let lattice = (vec3<f32>(face + offset) - vec3<f32>(0.5, 0.0, 0.5)) * 0.5;
-    let base = floor(lattice);
-    let lo = vec3<i32>(base);
-    let hi = lo + vec3<i32>(1);
-
-    var z0: vec4<f32>;
-    var z1: vec4<f32>;
-
-    if (all(lo >= vec3<i32>(0)) && all(vec3<u32>(hi) < parent.faces_v.size)) {
-        let s0 = grid_tile_window_storage(lo, parent.faces_v.corner_storage, parent.faces_v.period);
-        let s1_raw = s0 + vec3<u32>(1u);
-        let s1 = select(s1_raw, vec3<u32>(0u), s1_raw == parent.faces_v.period);
-        let far = vec4<f32>(parent.far_velocity.y);
-
-        z0 = vec4<f32>(
-            textureLoad(parent_v, s0, 0).r,
-            textureLoad(parent_v, vec3<u32>(s1.x, s0.y, s0.z), 0).r,
-            textureLoad(parent_v, vec3<u32>(s0.x, s1.y, s0.z), 0).r,
-            textureLoad(parent_v, vec3<u32>(s1.x, s1.y, s0.z), 0).r
-        ) - far;
-        z1 = vec4<f32>(
-            textureLoad(parent_v, vec3<u32>(s0.x, s0.y, s1.z), 0).r,
-            textureLoad(parent_v, vec3<u32>(s1.x, s0.y, s1.z), 0).r,
-            textureLoad(parent_v, vec3<u32>(s0.x, s1.y, s1.z), 0).r,
-            textureLoad(parent_v, s1, 0).r
-        ) - far;
-    } else {
-        z0 = vec4<f32>(
-            fluid_parent_deviation_v(lo),
-            fluid_parent_deviation_v(vec3<i32>(hi.x, lo.y, lo.z)),
-            fluid_parent_deviation_v(vec3<i32>(lo.x, hi.y, lo.z)),
-            fluid_parent_deviation_v(vec3<i32>(hi.x, hi.y, lo.z))
-        );
-        z1 = vec4<f32>(
-            fluid_parent_deviation_v(vec3<i32>(lo.x, lo.y, hi.z)),
-            fluid_parent_deviation_v(vec3<i32>(hi.x, lo.y, hi.z)),
-            fluid_parent_deviation_v(vec3<i32>(lo.x, hi.y, hi.z)),
-            fluid_parent_deviation_v(hi)
-        );
-    }
-
-    let corners = ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(z0, z1, lattice - base);
-
-    return parent.read_far_velocity.y + parent.keep * texture3d_trilinear_interpolate(corners);
-}
-
-fn fluid_parent_face_w(face: vec3<i32>, offset: vec3<i32>) -> f32 {
-    // the far field: nothing to read, every corner would count 0
-    if (parent.faces_w.size.x == 0u) {
-        return parent.read_far_velocity.z;
-    }
-
-    let lattice = (vec3<f32>(face + offset) - vec3<f32>(0.5, 0.5, 0.0)) * 0.5;
-    let base = floor(lattice);
-    let lo = vec3<i32>(base);
-    let hi = lo + vec3<i32>(1);
-
-    var z0: vec4<f32>;
-    var z1: vec4<f32>;
-
-    if (all(lo >= vec3<i32>(0)) && all(vec3<u32>(hi) < parent.faces_w.size)) {
-        let s0 = grid_tile_window_storage(lo, parent.faces_w.corner_storage, parent.faces_w.period);
-        let s1_raw = s0 + vec3<u32>(1u);
-        let s1 = select(s1_raw, vec3<u32>(0u), s1_raw == parent.faces_w.period);
-        let far = vec4<f32>(parent.far_velocity.z);
-
-        z0 = vec4<f32>(
-            textureLoad(parent_w, s0, 0).r,
-            textureLoad(parent_w, vec3<u32>(s1.x, s0.y, s0.z), 0).r,
-            textureLoad(parent_w, vec3<u32>(s0.x, s1.y, s0.z), 0).r,
-            textureLoad(parent_w, vec3<u32>(s1.x, s1.y, s0.z), 0).r
-        ) - far;
-        z1 = vec4<f32>(
-            textureLoad(parent_w, vec3<u32>(s0.x, s0.y, s1.z), 0).r,
-            textureLoad(parent_w, vec3<u32>(s1.x, s0.y, s1.z), 0).r,
-            textureLoad(parent_w, vec3<u32>(s0.x, s1.y, s1.z), 0).r,
-            textureLoad(parent_w, s1, 0).r
-        ) - far;
-    } else {
-        z0 = vec4<f32>(
-            fluid_parent_deviation_w(lo),
-            fluid_parent_deviation_w(vec3<i32>(hi.x, lo.y, lo.z)),
-            fluid_parent_deviation_w(vec3<i32>(lo.x, hi.y, lo.z)),
-            fluid_parent_deviation_w(vec3<i32>(hi.x, hi.y, lo.z))
-        );
-        z1 = vec4<f32>(
-            fluid_parent_deviation_w(vec3<i32>(lo.x, lo.y, hi.z)),
-            fluid_parent_deviation_w(vec3<i32>(hi.x, lo.y, hi.z)),
-            fluid_parent_deviation_w(vec3<i32>(lo.x, hi.y, hi.z)),
-            fluid_parent_deviation_w(hi)
-        );
-    }
-
-    let corners = ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(z0, z1, lattice - base);
-
-    return parent.read_far_velocity.z + parent.keep * texture3d_trilinear_interpolate(corners);
-}
-`, [
-        TEXTURE3D_TRILINEAR_CORNERS_STRUCT.declaration_chunk,
-        chunk_texture3d_trilinear_interpolate,
-        chunk_grid_tile_window,
-    ]
-);
-
-/**
- * `fluid_parent_pressure(q)`: the parent's kinematic pressure (m²/s², the child's units) at the
- * centre of child-lattice cell `q`, counted from `parent.origin`: the Dirichlet value of a ghost cell
- * beyond the child's window (§9).
- *
- * The centre of child cell `q` is parent cell coordinate `(q − ½)/2` (parent cell `P` centred at `P`),
- * a quarter of a parent cell off a parent centre on every axis, so the read is trilinear over eight
- * parent cells at weights ¾ and ¼. A parent cell beyond the parent's window reads 0, as does a value
- * that is not finite.
- *
- * Binds `parent_pressure`: the parent's pressure, `array<f32>`, toroidal through `parent.cells`.
- *
- * Reads 8 elements a call; beside the far field, none.
- *
- * @type {CodeChunk}
- */
-export const chunk_fluid_cascade_parent_pressure = CodeChunk.from(
-    //language=WGSL
-    `
-fn fluid_parent_pressure_sanitize(value: f32) -> f32 {
-    return select(0.0, value, is_finite(value));
-}
-
-fn fluid_parent_pressure_cell(cell: vec3<i32>) -> f32 {
-    if (!grid_tile_window_contains(cell, parent.cells.size)) {
-        return 0.0;
-    }
-
-    let storage = grid_tile_window_storage(cell, parent.cells.corner_storage, parent.cells.period);
-    let value = parent_pressure[grid3d_to_index(storage, parent.cells.period.xy)];
-
-    return fluid_parent_pressure_sanitize(value);
-}
-
-fn fluid_parent_pressure(q: vec3<i32>) -> f32 {
-    if (parent.cells.size.x == 0u) {
-        return 0.0;
-    }
-
-    let position = (vec3<f32>(q) - vec3<f32>(0.5)) * 0.5;
-    let base = floor(position);
-    let lo = vec3<i32>(base);
-    let hi = lo + vec3<i32>(1);
-
-    var z0: vec4<f32>;
-    var z1: vec4<f32>;
-
-    if (all(lo >= vec3<i32>(0)) && all(vec3<u32>(hi) < parent.cells.size)) {
-        let s0 = grid_tile_window_storage(lo, parent.cells.corner_storage, parent.cells.period);
-        let s1_raw = s0 + vec3<u32>(1u);
-        let s1 = select(s1_raw, vec3<u32>(0u), s1_raw == parent.cells.period);
-        let px = parent.cells.period.x;
-        let py = parent.cells.period.y;
-        let row00 = px * (s0.y + py * s0.z);
-        let row10 = px * (s1.y + py * s0.z);
-        let row01 = px * (s0.y + py * s1.z);
-        let row11 = px * (s1.y + py * s1.z);
-
-        z0 = vec4<f32>(
-            fluid_parent_pressure_sanitize(parent_pressure[s0.x + row00]),
-            fluid_parent_pressure_sanitize(parent_pressure[s1.x + row00]),
-            fluid_parent_pressure_sanitize(parent_pressure[s0.x + row10]),
-            fluid_parent_pressure_sanitize(parent_pressure[s1.x + row10])
-        );
-        z1 = vec4<f32>(
-            fluid_parent_pressure_sanitize(parent_pressure[s0.x + row01]),
-            fluid_parent_pressure_sanitize(parent_pressure[s1.x + row01]),
-            fluid_parent_pressure_sanitize(parent_pressure[s0.x + row11]),
-            fluid_parent_pressure_sanitize(parent_pressure[s1.x + row11])
-        );
-    } else {
-        z0 = vec4<f32>(
-            fluid_parent_pressure_cell(lo),
-            fluid_parent_pressure_cell(vec3<i32>(hi.x, lo.y, lo.z)),
-            fluid_parent_pressure_cell(vec3<i32>(lo.x, hi.y, lo.z)),
-            fluid_parent_pressure_cell(vec3<i32>(hi.x, hi.y, lo.z))
-        );
-        z1 = vec4<f32>(
-            fluid_parent_pressure_cell(vec3<i32>(lo.x, lo.y, hi.z)),
-            fluid_parent_pressure_cell(vec3<i32>(hi.x, lo.y, hi.z)),
-            fluid_parent_pressure_cell(vec3<i32>(lo.x, hi.y, hi.z)),
-            fluid_parent_pressure_cell(hi)
-        );
-    }
-
-    let corners = ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(z0, z1, position - base);
-
-    return texture3d_trilinear_interpolate(corners);
-}
-`, [
-        TEXTURE3D_TRILINEAR_CORNERS_STRUCT.declaration_chunk,
-        chunk_texture3d_trilinear_interpolate,
-        chunk_grid_tile_window,
-        chunk_grid3d_to_index,
-        chunk_is_finite,
-    ]
-);
+import { chunk_grid3d_to_index } from "../../shader/chunk/grid/chunk_grid3d_to_index.js";
+import { chunk_grid_tile_window } from "../../shader/chunk/grid/chunk_grid_tile_window.js";
+import { chunk_is_finite } from "../../shader/chunk/math/chunk_is_finite.js";
+import { chunk_texture3d_trilinear_interpolate } from "../../shader/chunk/texture/sample/chunk_texture3d_trilinear_corners.js";
+import { TEXTURE3D_TRILINEAR_CORNERS_STRUCT } from "../../shader/chunk/texture/TEXTURE3D_TRILINEAR_CORNERS_STRUCT.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_fluid_far_field } from "../chunk_fluid_far_field.js";
+
+/*
+ What a cascade reads of its parent (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §7, §9), through the
+ uniform `parent` (FLUID_CASCADE_PARENT_STRUCT), which every shader including one of these chunks
+ declares under that name.
+
+ A child addresses its parent by `offset = step.cells.corner − parent.origin` (or its pass's own copy
+ of the child's corner): child-lattice cells from the parent's window start to the child's, a
+ multiple of 4. With it, child window-local lattice points become parent window-local coordinates
+ by halving, so nothing here sees a world coordinate.
+
+ Both reads are trilinear with weights of 0, ¼, ½ or ¾, which f32 holds exactly. The velocity read
+ blends the parent's DEVIATIONS from its far field and adds the far field at the read's instant after,
+ so air the far field alone moves reads as the far field: exactly with no turbulence, and to the
+ turbulence's curvature over a parent cell with it.
+*/
+
+/**
+ * The parent's identity read at a face of the child, one concrete function per component:
+ * `fluid_parent_face_u(face, offset)`, `_v`, `_w`, `face` a window-local face of the child's lattice
+ * for that component (u face `(i, j, k)` at cell coordinate `(i − ½, j, k)`), and the deviation it adds
+ * to the far field, `fluid_parent_face_deviation_u(face, offset)`, `_v`, `_w`.
+ *
+ * Child u face `i` lies on parent u lattice coordinate `(i + offset)/2` along x and
+ * `(j + offset − ½)/2` across it; likewise v along y and w along z. In child-lattice cells counted
+ * from `parent.origin` the face is at `face + offset − (½, 0, 0)`, which is where both far fields,
+ * `parent.far` and `parent.read`, are laid.
+ *
+ * The deviation: the tap's eight parent faces are read less the parent's far field's mean,
+ * `v − parent.far.mean`, and one beyond the parent's window as the parent's far field's eddy at the
+ * face, `σ·T`; the trilinear of those, less that eddy, is the parent's deviation from its far field at
+ * the face, which the read keeps `parent.keep` of. A smooth far field differs from its trilinear over
+ * the parent's corners by a fraction of its curvature over a parent cell, which a tile of
+ * `FLUID_TURBULENCE_TEXELS_PER_LENGTH` texels a length scale keeps small; with no turbulence the
+ * eddy is 0 and the deviation is exact.
+ *
+ * The read: `v_far(t_read)` at the face, `parent.read`, plus the deviation.
+ *
+ * Binds `parent_u`, `parent_v`, `parent_w`: the parent's persistent faces, `texture_3d<f32>`
+ * (`r32float`), toroidal through `parent.faces_*`; and the turbulence tile
+ * (`fluid_turbulence_add_resources`). A far-field parent binds stand-ins it never reads.
+ *
+ * Reads 8 texels a call, and the tile once for each far field that has turbulence; beside the far
+ * field (a window of size 0) no texel, and the deviation answers 0 before any window test. That early
+ * answer is measured: a lone 64×32×64 cascade's predict went from 56.3 to 27.6 µs and its correct from
+ * 84.0 to 44.0 on an RTX 4090 (pipelines swapped in one run, per-dispatch medians), the seams'
+ * empty-window tests and blend being most of what a beyond-window read cost there.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_fluid_cascade_parent_velocity = CodeChunk.from(
+    //language=WGSL
+    `
+fn fluid_parent_deviation_u(lattice: vec3<i32>, outside: f32) -> f32 {
+    if (!grid_tile_window_contains(lattice, parent.faces_u.size)) {
+        return outside;
+    }
+
+    let storage = grid_tile_window_storage(lattice, parent.faces_u.corner_storage, parent.faces_u.period);
+
+    return textureLoad(parent_u, storage, 0).r - parent.far.mean.x;
+}
+
+fn fluid_parent_deviation_v(lattice: vec3<i32>, outside: f32) -> f32 {
+    if (!grid_tile_window_contains(lattice, parent.faces_v.size)) {
+        return outside;
+    }
+
+    let storage = grid_tile_window_storage(lattice, parent.faces_v.corner_storage, parent.faces_v.period);
+
+    return textureLoad(parent_v, storage, 0).r - parent.far.mean.y;
+}
+
+fn fluid_parent_deviation_w(lattice: vec3<i32>, outside: f32) -> f32 {
+    if (!grid_tile_window_contains(lattice, parent.faces_w.size)) {
+        return outside;
+    }
+
+    let storage = grid_tile_window_storage(lattice, parent.faces_w.corner_storage, parent.faces_w.period);
+
+    return textureLoad(parent_w, storage, 0).r - parent.far.mean.z;
+}
+
+fn fluid_parent_face_deviation_u(face: vec3<i32>, offset: vec3<i32>) -> f32 {
+    // the far field: nothing to read, every corner would count 0
+    if (parent.faces_u.size.x == 0u) {
+        return 0.0;
+    }
+
+    // the parent's own far field's eddy at the face, which a corner beyond its window takes
+    let eddy = parent.far.sigma * fluid_far_unit(parent.far, vec3<f32>(face + offset) - vec3<f32>(0.5, 0.0, 0.0)).x;
+
+    let lattice = (vec3<f32>(face + offset) - vec3<f32>(0.0, 0.5, 0.5)) * 0.5;
+    let base = floor(lattice);
+    let lo = vec3<i32>(base);
+    let hi = lo + vec3<i32>(1);
+
+    var z0: vec4<f32>;
+    var z1: vec4<f32>;
+
+    if (all(lo >= vec3<i32>(0)) && all(vec3<u32>(hi) < parent.faces_u.size)) {
+        let s0 = grid_tile_window_storage(lo, parent.faces_u.corner_storage, parent.faces_u.period);
+        let s1_raw = s0 + vec3<u32>(1u);
+        let s1 = select(s1_raw, vec3<u32>(0u), s1_raw == parent.faces_u.period);
+        let mean = vec4<f32>(parent.far.mean.x);
+
+        z0 = vec4<f32>(
+            textureLoad(parent_u, s0, 0).r,
+            textureLoad(parent_u, vec3<u32>(s1.x, s0.y, s0.z), 0).r,
+            textureLoad(parent_u, vec3<u32>(s0.x, s1.y, s0.z), 0).r,
+            textureLoad(parent_u, vec3<u32>(s1.x, s1.y, s0.z), 0).r
+        ) - mean;
+        z1 = vec4<f32>(
+            textureLoad(parent_u, vec3<u32>(s0.x, s0.y, s1.z), 0).r,
+            textureLoad(parent_u, vec3<u32>(s1.x, s0.y, s1.z), 0).r,
+            textureLoad(parent_u, vec3<u32>(s0.x, s1.y, s1.z), 0).r,
+            textureLoad(parent_u, s1, 0).r
+        ) - mean;
+    } else {
+        z0 = vec4<f32>(
+            fluid_parent_deviation_u(lo, eddy),
+            fluid_parent_deviation_u(vec3<i32>(hi.x, lo.y, lo.z), eddy),
+            fluid_parent_deviation_u(vec3<i32>(lo.x, hi.y, lo.z), eddy),
+            fluid_parent_deviation_u(vec3<i32>(hi.x, hi.y, lo.z), eddy)
+        );
+        z1 = vec4<f32>(
+            fluid_parent_deviation_u(vec3<i32>(lo.x, lo.y, hi.z), eddy),
+            fluid_parent_deviation_u(vec3<i32>(hi.x, lo.y, hi.z), eddy),
+            fluid_parent_deviation_u(vec3<i32>(lo.x, hi.y, hi.z), eddy),
+            fluid_parent_deviation_u(hi, eddy)
+        );
+    }
+
+    let corners = ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(z0, z1, lattice - base);
+
+    return parent.keep * (texture3d_trilinear_interpolate(corners) - eddy);
+}
+
+fn fluid_parent_face_u(face: vec3<i32>, offset: vec3<i32>) -> f32 {
+    return fluid_far_field(parent.read, vec3<f32>(face + offset) - vec3<f32>(0.5, 0.0, 0.0)).x + fluid_parent_face_deviation_u(face, offset);
+}
+
+fn fluid_parent_face_deviation_v(face: vec3<i32>, offset: vec3<i32>) -> f32 {
+    // the far field: nothing to read, every corner would count 0
+    if (parent.faces_v.size.x == 0u) {
+        return 0.0;
+    }
+
+    // the parent's own far field's eddy at the face, which a corner beyond its window takes
+    let eddy = parent.far.sigma * fluid_far_unit(parent.far, vec3<f32>(face + offset) - vec3<f32>(0.0, 0.5, 0.0)).y;
+
+    let lattice = (vec3<f32>(face + offset) - vec3<f32>(0.5, 0.0, 0.5)) * 0.5;
+    let base = floor(lattice);
+    let lo = vec3<i32>(base);
+    let hi = lo + vec3<i32>(1);
+
+    var z0: vec4<f32>;
+    var z1: vec4<f32>;
+
+    if (all(lo >= vec3<i32>(0)) && all(vec3<u32>(hi) < parent.faces_v.size)) {
+        let s0 = grid_tile_window_storage(lo, parent.faces_v.corner_storage, parent.faces_v.period);
+        let s1_raw = s0 + vec3<u32>(1u);
+        let s1 = select(s1_raw, vec3<u32>(0u), s1_raw == parent.faces_v.period);
+        let mean = vec4<f32>(parent.far.mean.y);
+
+        z0 = vec4<f32>(
+            textureLoad(parent_v, s0, 0).r,
+            textureLoad(parent_v, vec3<u32>(s1.x, s0.y, s0.z), 0).r,
+            textureLoad(parent_v, vec3<u32>(s0.x, s1.y, s0.z), 0).r,
+            textureLoad(parent_v, vec3<u32>(s1.x, s1.y, s0.z), 0).r
+        ) - mean;
+        z1 = vec4<f32>(
+            textureLoad(parent_v, vec3<u32>(s0.x, s0.y, s1.z), 0).r,
+            textureLoad(parent_v, vec3<u32>(s1.x, s0.y, s1.z), 0).r,
+            textureLoad(parent_v, vec3<u32>(s0.x, s1.y, s1.z), 0).r,
+            textureLoad(parent_v, s1, 0).r
+        ) - mean;
+    } else {
+        z0 = vec4<f32>(
+            fluid_parent_deviation_v(lo, eddy),
+            fluid_parent_deviation_v(vec3<i32>(hi.x, lo.y, lo.z), eddy),
+            fluid_parent_deviation_v(vec3<i32>(lo.x, hi.y, lo.z), eddy),
+            fluid_parent_deviation_v(vec3<i32>(hi.x, hi.y, lo.z), eddy)
+        );
+        z1 = vec4<f32>(
+            fluid_parent_deviation_v(vec3<i32>(lo.x, lo.y, hi.z), eddy),
+            fluid_parent_deviation_v(vec3<i32>(hi.x, lo.y, hi.z), eddy),
+            fluid_parent_deviation_v(vec3<i32>(lo.x, hi.y, hi.z), eddy),
+            fluid_parent_deviation_v(hi, eddy)
+        );
+    }
+
+    let corners = ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(z0, z1, lattice - base);
+
+    return parent.keep * (texture3d_trilinear_interpolate(corners) - eddy);
+}
+
+fn fluid_parent_face_v(face: vec3<i32>, offset: vec3<i32>) -> f32 {
+    return fluid_far_field(parent.read, vec3<f32>(face + offset) - vec3<f32>(0.0, 0.5, 0.0)).y + fluid_parent_face_deviation_v(face, offset);
+}
+
+fn fluid_parent_face_deviation_w(face: vec3<i32>, offset: vec3<i32>) -> f32 {
+    // the far field: nothing to read, every corner would count 0
+    if (parent.faces_w.size.x == 0u) {
+        return 0.0;
+    }
+
+    // the parent's own far field's eddy at the face, which a corner beyond its window takes
+    let eddy = parent.far.sigma * fluid_far_unit(parent.far, vec3<f32>(face + offset) - vec3<f32>(0.0, 0.0, 0.5)).z;
+
+    let lattice = (vec3<f32>(face + offset) - vec3<f32>(0.5, 0.5, 0.0)) * 0.5;
+    let base = floor(lattice);
+    let lo = vec3<i32>(base);
+    let hi = lo + vec3<i32>(1);
+
+    var z0: vec4<f32>;
+    var z1: vec4<f32>;
+
+    if (all(lo >= vec3<i32>(0)) && all(vec3<u32>(hi) < parent.faces_w.size)) {
+        let s0 = grid_tile_window_storage(lo, parent.faces_w.corner_storage, parent.faces_w.period);
+        let s1_raw = s0 + vec3<u32>(1u);
+        let s1 = select(s1_raw, vec3<u32>(0u), s1_raw == parent.faces_w.period);
+        let mean = vec4<f32>(parent.far.mean.z);
+
+        z0 = vec4<f32>(
+            textureLoad(parent_w, s0, 0).r,
+            textureLoad(parent_w, vec3<u32>(s1.x, s0.y, s0.z), 0).r,
+            textureLoad(parent_w, vec3<u32>(s0.x, s1.y, s0.z), 0).r,
+            textureLoad(parent_w, vec3<u32>(s1.x, s1.y, s0.z), 0).r
+        ) - mean;
+        z1 = vec4<f32>(
+            textureLoad(parent_w, vec3<u32>(s0.x, s0.y, s1.z), 0).r,
+            textureLoad(parent_w, vec3<u32>(s1.x, s0.y, s1.z), 0).r,
+            textureLoad(parent_w, vec3<u32>(s0.x, s1.y, s1.z), 0).r,
+            textureLoad(parent_w, s1, 0).r
+        ) - mean;
+    } else {
+        z0 = vec4<f32>(
+            fluid_parent_deviation_w(lo, eddy),
+            fluid_parent_deviation_w(vec3<i32>(hi.x, lo.y, lo.z), eddy),
+            fluid_parent_deviation_w(vec3<i32>(lo.x, hi.y, lo.z), eddy),
+            fluid_parent_deviation_w(vec3<i32>(hi.x, hi.y, lo.z), eddy)
+        );
+        z1 = vec4<f32>(
+            fluid_parent_deviation_w(vec3<i32>(lo.x, lo.y, hi.z), eddy),
+            fluid_parent_deviation_w(vec3<i32>(hi.x, lo.y, hi.z), eddy),
+            fluid_parent_deviation_w(vec3<i32>(lo.x, hi.y, hi.z), eddy),
+            fluid_parent_deviation_w(hi, eddy)
+        );
+    }
+
+    let corners = ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(z0, z1, lattice - base);
+
+    return parent.keep * (texture3d_trilinear_interpolate(corners) - eddy);
+}
+
+fn fluid_parent_face_w(face: vec3<i32>, offset: vec3<i32>) -> f32 {
+    return fluid_far_field(parent.read, vec3<f32>(face + offset) - vec3<f32>(0.0, 0.0, 0.5)).z + fluid_parent_face_deviation_w(face, offset);
+}
+`, [
+        TEXTURE3D_TRILINEAR_CORNERS_STRUCT.declaration_chunk,
+        chunk_texture3d_trilinear_interpolate,
+        chunk_grid_tile_window,
+        chunk_fluid_far_field,
+    ]
+);
+
+/**
+ * `fluid_parent_pressure(q)`: the parent's kinematic pressure (m²/s², the child's units) at the
+ * centre of child-lattice cell `q`, counted from `parent.origin`: the Dirichlet value of a ghost cell
+ * beyond the child's window (§9).
+ *
+ * The centre of child cell `q` is parent cell coordinate `(q − ½)/2` (parent cell `P` centred at `P`),
+ * a quarter of a parent cell off a parent centre on every axis, so the read is trilinear over eight
+ * parent cells at weights ¾ and ¼. A parent cell beyond the parent's window reads 0, as does a value
+ * that is not finite.
+ *
+ * Binds `parent_pressure`: the parent's pressure, `array<f32>`, toroidal through `parent.cells`.
+ *
+ * Reads 8 elements a call; beside the far field, none.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_fluid_cascade_parent_pressure = CodeChunk.from(
+    //language=WGSL
+    `
+fn fluid_parent_pressure_sanitize(value: f32) -> f32 {
+    return select(0.0, value, is_finite(value));
+}
+
+fn fluid_parent_pressure_cell(cell: vec3<i32>) -> f32 {
+    if (!grid_tile_window_contains(cell, parent.cells.size)) {
+        return 0.0;
+    }
+
+    let storage = grid_tile_window_storage(cell, parent.cells.corner_storage, parent.cells.period);
+    let value = parent_pressure[grid3d_to_index(storage, parent.cells.period.xy)];
+
+    return fluid_parent_pressure_sanitize(value);
+}
+
+fn fluid_parent_pressure(q: vec3<i32>) -> f32 {
+    if (parent.cells.size.x == 0u) {
+        return 0.0;
+    }
+
+    let position = (vec3<f32>(q) - vec3<f32>(0.5)) * 0.5;
+    let base = floor(position);
+    let lo = vec3<i32>(base);
+    let hi = lo + vec3<i32>(1);
+
+    var z0: vec4<f32>;
+    var z1: vec4<f32>;
+
+    if (all(lo >= vec3<i32>(0)) && all(vec3<u32>(hi) < parent.cells.size)) {
+        let s0 = grid_tile_window_storage(lo, parent.cells.corner_storage, parent.cells.period);
+        let s1_raw = s0 + vec3<u32>(1u);
+        let s1 = select(s1_raw, vec3<u32>(0u), s1_raw == parent.cells.period);
+        let px = parent.cells.period.x;
+        let py = parent.cells.period.y;
+        let row00 = px * (s0.y + py * s0.z);
+        let row10 = px * (s1.y + py * s0.z);
+        let row01 = px * (s0.y + py * s1.z);
+        let row11 = px * (s1.y + py * s1.z);
+
+        z0 = vec4<f32>(
+            fluid_parent_pressure_sanitize(parent_pressure[s0.x + row00]),
+            fluid_parent_pressure_sanitize(parent_pressure[s1.x + row00]),
+            fluid_parent_pressure_sanitize(parent_pressure[s0.x + row10]),
+            fluid_parent_pressure_sanitize(parent_pressure[s1.x + row10])
+        );
+        z1 = vec4<f32>(
+            fluid_parent_pressure_sanitize(parent_pressure[s0.x + row01]),
+            fluid_parent_pressure_sanitize(parent_pressure[s1.x + row01]),
+            fluid_parent_pressure_sanitize(parent_pressure[s0.x + row11]),
+            fluid_parent_pressure_sanitize(parent_pressure[s1.x + row11])
+        );
+    } else {
+        z0 = vec4<f32>(
+            fluid_parent_pressure_cell(lo),
+            fluid_parent_pressure_cell(vec3<i32>(hi.x, lo.y, lo.z)),
+            fluid_parent_pressure_cell(vec3<i32>(lo.x, hi.y, lo.z)),
+            fluid_parent_pressure_cell(vec3<i32>(hi.x, hi.y, lo.z))
+        );
+        z1 = vec4<f32>(
+            fluid_parent_pressure_cell(vec3<i32>(lo.x, lo.y, hi.z)),
+            fluid_parent_pressure_cell(vec3<i32>(hi.x, lo.y, hi.z)),
+            fluid_parent_pressure_cell(vec3<i32>(lo.x, hi.y, hi.z)),
+            fluid_parent_pressure_cell(hi)
+        );
+    }
+
+    let corners = ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(z0, z1, position - base);
+
+    return texture3d_trilinear_interpolate(corners);
+}
+`, [
+        TEXTURE3D_TRILINEAR_CORNERS_STRUCT.declaration_chunk,
+        chunk_texture3d_trilinear_interpolate,
+        chunk_grid_tile_window,
+        chunk_grid3d_to_index,
+        chunk_is_finite,
+    ]
+);