@woosh/meep-engine 3.56.0 → 3.57.0

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

@@ -1,241 +1,335 @@
-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
-    let n_corners = select(0u, 8u, parent.faces_u.size.x != 0u);
-    if (n_corners == 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>(0.0);
-    var z1 = vec4<f32>(0.0);
-
-    for (var i = 0u; i < n_corners; i++) {
-        let pt = vec3<i32>(
-            select(lo.x, hi.x, (i & 1u) != 0u),
-            select(lo.y, hi.y, (i & 2u) != 0u),
-            select(lo.z, hi.z, (i & 4u) != 0u)
-        );
-        let v = vec4<f32>(fluid_parent_deviation_u(pt));
-        let mask = vec4<u32>(i & 3u) == vec4<u32>(0u, 1u, 2u, 3u);
-        z0 = select(z0, v, mask & vec4<bool>(i < 4u));
-        z1 = select(z1, v, mask & vec4<bool>(i >= 4u));
-    }
-
-    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
-    let n_corners = select(0u, 8u, parent.faces_v.size.x != 0u);
-    if (n_corners == 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>(0.0);
-    var z1 = vec4<f32>(0.0);
-
-    for (var i = 0u; i < n_corners; i++) {
-        let pt = vec3<i32>(
-            select(lo.x, hi.x, (i & 1u) != 0u),
-            select(lo.y, hi.y, (i & 2u) != 0u),
-            select(lo.z, hi.z, (i & 4u) != 0u)
-        );
-        let v = vec4<f32>(fluid_parent_deviation_v(pt));
-        let mask = vec4<u32>(i & 3u) == vec4<u32>(0u, 1u, 2u, 3u);
-        z0 = select(z0, v, mask & vec4<bool>(i < 4u));
-        z1 = select(z1, v, mask & vec4<bool>(i >= 4u));
-    }
-
-    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
-    let n_corners = select(0u, 8u, parent.faces_w.size.x != 0u);
-    if (n_corners == 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>(0.0);
-    var z1 = vec4<f32>(0.0);
-
-    for (var i = 0u; i < n_corners; i++) {
-        let pt = vec3<i32>(
-            select(lo.x, hi.x, (i & 1u) != 0u),
-            select(lo.y, hi.y, (i & 2u) != 0u),
-            select(lo.z, hi.z, (i & 4u) != 0u)
-        );
-        let v = vec4<f32>(fluid_parent_deviation_w(pt));
-        let mask = vec4<u32>(i & 3u) == vec4<u32>(0u, 1u, 2u, 3u);
-        z0 = select(z0, v, mask & vec4<bool>(i < 4u));
-        z1 = select(z1, v, mask & vec4<bool>(i >= 4u));
-    }
-
-    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_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 select(0.0, value, is_finite(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);
-
-    let corners = ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(
-        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))
-        ),
-        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)
-        ),
-        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";
+
+/*
+ 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,
+    ]
+);

package/src/shade/renderer/fluid/coupling/shader_fluid_cascade_ghosts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_fluid_cascade_ghosts.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/coupling/shader_fluid_cascade_ghosts.js"],"names":[],"mappings":"AAiEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,0CAFU,aAAa,CAMpB;8BAnG2B,+BAA+B"}
+{"version":3,"file":"shader_fluid_cascade_ghosts.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/coupling/shader_fluid_cascade_ghosts.js"],"names":[],"mappings":"AAwEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,0CAFU,aAAa,CAMpB;8BA1G2B,+BAA+B"}