@woosh/meep-engine 3.56.0 → 3.57.0

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

@@ -1,190 +1,532 @@
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-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_fluid_cascade_parent_velocity } from "../coupling/chunk_fluid_cascade_parent.js";
-import { FLUID_CASCADE_GHOST_DEPTH } from "../coupling/FLUID_CASCADE_GHOSTS.js";
-
-/*
- The seams the MAC chunks read through, as the fluid's passes back them: texels, the solid flags, and
- what lies beyond the window. Each chunk here names the bindings it reads, and a pass that includes it
- declares them under those names, beside the uniform `step` (FLUID_MAC_STEP_STRUCT).
-
- Beyond the window, velocity is the parent's identity read at the step's start: the step's ghosts
- (`ghost_u`, `ghost_v`, `ghost_w`, written once a step by shader_fluid_cascade_ghosts) hold it for
- every face within FLUID_CASCADE_GHOST_DEPTH of the window, and past them the read itself, through
- the uniform `parent` (FLUID_CASCADE_PARENT_STRUCT) and the textures `parent_u`, `parent_v`,
- `parent_w` (chunk_fluid_cascade_parent_velocity). The coarsest cascade's parent is the far field, a
- parent with no window, which reads `v_far`. Cells beyond the window are fluid.
-*/
-
-/**
- * `mac_cell_solid(cell)` from `solid: array<u32>`, the window-local solid flags (bit 0), laid out x
- * fastest over `step.cells.size`. A cell beyond the window is fluid.
- *
- * @type {CodeChunk}
- */
-export const chunk_fluid_mac_seam_solid = CodeChunk.from(
-    //language=WGSL
-    `
-fn mac_cell_solid(cell: vec3<i32>) -> bool {
-    if (!grid_tile_window_contains(cell, step.cells.size)) {
-        return false;
-    }
-
-    return (solid[grid3d_to_index(vec3<u32>(cell), step.cells.size.xy)] & 1u) != 0u;
-}
-`, [
-        chunk_grid_tile_window,
-        chunk_grid3d_to_index,
-    ]
-);
-
-/**
- * `fluid_mac_ghost_u(face)`, `_v`, `_w`: a window-local face past the window, as the step's ghosts
- * hold it: the texel of `ghost_u`, `ghost_v`, `ghost_w` (`texture_3d<f32>`, `r32float`, face `f` at
- * `f + FLUID_CASCADE_GHOST_DEPTH`, `shader_fluid_cascade_ghosts`) inside the shell, and past it the
- * parent's identity read itself (`chunk_fluid_cascade_parent_velocity`), which is what the shell holds.
- *
- * @type {CodeChunk}
- */
-export const chunk_fluid_mac_seam_ghost = CodeChunk.from(
-    //language=WGSL
-    `
-const FLUID_MAC_GHOST_DEPTH = ${FLUID_CASCADE_GHOST_DEPTH};
-
-fn fluid_mac_ghost_u(face: vec3<i32>) -> f32 {
-    let texel = face + vec3<i32>(FLUID_MAC_GHOST_DEPTH);
-
-    if (all(texel >= vec3<i32>(0)) && all(texel < vec3<i32>(step.faces_u.size) + vec3<i32>(2 * FLUID_MAC_GHOST_DEPTH))) {
-        return textureLoad(ghost_u, vec3<u32>(texel), 0).r;
-    }
-
-    return fluid_parent_face_u(face, step.cells.corner - parent.origin);
-}
-
-fn fluid_mac_ghost_v(face: vec3<i32>) -> f32 {
-    let texel = face + vec3<i32>(FLUID_MAC_GHOST_DEPTH);
-
-    if (all(texel >= vec3<i32>(0)) && all(texel < vec3<i32>(step.faces_v.size) + vec3<i32>(2 * FLUID_MAC_GHOST_DEPTH))) {
-        return textureLoad(ghost_v, vec3<u32>(texel), 0).r;
-    }
-
-    return fluid_parent_face_v(face, step.cells.corner - parent.origin);
-}
-
-fn fluid_mac_ghost_w(face: vec3<i32>) -> f32 {
-    let texel = face + vec3<i32>(FLUID_MAC_GHOST_DEPTH);
-
-    if (all(texel >= vec3<i32>(0)) && all(texel < vec3<i32>(step.faces_w.size) + vec3<i32>(2 * FLUID_MAC_GHOST_DEPTH))) {
-        return textureLoad(ghost_w, vec3<u32>(texel), 0).r;
-    }
-
-    return fluid_parent_face_w(face, step.cells.corner - parent.origin);
-}
-`, [
-        chunk_fluid_cascade_parent_velocity,
-    ]
-);
-
-/**
- * `mac_source_u(face)`, `_v`, `_w` from the persistent velocity `source_u`, `source_v`, `source_w`
- * (`texture_3d<f32>`, `r32float`), wrapped through the windows `step.faces_*`; beyond the window, the
- * parent's identity read at the face. The field advects itself, so `mac_carrier_*` reads the same.
- *
- * @type {CodeChunk}
- */
-export const chunk_fluid_mac_seam_source = CodeChunk.from(
-    //language=WGSL
-    `
-fn mac_source_u(face: vec3<i32>) -> f32 {
-    if (grid_tile_window_contains(face, step.faces_u.size)) {
-        return textureLoad(source_u, grid_tile_window_storage(face, step.faces_u.corner_storage, step.faces_u.period), 0).r;
-    }
-
-    return fluid_mac_ghost_u(face);
-}
-
-fn mac_source_v(face: vec3<i32>) -> f32 {
-    if (grid_tile_window_contains(face, step.faces_v.size)) {
-        return textureLoad(source_v, grid_tile_window_storage(face, step.faces_v.corner_storage, step.faces_v.period), 0).r;
-    }
-
-    return fluid_mac_ghost_v(face);
-}
-
-fn mac_source_w(face: vec3<i32>) -> f32 {
-    if (grid_tile_window_contains(face, step.faces_w.size)) {
-        return textureLoad(source_w, grid_tile_window_storage(face, step.faces_w.corner_storage, step.faces_w.period), 0).r;
-    }
-
-    return fluid_mac_ghost_w(face);
-}
-
-fn mac_carrier_u(face: vec3<i32>) -> f32 {
-    if (grid_tile_window_contains(face, step.faces_u.size)) {
-        return textureLoad(source_u, grid_tile_window_storage(face, step.faces_u.corner_storage, step.faces_u.period), 0).r;
-    }
-
-    return textureLoad(ghost_u, vec3<u32>(face + vec3<i32>(FLUID_MAC_GHOST_DEPTH)), 0).r;
-}
-
-fn mac_carrier_v(face: vec3<i32>) -> f32 {
-    if (grid_tile_window_contains(face, step.faces_v.size)) {
-        return textureLoad(source_v, grid_tile_window_storage(face, step.faces_v.corner_storage, step.faces_v.period), 0).r;
-    }
-
-    return textureLoad(ghost_v, vec3<u32>(face + vec3<i32>(FLUID_MAC_GHOST_DEPTH)), 0).r;
-}
-
-fn mac_carrier_w(face: vec3<i32>) -> f32 {
-    if (grid_tile_window_contains(face, step.faces_w.size)) {
-        return textureLoad(source_w, grid_tile_window_storage(face, step.faces_w.corner_storage, step.faces_w.period), 0).r;
-    }
-
-    return textureLoad(ghost_w, vec3<u32>(face + vec3<i32>(FLUID_MAC_GHOST_DEPTH)), 0).r;
-}
-`, [
-        chunk_grid_tile_window,
-        chunk_fluid_mac_seam_ghost,
-    ]
-);
-
-/**
- * `mac_forward_u(face)`, `_v`, `_w` from the predicted field `forward_u`, `forward_v`, `forward_w`
- * (`texture_3d<f32>`, `r32float`), a transient written over the window and stored window-local;
- * beyond the window, the parent's identity read at the face, which this step's advection leaves as
- * it is.
- *
- * @type {CodeChunk}
- */
-export const chunk_fluid_mac_seam_forward = CodeChunk.from(
-    //language=WGSL
-    `
-fn mac_forward_u(face: vec3<i32>) -> f32 {
-    if (grid_tile_window_contains(face, step.faces_u.size)) {
-        return textureLoad(forward_u, vec3<u32>(face), 0).r;
-    }
-
-    return fluid_mac_ghost_u(face);
-}
-
-fn mac_forward_v(face: vec3<i32>) -> f32 {
-    if (grid_tile_window_contains(face, step.faces_v.size)) {
-        return textureLoad(forward_v, vec3<u32>(face), 0).r;
-    }
-
-    return fluid_mac_ghost_v(face);
-}
-
-fn mac_forward_w(face: vec3<i32>) -> f32 {
-    if (grid_tile_window_contains(face, step.faces_w.size)) {
-        return textureLoad(forward_w, vec3<u32>(face), 0).r;
-    }
-
-    return fluid_mac_ghost_w(face);
-}
-`, [
-        chunk_grid_tile_window,
-        chunk_fluid_mac_seam_ghost,
-    ]
-);
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+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 { TEXTURE3D_TRILINEAR_CORNERS_STRUCT } from "../../shader/chunk/texture/TEXTURE3D_TRILINEAR_CORNERS_STRUCT.js";
+import { FLUID_CASCADE_GHOST_DEPTH } from "../coupling/FLUID_CASCADE_GHOSTS.js";
+import { chunk_v3_mac_lattice_tap } from "./chunk_v3_mac_lattice_corners.js";
+
+/*
+ The seams the MAC chunks read through, as the fluid's passes back them: texels, the solid flags, and
+ what lies beyond the window. Each chunk here names the bindings it reads, and a pass that includes it
+ declares them under those names, beside the uniform `step` (FLUID_MAC_STEP_STRUCT).
+
+ Beyond the window, velocity is the parent's identity read at the step's start: the step's ghosts
+ (`ghost_u`, `ghost_v`, `ghost_w`, written once a step by shader_fluid_cascade_ghosts) hold it for
+ every face within FLUID_CASCADE_GHOST_DEPTH of the window, and clamp at the shell's outer boundary.
+ Cells beyond the window are fluid.
+*/
+
+/**
+ * `mac_cell_solid(cell)` from `solid: array<u32>`, the window-local solid flags (bit 0), laid out x
+ * fastest over `step.cells.size`. A cell beyond the window is fluid.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_fluid_mac_seam_solid = CodeChunk.from(
+    //language=WGSL
+    `
+fn mac_cell_solid(cell: vec3<i32>) -> bool {
+    if (!grid_tile_window_contains(cell, step.cells.size)) {
+        return false;
+    }
+
+    return (solid[grid3d_to_index(vec3<u32>(cell), step.cells.size.xy)] & 1u) != 0u;
+}
+`, [
+        chunk_grid_tile_window,
+        chunk_grid3d_to_index,
+    ]
+);
+
+/**
+ * `fluid_mac_ghost_u(face)`, `_v`, `_w`: a window-local face past the window, as the step's ghosts
+ * hold it: the texel of `ghost_u`, `ghost_v`, `ghost_w` (`texture_3d<f32>`, `r32float`, face `f` at
+ * `f + FLUID_CASCADE_GHOST_DEPTH`, `shader_fluid_cascade_ghosts`), clamped to the ghost shell.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_fluid_mac_seam_ghost = CodeChunk.from(
+    //language=WGSL
+    `
+const FLUID_MAC_GHOST_DEPTH = ${FLUID_CASCADE_GHOST_DEPTH};
+
+fn fluid_mac_ghost_u(face: vec3<i32>) -> f32 {
+    let reach = vec3<i32>(step.faces_u.size) + vec3<i32>(2 * FLUID_MAC_GHOST_DEPTH - 1);
+    let texel = clamp(face + vec3<i32>(FLUID_MAC_GHOST_DEPTH), vec3<i32>(0), reach);
+
+    return textureLoad(ghost_u, vec3<u32>(texel), 0).r;
+}
+
+fn fluid_mac_ghost_v(face: vec3<i32>) -> f32 {
+    let reach = vec3<i32>(step.faces_v.size) + vec3<i32>(2 * FLUID_MAC_GHOST_DEPTH - 1);
+    let texel = clamp(face + vec3<i32>(FLUID_MAC_GHOST_DEPTH), vec3<i32>(0), reach);
+
+    return textureLoad(ghost_v, vec3<u32>(texel), 0).r;
+}
+
+fn fluid_mac_ghost_w(face: vec3<i32>) -> f32 {
+    let reach = vec3<i32>(step.faces_w.size) + vec3<i32>(2 * FLUID_MAC_GHOST_DEPTH - 1);
+    let texel = clamp(face + vec3<i32>(FLUID_MAC_GHOST_DEPTH), vec3<i32>(0), reach);
+
+    return textureLoad(ghost_w, vec3<u32>(texel), 0).r;
+}
+`
+);
+
+/**
+ * `mac_source_u(face)`, `_v`, `_w` from the persistent velocity `source_u`, `source_v`, `source_w`
+ * (`texture_3d<f32>`, `r32float`), wrapped through the windows `step.faces_*`; beyond the window, the
+ * step's velocity ghost shell. The field advects itself, so `mac_carrier_*` reads the same.
+ *
+ * Also provides `fluid_mac_source_corners_u/_v/_w` and `fluid_mac_face_carrier_u/_v/_w`, which hoist
+ * the window bounds check and toroidal coordinate wrap out of the 8-corner trilinear and 9-tap carrier
+ * reads so all interior taps compile into a single unconditional VMEM load clause.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_fluid_mac_seam_source = CodeChunk.from(
+    //language=WGSL
+    `
+fn mac_source_u(face: vec3<i32>) -> f32 {
+    if (grid_tile_window_contains(face, step.faces_u.size)) {
+        return textureLoad(source_u, grid_tile_window_storage(face, step.faces_u.corner_storage, step.faces_u.period), 0).r;
+    }
+
+    return fluid_mac_ghost_u(face);
+}
+
+fn mac_source_v(face: vec3<i32>) -> f32 {
+    if (grid_tile_window_contains(face, step.faces_v.size)) {
+        return textureLoad(source_v, grid_tile_window_storage(face, step.faces_v.corner_storage, step.faces_v.period), 0).r;
+    }
+
+    return fluid_mac_ghost_v(face);
+}
+
+fn mac_source_w(face: vec3<i32>) -> f32 {
+    if (grid_tile_window_contains(face, step.faces_w.size)) {
+        return textureLoad(source_w, grid_tile_window_storage(face, step.faces_w.corner_storage, step.faces_w.period), 0).r;
+    }
+
+    return fluid_mac_ghost_w(face);
+}
+
+fn mac_carrier_u(face: vec3<i32>) -> f32 {
+    return mac_source_u(face);
+}
+
+fn mac_carrier_v(face: vec3<i32>) -> f32 {
+    return mac_source_v(face);
+}
+
+fn mac_carrier_w(face: vec3<i32>) -> f32 {
+    return mac_source_w(face);
+}
+
+fn fluid_mac_face_carrier_u(face: vec3<i32>, u_own: f32) -> vec3<f32> {
+    if (face.x >= 1 && face.x < i32(step.cells.size.x)) {
+        let base = face - vec3<i32>(1, 0, 0);
+        let sv0 = grid_tile_window_storage(base, step.faces_v.corner_storage, step.faces_v.period);
+        let sv1_x = select(sv0.x + 1u, 0u, sv0.x + 1u == step.faces_v.period.x);
+        let sv1_y = select(sv0.y + 1u, 0u, sv0.y + 1u == step.faces_v.period.y);
+        let sw0 = grid_tile_window_storage(base, step.faces_w.corner_storage, step.faces_w.period);
+        let sw1_x = select(sw0.x + 1u, 0u, sw0.x + 1u == step.faces_w.period.x);
+        let sw1_z = select(sw0.z + 1u, 0u, sw0.z + 1u == step.faces_w.period.z);
+
+        let v = 0.25 * (
+            textureLoad(source_v, sv0, 0).r + textureLoad(source_v, vec3<u32>(sv1_x, sv0.y, sv0.z), 0).r
+            + textureLoad(source_v, vec3<u32>(sv0.x, sv1_y, sv0.z), 0).r + textureLoad(source_v, vec3<u32>(sv1_x, sv1_y, sv0.z), 0).r
+        );
+        let w = 0.25 * (
+            textureLoad(source_w, sw0, 0).r + textureLoad(source_w, vec3<u32>(sw1_x, sw0.y, sw0.z), 0).r
+            + textureLoad(source_w, vec3<u32>(sw0.x, sw0.y, sw1_z), 0).r + textureLoad(source_w, vec3<u32>(sw1_x, sw0.y, sw1_z), 0).r
+        );
+
+        return vec3<f32>(u_own, v, w);
+    }
+
+    let v = 0.25 * (
+        mac_carrier_v(face + vec3<i32>(-1, 0, 0)) + mac_carrier_v(face)
+        + mac_carrier_v(face + vec3<i32>(-1, 1, 0)) + mac_carrier_v(face + vec3<i32>(0, 1, 0))
+    );
+    let w = 0.25 * (
+        mac_carrier_w(face + vec3<i32>(-1, 0, 0)) + mac_carrier_w(face)
+        + mac_carrier_w(face + vec3<i32>(-1, 0, 1)) + mac_carrier_w(face + vec3<i32>(0, 0, 1))
+    );
+
+    return vec3<f32>(u_own, v, w);
+}
+
+fn fluid_mac_face_carrier_v(face: vec3<i32>, v_own: f32) -> vec3<f32> {
+    if (face.y >= 1 && face.y < i32(step.cells.size.y)) {
+        let base = face - vec3<i32>(0, 1, 0);
+        let su0 = grid_tile_window_storage(base, step.faces_u.corner_storage, step.faces_u.period);
+        let su1_x = select(su0.x + 1u, 0u, su0.x + 1u == step.faces_u.period.x);
+        let su1_y = select(su0.y + 1u, 0u, su0.y + 1u == step.faces_u.period.y);
+        let sw0 = grid_tile_window_storage(base, step.faces_w.corner_storage, step.faces_w.period);
+        let sw1_y = select(sw0.y + 1u, 0u, sw0.y + 1u == step.faces_w.period.y);
+        let sw1_z = select(sw0.z + 1u, 0u, sw0.z + 1u == step.faces_w.period.z);
+
+        let u = 0.25 * (
+            textureLoad(source_u, su0, 0).r + textureLoad(source_u, vec3<u32>(su1_x, su0.y, su0.z), 0).r
+            + textureLoad(source_u, vec3<u32>(su0.x, su1_y, su0.z), 0).r + textureLoad(source_u, vec3<u32>(su1_x, su1_y, su0.z), 0).r
+        );
+        let w = 0.25 * (
+            textureLoad(source_w, sw0, 0).r + textureLoad(source_w, vec3<u32>(sw0.x, sw0.y, sw1_z), 0).r
+            + textureLoad(source_w, vec3<u32>(sw0.x, sw1_y, sw0.z), 0).r + textureLoad(source_w, vec3<u32>(sw0.x, sw1_y, sw1_z), 0).r
+        );
+
+        return vec3<f32>(u, v_own, w);
+    }
+
+    let u = 0.25 * (
+        mac_carrier_u(face + vec3<i32>(0, -1, 0)) + mac_carrier_u(face + vec3<i32>(1, -1, 0))
+        + mac_carrier_u(face) + mac_carrier_u(face + vec3<i32>(1, 0, 0))
+    );
+    let w = 0.25 * (
+        mac_carrier_w(face + vec3<i32>(0, -1, 0)) + mac_carrier_w(face + vec3<i32>(0, -1, 1))
+        + mac_carrier_w(face) + mac_carrier_w(face + vec3<i32>(0, 0, 1))
+    );
+
+    return vec3<f32>(u, v_own, w);
+}
+
+fn fluid_mac_face_carrier_w(face: vec3<i32>, w_own: f32) -> vec3<f32> {
+    if (face.z >= 1 && face.z < i32(step.cells.size.z)) {
+        let base = face - vec3<i32>(0, 0, 1);
+        let su0 = grid_tile_window_storage(base, step.faces_u.corner_storage, step.faces_u.period);
+        let su1_x = select(su0.x + 1u, 0u, su0.x + 1u == step.faces_u.period.x);
+        let su1_z = select(su0.z + 1u, 0u, su0.z + 1u == step.faces_u.period.z);
+        let sv0 = grid_tile_window_storage(base, step.faces_v.corner_storage, step.faces_v.period);
+        let sv1_y = select(sv0.y + 1u, 0u, sv0.y + 1u == step.faces_v.period.y);
+        let sv1_z = select(sv0.z + 1u, 0u, sv0.z + 1u == step.faces_v.period.z);
+
+        let u = 0.25 * (
+            textureLoad(source_u, su0, 0).r + textureLoad(source_u, vec3<u32>(su1_x, su0.y, su0.z), 0).r
+            + textureLoad(source_u, vec3<u32>(su0.x, su0.y, su1_z), 0).r + textureLoad(source_u, vec3<u32>(su1_x, su0.y, su1_z), 0).r
+        );
+        let v = 0.25 * (
+            textureLoad(source_v, sv0, 0).r + textureLoad(source_v, vec3<u32>(sv0.x, sv1_y, sv0.z), 0).r
+            + textureLoad(source_v, vec3<u32>(sv0.x, sv0.y, sv1_z), 0).r + textureLoad(source_v, vec3<u32>(sv0.x, sv1_y, sv1_z), 0).r
+        );
+
+        return vec3<f32>(u, v, w_own);
+    }
+
+    let u = 0.25 * (
+        mac_carrier_u(face + vec3<i32>(0, 0, -1)) + mac_carrier_u(face + vec3<i32>(1, 0, -1))
+        + mac_carrier_u(face) + mac_carrier_u(face + vec3<i32>(1, 0, 0))
+    );
+    let v = 0.25 * (
+        mac_carrier_v(face + vec3<i32>(0, 0, -1)) + mac_carrier_v(face + vec3<i32>(0, 1, -1))
+        + mac_carrier_v(face) + mac_carrier_v(face + vec3<i32>(0, 1, 0))
+    );
+
+    return vec3<f32>(u, v, w_own);
+}
+
+fn fluid_mac_source_corners_u(position: vec3<f32>) -> ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref} {
+    let tap = v3_mac_lattice_tap(position);
+    let lo = tap.lo;
+    let hi = tap.hi;
+
+    var z0: vec4<f32>;
+    var z1: vec4<f32>;
+
+    if (all(lo >= vec3<i32>(0)) && all(vec3<u32>(hi) < step.faces_u.size)) {
+        let s0 = grid_tile_window_storage(lo, step.faces_u.corner_storage, step.faces_u.period);
+        let s1_raw = s0 + vec3<u32>(hi - lo);
+        let s1 = select(s1_raw, vec3<u32>(0u), s1_raw == step.faces_u.period);
+
+        z0 = vec4<f32>(
+            textureLoad(source_u, s0, 0).r,
+            textureLoad(source_u, vec3<u32>(s1.x, s0.y, s0.z), 0).r,
+            textureLoad(source_u, vec3<u32>(s0.x, s1.y, s0.z), 0).r,
+            textureLoad(source_u, vec3<u32>(s1.x, s1.y, s0.z), 0).r
+        );
+        z1 = vec4<f32>(
+            textureLoad(source_u, vec3<u32>(s0.x, s0.y, s1.z), 0).r,
+            textureLoad(source_u, vec3<u32>(s1.x, s0.y, s1.z), 0).r,
+            textureLoad(source_u, vec3<u32>(s0.x, s1.y, s1.z), 0).r,
+            textureLoad(source_u, s1, 0).r
+        );
+    } else {
+        z0 = vec4<f32>(
+            mac_source_u(lo),
+            mac_source_u(vec3<i32>(hi.x, lo.y, lo.z)),
+            mac_source_u(vec3<i32>(lo.x, hi.y, lo.z)),
+            mac_source_u(vec3<i32>(hi.x, hi.y, lo.z))
+        );
+        z1 = vec4<f32>(
+            mac_source_u(vec3<i32>(lo.x, lo.y, hi.z)),
+            mac_source_u(vec3<i32>(hi.x, lo.y, hi.z)),
+            mac_source_u(vec3<i32>(lo.x, hi.y, hi.z)),
+            mac_source_u(hi)
+        );
+    }
+
+    return ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(z0, z1, tap.weight);
+}
+
+fn fluid_mac_source_corners_v(position: vec3<f32>) -> ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref} {
+    let tap = v3_mac_lattice_tap(position);
+    let lo = tap.lo;
+    let hi = tap.hi;
+
+    var z0: vec4<f32>;
+    var z1: vec4<f32>;
+
+    if (all(lo >= vec3<i32>(0)) && all(vec3<u32>(hi) < step.faces_v.size)) {
+        let s0 = grid_tile_window_storage(lo, step.faces_v.corner_storage, step.faces_v.period);
+        let s1_raw = s0 + vec3<u32>(hi - lo);
+        let s1 = select(s1_raw, vec3<u32>(0u), s1_raw == step.faces_v.period);
+
+        z0 = vec4<f32>(
+            textureLoad(source_v, s0, 0).r,
+            textureLoad(source_v, vec3<u32>(s1.x, s0.y, s0.z), 0).r,
+            textureLoad(source_v, vec3<u32>(s0.x, s1.y, s0.z), 0).r,
+            textureLoad(source_v, vec3<u32>(s1.x, s1.y, s0.z), 0).r
+        );
+        z1 = vec4<f32>(
+            textureLoad(source_v, vec3<u32>(s0.x, s0.y, s1.z), 0).r,
+            textureLoad(source_v, vec3<u32>(s1.x, s0.y, s1.z), 0).r,
+            textureLoad(source_v, vec3<u32>(s0.x, s1.y, s1.z), 0).r,
+            textureLoad(source_v, s1, 0).r
+        );
+    } else {
+        z0 = vec4<f32>(
+            mac_source_v(lo),
+            mac_source_v(vec3<i32>(hi.x, lo.y, lo.z)),
+            mac_source_v(vec3<i32>(lo.x, hi.y, lo.z)),
+            mac_source_v(vec3<i32>(hi.x, hi.y, lo.z))
+        );
+        z1 = vec4<f32>(
+            mac_source_v(vec3<i32>(lo.x, lo.y, hi.z)),
+            mac_source_v(vec3<i32>(hi.x, lo.y, hi.z)),
+            mac_source_v(vec3<i32>(lo.x, hi.y, hi.z)),
+            mac_source_v(hi)
+        );
+    }
+
+    return ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(z0, z1, tap.weight);
+}
+
+fn fluid_mac_source_corners_w(position: vec3<f32>) -> ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref} {
+    let tap = v3_mac_lattice_tap(position);
+    let lo = tap.lo;
+    let hi = tap.hi;
+
+    var z0: vec4<f32>;
+    var z1: vec4<f32>;
+
+    if (all(lo >= vec3<i32>(0)) && all(vec3<u32>(hi) < step.faces_w.size)) {
+        let s0 = grid_tile_window_storage(lo, step.faces_w.corner_storage, step.faces_w.period);
+        let s1_raw = s0 + vec3<u32>(hi - lo);
+        let s1 = select(s1_raw, vec3<u32>(0u), s1_raw == step.faces_w.period);
+
+        z0 = vec4<f32>(
+            textureLoad(source_w, s0, 0).r,
+            textureLoad(source_w, vec3<u32>(s1.x, s0.y, s0.z), 0).r,
+            textureLoad(source_w, vec3<u32>(s0.x, s1.y, s0.z), 0).r,
+            textureLoad(source_w, vec3<u32>(s1.x, s1.y, s0.z), 0).r
+        );
+        z1 = vec4<f32>(
+            textureLoad(source_w, vec3<u32>(s0.x, s0.y, s1.z), 0).r,
+            textureLoad(source_w, vec3<u32>(s1.x, s0.y, s1.z), 0).r,
+            textureLoad(source_w, vec3<u32>(s0.x, s1.y, s1.z), 0).r,
+            textureLoad(source_w, s1, 0).r
+        );
+    } else {
+        z0 = vec4<f32>(
+            mac_source_w(lo),
+            mac_source_w(vec3<i32>(hi.x, lo.y, lo.z)),
+            mac_source_w(vec3<i32>(lo.x, hi.y, lo.z)),
+            mac_source_w(vec3<i32>(hi.x, hi.y, lo.z))
+        );
+        z1 = vec4<f32>(
+            mac_source_w(vec3<i32>(lo.x, lo.y, hi.z)),
+            mac_source_w(vec3<i32>(hi.x, lo.y, hi.z)),
+            mac_source_w(vec3<i32>(lo.x, hi.y, hi.z)),
+            mac_source_w(hi)
+        );
+    }
+
+    return ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(z0, z1, tap.weight);
+}
+`, [
+        TEXTURE3D_TRILINEAR_CORNERS_STRUCT.declaration_chunk,
+        chunk_v3_mac_lattice_tap,
+        chunk_grid_tile_window,
+        chunk_fluid_mac_seam_ghost,
+    ]
+);
+
+/**
+ * `mac_forward_u(face)`, `_v`, `_w` from the predicted field `forward_u`, `forward_v`, `forward_w`
+ * (`texture_3d<f32>`, `r32float`), a transient written over the window and stored window-local;
+ * beyond the window, the step's velocity ghost shell, which this step's advection leaves as it is.
+ *
+ * Also provides `fluid_mac_forward_corners_u/_v/_w`, which hoist the window bounds check out of the
+ * 8-corner read so all interior taps compile into a single unconditional VMEM load clause.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_fluid_mac_seam_forward = CodeChunk.from(
+    //language=WGSL
+    `
+fn mac_forward_u(face: vec3<i32>) -> f32 {
+    if (grid_tile_window_contains(face, step.faces_u.size)) {
+        return textureLoad(forward_u, vec3<u32>(face), 0).r;
+    }
+
+    return fluid_mac_ghost_u(face);
+}
+
+fn mac_forward_v(face: vec3<i32>) -> f32 {
+    if (grid_tile_window_contains(face, step.faces_v.size)) {
+        return textureLoad(forward_v, vec3<u32>(face), 0).r;
+    }
+
+    return fluid_mac_ghost_v(face);
+}
+
+fn mac_forward_w(face: vec3<i32>) -> f32 {
+    if (grid_tile_window_contains(face, step.faces_w.size)) {
+        return textureLoad(forward_w, vec3<u32>(face), 0).r;
+    }
+
+    return fluid_mac_ghost_w(face);
+}
+
+fn fluid_mac_forward_corners_u(position: vec3<f32>) -> ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref} {
+    let tap = v3_mac_lattice_tap(position);
+    let lo = tap.lo;
+    let hi = tap.hi;
+
+    var z0: vec4<f32>;
+    var z1: vec4<f32>;
+
+    if (all(lo >= vec3<i32>(0)) && all(vec3<u32>(hi) < step.faces_u.size)) {
+        let s0 = vec3<u32>(lo);
+        let s1 = vec3<u32>(hi);
+
+        z0 = vec4<f32>(
+            textureLoad(forward_u, s0, 0).r,
+            textureLoad(forward_u, vec3<u32>(s1.x, s0.y, s0.z), 0).r,
+            textureLoad(forward_u, vec3<u32>(s0.x, s1.y, s0.z), 0).r,
+            textureLoad(forward_u, vec3<u32>(s1.x, s1.y, s0.z), 0).r
+        );
+        z1 = vec4<f32>(
+            textureLoad(forward_u, vec3<u32>(s0.x, s0.y, s1.z), 0).r,
+            textureLoad(forward_u, vec3<u32>(s1.x, s0.y, s1.z), 0).r,
+            textureLoad(forward_u, vec3<u32>(s0.x, s1.y, s1.z), 0).r,
+            textureLoad(forward_u, s1, 0).r
+        );
+    } else {
+        z0 = vec4<f32>(
+            mac_forward_u(lo),
+            mac_forward_u(vec3<i32>(hi.x, lo.y, lo.z)),
+            mac_forward_u(vec3<i32>(lo.x, hi.y, lo.z)),
+            mac_forward_u(vec3<i32>(hi.x, hi.y, lo.z))
+        );
+        z1 = vec4<f32>(
+            mac_forward_u(vec3<i32>(lo.x, lo.y, hi.z)),
+            mac_forward_u(vec3<i32>(hi.x, lo.y, hi.z)),
+            mac_forward_u(vec3<i32>(lo.x, hi.y, hi.z)),
+            mac_forward_u(hi)
+        );
+    }
+
+    return ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(z0, z1, tap.weight);
+}
+
+fn fluid_mac_forward_corners_v(position: vec3<f32>) -> ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref} {
+    let tap = v3_mac_lattice_tap(position);
+    let lo = tap.lo;
+    let hi = tap.hi;
+
+    var z0: vec4<f32>;
+    var z1: vec4<f32>;
+
+    if (all(lo >= vec3<i32>(0)) && all(vec3<u32>(hi) < step.faces_v.size)) {
+        let s0 = vec3<u32>(lo);
+        let s1 = vec3<u32>(hi);
+
+        z0 = vec4<f32>(
+            textureLoad(forward_v, s0, 0).r,
+            textureLoad(forward_v, vec3<u32>(s1.x, s0.y, s0.z), 0).r,
+            textureLoad(forward_v, vec3<u32>(s0.x, s1.y, s0.z), 0).r,
+            textureLoad(forward_v, vec3<u32>(s1.x, s1.y, s0.z), 0).r
+        );
+        z1 = vec4<f32>(
+            textureLoad(forward_v, vec3<u32>(s0.x, s0.y, s1.z), 0).r,
+            textureLoad(forward_v, vec3<u32>(s1.x, s0.y, s1.z), 0).r,
+            textureLoad(forward_v, vec3<u32>(s0.x, s1.y, s1.z), 0).r,
+            textureLoad(forward_v, s1, 0).r
+        );
+    } else {
+        z0 = vec4<f32>(
+            mac_forward_v(lo),
+            mac_forward_v(vec3<i32>(hi.x, lo.y, lo.z)),
+            mac_forward_v(vec3<i32>(lo.x, hi.y, lo.z)),
+            mac_forward_v(vec3<i32>(hi.x, hi.y, lo.z))
+        );
+        z1 = vec4<f32>(
+            mac_forward_v(vec3<i32>(lo.x, lo.y, hi.z)),
+            mac_forward_v(vec3<i32>(hi.x, lo.y, hi.z)),
+            mac_forward_v(vec3<i32>(lo.x, hi.y, hi.z)),
+            mac_forward_v(hi)
+        );
+    }
+
+    return ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(z0, z1, tap.weight);
+}
+
+fn fluid_mac_forward_corners_w(position: vec3<f32>) -> ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref} {
+    let tap = v3_mac_lattice_tap(position);
+    let lo = tap.lo;
+    let hi = tap.hi;
+
+    var z0: vec4<f32>;
+    var z1: vec4<f32>;
+
+    if (all(lo >= vec3<i32>(0)) && all(vec3<u32>(hi) < step.faces_w.size)) {
+        let s0 = vec3<u32>(lo);
+        let s1 = vec3<u32>(hi);
+
+        z0 = vec4<f32>(
+            textureLoad(forward_w, s0, 0).r,
+            textureLoad(forward_w, vec3<u32>(s1.x, s0.y, s0.z), 0).r,
+            textureLoad(forward_w, vec3<u32>(s0.x, s1.y, s0.z), 0).r,
+            textureLoad(forward_w, vec3<u32>(s1.x, s1.y, s0.z), 0).r
+        );
+        z1 = vec4<f32>(
+            textureLoad(forward_w, vec3<u32>(s0.x, s0.y, s1.z), 0).r,
+            textureLoad(forward_w, vec3<u32>(s1.x, s0.y, s1.z), 0).r,
+            textureLoad(forward_w, vec3<u32>(s0.x, s1.y, s1.z), 0).r,
+            textureLoad(forward_w, s1, 0).r
+        );
+    } else {
+        z0 = vec4<f32>(
+            mac_forward_w(lo),
+            mac_forward_w(vec3<i32>(hi.x, lo.y, lo.z)),
+            mac_forward_w(vec3<i32>(lo.x, hi.y, lo.z)),
+            mac_forward_w(vec3<i32>(hi.x, hi.y, lo.z))
+        );
+        z1 = vec4<f32>(
+            mac_forward_w(vec3<i32>(lo.x, lo.y, hi.z)),
+            mac_forward_w(vec3<i32>(hi.x, lo.y, hi.z)),
+            mac_forward_w(vec3<i32>(lo.x, hi.y, hi.z)),
+            mac_forward_w(hi)
+        );
+    }
+
+    return ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(z0, z1, tap.weight);
+}
+`, [
+        TEXTURE3D_TRILINEAR_CORNERS_STRUCT.declaration_chunk,
+        chunk_v3_mac_lattice_tap,
+        chunk_grid_tile_window,
+        chunk_fluid_mac_seam_ghost,
+    ]
+);