@woosh/meep-engine 3.55.0 → 3.57.0

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_v3_mac_lattice_corners.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/mac/chunk_v3_mac_lattice_corners.js"],"names":[],"mappings":"AAqBA;;;;;GAKG;AACH,uCAFU,SAAS,CAkBjB;AAEF;;;;;GAKG;AACH,iCAFU,SAAS,CAkBjB;AAEF;;;;;;;GAOG;AACH,0CAFU,SAAS,CA6EjB;AAEF;;;;;;GAMG;AACH,2CAFU,SAAS,CA6EjB;0BA5OwB,oCAAoC"}
+{"version":3,"file":"chunk_v3_mac_lattice_corners.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/mac/chunk_v3_mac_lattice_corners.js"],"names":[],"mappings":"AAqBA;;;;;GAKG;AACH,uCAFU,SAAS,CAkBjB;AAEF;;;;;GAKG;AACH,iCAFU,SAAS,CAkBjB;AAEF;;;;;;;GAOG;AACH,0CAFU,SAAS,CA0EjB;AAEF;;;;;;GAMG;AACH,2CAFU,SAAS,CA0EjB;0BAtOwB,oCAAoC"}

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

@@ -1,237 +1,231 @@
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { TEXTURE3D_TRILINEAR_CORNERS_STRUCT } from "../../shader/chunk/texture/TEXTURE3D_TRILINEAR_CORNERS_STRUCT.js";
-import { V3_MAC_LATTICE_TAP_STRUCT } from "./V3_MAC_LATTICE_TAP_STRUCT.js";
-
-/*
- A manual trilinear tap on a face lattice of the fluid, read through seams: the corner maths of
- chunk_texture3d_trilinear_corners, with each of the eight corners fetched through the enclosing
- shader's seam instead of loaded from one texture region, because a corner may lie beyond the window
- (where the far field or the parent answers) and a toroidal window wraps each corner on its own.
- The result is the S0 TEXTURE3D_TRILINEAR_CORNERS_STRUCT, so texture3d_trilinear_interpolate blends
- it, in f32 and with exact weights.
-
- Two departures from that chunk's corner maths, both the CPU's:
- - no clamp: the seam decides what a lattice point beyond the window holds (the CPU clamps it, which
-   a spec's seam reproduces);
- - a corner at weight 0 collapses onto the lower one. It takes no part in the blend either way, but
-   the corners also bound the MacCormack limiter, and the CPU's limiter (and its sampler) leave such
-   a corner out: a trace ending exactly on a lattice plane, as every trace through a still axis does,
-   is bounded by that plane's values alone.
-*/
-
-/**
- * `v3_mac_lattice_tap(position)`: the {@link V3_MAC_LATTICE_TAP_STRUCT} of a position in a lattice's
- * own index space (lattice point `l` at `l`).
- *
- * @type {CodeChunk}
- */
-export const chunk_v3_mac_lattice_tap = CodeChunk.from(
-    //language=WGSL
-    `
-fn v3_mac_lattice_tap(position: vec3<f32>) -> ${V3_MAC_LATTICE_TAP_STRUCT.wgsl_ref} {
-    let base = floor(position);
-    let weight = position - base;
-    let lo = vec3<i32>(base);
-
-    // a corner at weight 0 takes no part in the blend, and none in the limiter's bounds
-    let hi = lo + select(vec3<i32>(1), vec3<i32>(0), weight == vec3<f32>(0.0));
-
-    return ${V3_MAC_LATTICE_TAP_STRUCT.wgsl_ref}(lo, hi, weight);
-}
-`, [
-        V3_MAC_LATTICE_TAP_STRUCT.declaration_chunk,
-    ]
-);
-
-/**
- * `v3_mac_limit(value, corners)`: Selle's monotone limiter, the value clamped to the least and the
- * greatest of a tap's eight corners. Twin of the CPU's `v3_grid_limit8_at_indices`.
- *
- * @type {CodeChunk}
- */
-export const chunk_v3_mac_limit = CodeChunk.from(
-    //language=WGSL
-    `
-fn v3_mac_limit(value: f32, corners: ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}) -> f32 {
-    let lower = min(corners.z0, corners.z1);
-    let upper = max(corners.z0, corners.z1);
-
-    return clamp(
-        value,
-        min(min(lower.x, lower.y), min(lower.z, lower.w)),
-        max(max(upper.x, upper.y), max(upper.z, upper.w))
-    );
-}
-`, [
-        TEXTURE3D_TRILINEAR_CORNERS_STRUCT.declaration_chunk,
-    ]
-);
-
-/**
- * The corners of a tap on the advected field, one concrete function per component:
- * `v3_mac_source_corners_u(position)`, `_v`, `_w`, `position` in that component's lattice index
- * space. Eight reads of the seam `fn mac_source_u(face: vec3<i32>) -> f32` (and `_v`, `_w`), which
- * the enclosing shader defines for any window-local face.
- *
- * @type {CodeChunk}
- */
-export const chunk_v3_mac_source_corners = CodeChunk.from(
-    //language=WGSL
-    `
-fn v3_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;
-    let n_corners = select(0u, 8u, abs(position.x) < 1e30);
-    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>(mac_source_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));
-    }
-
-    return ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(z0, z1, tap.weight);
-}
-
-fn v3_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;
-    let n_corners = select(0u, 8u, abs(position.x) < 1e30);
-    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>(mac_source_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));
-    }
-
-    return ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(z0, z1, tap.weight);
-}
-
-fn v3_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;
-    let n_corners = select(0u, 8u, abs(position.x) < 1e30);
-    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>(mac_source_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));
-    }
-
-    return ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(z0, z1, tap.weight);
-}
-`, [
-        TEXTURE3D_TRILINEAR_CORNERS_STRUCT.declaration_chunk,
-        chunk_v3_mac_lattice_tap,
-    ]
-);
-
-/**
- * {@link chunk_v3_mac_source_corners} for the predicted field MacCormack corrects with:
- * `v3_mac_forward_corners_u(position)`, `_v`, `_w`, through the seam
- * `fn mac_forward_u(face: vec3<i32>) -> f32` (and `_v`, `_w`).
- *
- * @type {CodeChunk}
- */
-export const chunk_v3_mac_forward_corners = CodeChunk.from(
-    //language=WGSL
-    `
-fn v3_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;
-    let n_corners = select(0u, 8u, abs(position.x) < 1e30);
-    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>(mac_forward_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));
-    }
-
-    return ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(z0, z1, tap.weight);
-}
-
-fn v3_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;
-    let n_corners = select(0u, 8u, abs(position.x) < 1e30);
-    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>(mac_forward_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));
-    }
-
-    return ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(z0, z1, tap.weight);
-}
-
-fn v3_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;
-    let n_corners = select(0u, 8u, abs(position.x) < 1e30);
-    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>(mac_forward_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));
-    }
-
-    return ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(z0, z1, tap.weight);
-}
-`, [
-        TEXTURE3D_TRILINEAR_CORNERS_STRUCT.declaration_chunk,
-        chunk_v3_mac_lattice_tap,
-    ]
-);
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { TEXTURE3D_TRILINEAR_CORNERS_STRUCT } from "../../shader/chunk/texture/TEXTURE3D_TRILINEAR_CORNERS_STRUCT.js";
+import { V3_MAC_LATTICE_TAP_STRUCT } from "./V3_MAC_LATTICE_TAP_STRUCT.js";
+
+/*
+ A manual trilinear tap on a face lattice of the fluid, read through seams: the corner maths of
+ chunk_texture3d_trilinear_corners, with each of the eight corners fetched through the enclosing
+ shader's seam instead of loaded from one texture region, because a corner may lie beyond the window
+ (where the far field or the parent answers) and a toroidal window wraps each corner on its own.
+ The result is the S0 TEXTURE3D_TRILINEAR_CORNERS_STRUCT, so texture3d_trilinear_interpolate blends
+ it, in f32 and with exact weights.
+
+ Two departures from that chunk's corner maths, both the CPU's:
+ - no clamp: the seam decides what a lattice point beyond the window holds (the CPU clamps it, which
+   a spec's seam reproduces);
+ - a corner at weight 0 collapses onto the lower one. It takes no part in the blend either way, but
+   the corners also bound the MacCormack limiter, and the CPU's limiter (and its sampler) leave such
+   a corner out: a trace ending exactly on a lattice plane, as every trace through a still axis does,
+   is bounded by that plane's values alone.
+*/
+
+/**
+ * `v3_mac_lattice_tap(position)`: the {@link V3_MAC_LATTICE_TAP_STRUCT} of a position in a lattice's
+ * own index space (lattice point `l` at `l`).
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_v3_mac_lattice_tap = CodeChunk.from(
+    //language=WGSL
+    `
+fn v3_mac_lattice_tap(position: vec3<f32>) -> ${V3_MAC_LATTICE_TAP_STRUCT.wgsl_ref} {
+    let base = floor(position);
+    let weight = position - base;
+    let lo = vec3<i32>(base);
+
+    // a corner at weight 0 takes no part in the blend, and none in the limiter's bounds
+    let hi = lo + select(vec3<i32>(1), vec3<i32>(0), weight == vec3<f32>(0.0));
+
+    return ${V3_MAC_LATTICE_TAP_STRUCT.wgsl_ref}(lo, hi, weight);
+}
+`, [
+        V3_MAC_LATTICE_TAP_STRUCT.declaration_chunk,
+    ]
+);
+
+/**
+ * `v3_mac_limit(value, corners)`: Selle's monotone limiter, the value clamped to the least and the
+ * greatest of a tap's eight corners. Twin of the CPU's `v3_grid_limit8_at_indices`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_v3_mac_limit = CodeChunk.from(
+    //language=WGSL
+    `
+fn v3_mac_limit(value: f32, corners: ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}) -> f32 {
+    let lower = min(corners.z0, corners.z1);
+    let upper = max(corners.z0, corners.z1);
+
+    return clamp(
+        value,
+        min(min(lower.x, lower.y), min(lower.z, lower.w)),
+        max(max(upper.x, upper.y), max(upper.z, upper.w))
+    );
+}
+`, [
+        TEXTURE3D_TRILINEAR_CORNERS_STRUCT.declaration_chunk,
+    ]
+);
+
+/**
+ * The corners of a tap on the advected field, one concrete function per component:
+ * `v3_mac_source_corners_u(position)`, `_v`, `_w`, `position` in that component's lattice index
+ * space. Eight reads of the seam `fn mac_source_u(face: vec3<i32>) -> f32` (and `_v`, `_w`), which
+ * the enclosing shader defines for any window-local face.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_v3_mac_source_corners = CodeChunk.from(
+    //language=WGSL
+    `
+fn v3_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;
+
+    return ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(
+        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))
+        ),
+        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)
+        ),
+        tap.weight
+    );
+}
+
+fn v3_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;
+
+    return ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(
+        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))
+        ),
+        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)
+        ),
+        tap.weight
+    );
+}
+
+fn v3_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;
+
+    return ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(
+        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))
+        ),
+        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)
+        ),
+        tap.weight
+    );
+}
+`, [
+        TEXTURE3D_TRILINEAR_CORNERS_STRUCT.declaration_chunk,
+        chunk_v3_mac_lattice_tap,
+    ]
+);
+
+/**
+ * {@link chunk_v3_mac_source_corners} for the predicted field MacCormack corrects with:
+ * `v3_mac_forward_corners_u(position)`, `_v`, `_w`, through the seam
+ * `fn mac_forward_u(face: vec3<i32>) -> f32` (and `_v`, `_w`).
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_v3_mac_forward_corners = CodeChunk.from(
+    //language=WGSL
+    `
+fn v3_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;
+
+    return ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(
+        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))
+        ),
+        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)
+        ),
+        tap.weight
+    );
+}
+
+fn v3_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;
+
+    return ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(
+        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))
+        ),
+        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)
+        ),
+        tap.weight
+    );
+}
+
+fn v3_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;
+
+    return ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(
+        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))
+        ),
+        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)
+        ),
+        tap.weight
+    );
+}
+`, [
+        TEXTURE3D_TRILINEAR_CORNERS_STRUCT.declaration_chunk,
+        chunk_v3_mac_lattice_tap,
+    ]
+);

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

@@ -17,8 +17,8 @@
  * - `step`: {@link FLUID_MAC_STEP_STRUCT};
  * - `parent`: {@link FLUID_CASCADE_PARENT_STRUCT}, and `parent_u`, `parent_v`, `parent_w` the parent's
  *   persistent faces: beyond the window both the source and the predicted field are the parent's
- *   identity read at the step's start, as the step's ghosts `ghost_u`, `ghost_v`, `ghost_w` hold it
- *   and past them read again; the band reads the parent itself;
+ *   identity read at the step's start, as the step's ghosts `ghost_u`, `ghost_v`, `ghost_w` hold it;
+ *   the band reads the parent itself;
  * - `source_u`, `source_v`, `source_w`: the persistent velocity the predict pass read, toroidal
  *   through `step.faces_*`;
  * - `forward_u`, `forward_v`, `forward_w`: what the predict pass wrote, window-local;

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

@@ -1 +1 @@
-{"version":3,"file":"shader_fluid_mac_advect_correct.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/mac/shader_fluid_mac_advect_correct.js"],"names":[],"mappings":"AAwMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,8CAFU,aAAa,CAMpB;8BAlP2B,+BAA+B"}
+{"version":3,"file":"shader_fluid_mac_advect_correct.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/mac/shader_fluid_mac_advect_correct.js"],"names":[],"mappings":"AA6OA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,8CAFU,aAAa,CAMpB;8BAtR2B,+BAA+B"}