@woosh/meep-engine 3.49.0 → 3.50.0

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

@@ -0,0 +1,178 @@
+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 {
+    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);
+}
+`, [
+        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,
+    ]
+);

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

@@ -0,0 +1,17 @@
+/**
+ * `v3_mac_advect_predict_u(face, dt_over_h)`, `_v`, `_w`: the semi-Lagrangian forward pass at one
+ * face.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_v3_mac_advect_predict: CodeChunk;
+/**
+ * `v3_mac_advect_correct_u(face, dt_over_h)`, `_v`, `_w`: the MacCormack correction at one face,
+ * limited. Returns the limited value; a pass that adds per-face terms after the limiter applies them
+ * to what this returns.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_v3_mac_advect_correct: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_v3_mac_advect_maccormack.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_v3_mac_advect_maccormack.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/mac/chunk_v3_mac_advect_maccormack.js"],"names":[],"mappings":"AAiCA;;;;;GAKG;AACH,0CAFU,SAAS,CA4CjB;AAEF;;;;;;GAMG;AACH,0CAFU,SAAS,CAmEjB;0BA3JwB,oCAAoC"}

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

@@ -0,0 +1,156 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_texture3d_trilinear_interpolate } from "../../shader/chunk/texture/sample/chunk_texture3d_trilinear_corners.js";
+import { chunk_v3_mac_clip_trace } from "./chunk_v3_mac_clip_trace.js";
+import { chunk_v3_mac_face_carrier } from "./chunk_v3_mac_face_carrier.js";
+import { chunk_v3_mac_face_pinned } from "./chunk_v3_mac_face_pinned.js";
+import {
+    chunk_v3_mac_forward_corners,
+    chunk_v3_mac_limit,
+    chunk_v3_mac_source_corners
+} from "./chunk_v3_mac_lattice_corners.js";
+
+/*
+ MacCormack advection of a MAC velocity field, one face at a time: the two passes of the CPU's
+ v3_mac_advect_maccormack_velocity, with its solid handling, as concrete u, v and w functions.
+
+ Positions are window-local cell coordinates (cell c centred at c). u face (i, j, k) sits at
+ (i − 0.5, j, k), and a cell coordinate p is u-lattice coordinate p + (0.5, 0, 0); likewise along y
+ for v and z for w. dt_over_h is dt/h: the cells a velocity of 1 m/s crosses in the step.
+
+ - predict: û = the source sampled at the back-trace end, face − carrier·dt/h, clipped against
+   solids.
+ - correct: the forward probe face + carrier·dt/h, clipped, samples the predicted field: ū; then
+   û + ½·(source − ū) at the face, limited to the source's eight corners around the back-trace end.
+ - A pinned face passes the source's value through, in both.
+
+ Samples are manual trilinear taps in f32 (chunk_v3_mac_lattice_corners). Reads a face: predict 9
+ carrier, 8 source, 1 more on a pinned face, and 2 to 6 solid tests; correct 9 carrier, 1 + 8 source,
+ 1 + 8 predicted, and 2 to 11 solid tests.
+
+ Seams, defined by the enclosing shader for any window-local face or cell: mac_carrier_u/_v/_w,
+ mac_source_u/_v/_w, mac_forward_u/_v/_w (correct only) and mac_cell_solid.
+*/
+
+/**
+ * `v3_mac_advect_predict_u(face, dt_over_h)`, `_v`, `_w`: the semi-Lagrangian forward pass at one
+ * face.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_v3_mac_advect_predict = CodeChunk.from(
+    //language=WGSL
+    `
+fn v3_mac_advect_predict_u(face: vec3<i32>, dt_over_h: f32) -> f32 {
+    if (v3_mac_face_pinned_u(face)) {
+        return mac_source_u(face);
+    }
+
+    let start = vec3<f32>(face) - vec3<f32>(0.5, 0.0, 0.0);
+    let back = v3_mac_clip_trace(start, start - v3_mac_face_carrier_u(face) * dt_over_h);
+
+    return texture3d_trilinear_interpolate(v3_mac_source_corners_u(back + vec3<f32>(0.5, 0.0, 0.0)));
+}
+
+fn v3_mac_advect_predict_v(face: vec3<i32>, dt_over_h: f32) -> f32 {
+    if (v3_mac_face_pinned_v(face)) {
+        return mac_source_v(face);
+    }
+
+    let start = vec3<f32>(face) - vec3<f32>(0.0, 0.5, 0.0);
+    let back = v3_mac_clip_trace(start, start - v3_mac_face_carrier_v(face) * dt_over_h);
+
+    return texture3d_trilinear_interpolate(v3_mac_source_corners_v(back + vec3<f32>(0.0, 0.5, 0.0)));
+}
+
+fn v3_mac_advect_predict_w(face: vec3<i32>, dt_over_h: f32) -> f32 {
+    if (v3_mac_face_pinned_w(face)) {
+        return mac_source_w(face);
+    }
+
+    let start = vec3<f32>(face) - vec3<f32>(0.0, 0.0, 0.5);
+    let back = v3_mac_clip_trace(start, start - v3_mac_face_carrier_w(face) * dt_over_h);
+
+    return texture3d_trilinear_interpolate(v3_mac_source_corners_w(back + vec3<f32>(0.0, 0.0, 0.5)));
+}
+`, [
+        chunk_v3_mac_face_pinned,
+        chunk_v3_mac_face_carrier,
+        chunk_v3_mac_clip_trace,
+        chunk_v3_mac_source_corners,
+        chunk_texture3d_trilinear_interpolate,
+    ]
+);
+
+/**
+ * `v3_mac_advect_correct_u(face, dt_over_h)`, `_v`, `_w`: the MacCormack correction at one face,
+ * limited. Returns the limited value; a pass that adds per-face terms after the limiter applies them
+ * to what this returns.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_v3_mac_advect_correct = CodeChunk.from(
+    //language=WGSL
+    `
+fn v3_mac_advect_correct_u(face: vec3<i32>, dt_over_h: f32) -> f32 {
+    let source = mac_source_u(face);
+
+    if (v3_mac_face_pinned_u(face)) {
+        return source;
+    }
+
+    let start = vec3<f32>(face) - vec3<f32>(0.5, 0.0, 0.0);
+    let travel = v3_mac_face_carrier_u(face) * dt_over_h;
+    let back = v3_mac_clip_trace(start, start - travel);
+    let ahead = v3_mac_clip_trace(start, start + travel);
+
+    let backward = texture3d_trilinear_interpolate(v3_mac_forward_corners_u(ahead + vec3<f32>(0.5, 0.0, 0.0)));
+    let corrected = mac_forward_u(face) + 0.5 * (source - backward);
+
+    return v3_mac_limit(corrected, v3_mac_source_corners_u(back + vec3<f32>(0.5, 0.0, 0.0)));
+}
+
+fn v3_mac_advect_correct_v(face: vec3<i32>, dt_over_h: f32) -> f32 {
+    let source = mac_source_v(face);
+
+    if (v3_mac_face_pinned_v(face)) {
+        return source;
+    }
+
+    let start = vec3<f32>(face) - vec3<f32>(0.0, 0.5, 0.0);
+    let travel = v3_mac_face_carrier_v(face) * dt_over_h;
+    let back = v3_mac_clip_trace(start, start - travel);
+    let ahead = v3_mac_clip_trace(start, start + travel);
+
+    let backward = texture3d_trilinear_interpolate(v3_mac_forward_corners_v(ahead + vec3<f32>(0.0, 0.5, 0.0)));
+    let corrected = mac_forward_v(face) + 0.5 * (source - backward);
+
+    return v3_mac_limit(corrected, v3_mac_source_corners_v(back + vec3<f32>(0.0, 0.5, 0.0)));
+}
+
+fn v3_mac_advect_correct_w(face: vec3<i32>, dt_over_h: f32) -> f32 {
+    let source = mac_source_w(face);
+
+    if (v3_mac_face_pinned_w(face)) {
+        return source;
+    }
+
+    let start = vec3<f32>(face) - vec3<f32>(0.0, 0.0, 0.5);
+    let travel = v3_mac_face_carrier_w(face) * dt_over_h;
+    let back = v3_mac_clip_trace(start, start - travel);
+    let ahead = v3_mac_clip_trace(start, start + travel);
+
+    let backward = texture3d_trilinear_interpolate(v3_mac_forward_corners_w(ahead + vec3<f32>(0.0, 0.0, 0.5)));
+    let corrected = mac_forward_w(face) + 0.5 * (source - backward);
+
+    return v3_mac_limit(corrected, v3_mac_source_corners_w(back + vec3<f32>(0.0, 0.0, 0.5)));
+}
+`, [
+        chunk_v3_mac_face_pinned,
+        chunk_v3_mac_face_carrier,
+        chunk_v3_mac_clip_trace,
+        chunk_v3_mac_source_corners,
+        chunk_v3_mac_forward_corners,
+        chunk_v3_mac_limit,
+        chunk_texture3d_trilinear_interpolate,
+    ]
+);

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

@@ -0,0 +1,31 @@
+/**
+ * Bisection steps of {@link chunk_v3_mac_clip_trace}, the CPU's four: the end is found to 1/16 of the
+ * segment, sub-cell at the Courant numbers the fluid runs at.
+ * @type {number}
+ */
+export const V3_MAC_CLIP_TRACE_ITERATIONS: number;
+/**
+ * A trace segment clipped against solid cells, twin of the CPU's `v3_mac_clip_trace`.
+ *
+ * Positions are in window-local cell coordinates, cell `c` centred at `c` and spanning
+ * `[c − 0.5, c + 0.5)`, so the cell holding a point is `floor(p + 0.5)`.
+ *
+ * - `v3_mac_point_in_solid(point)`: whether the cell holding the point is solid.
+ * - `v3_mac_clip_trace(start, end)`: `end` when it is not in a solid; otherwise the segment from the
+ *   fluid `start` is walked back by bisection, a fixed {@link V3_MAC_CLIP_TRACE_ITERATIONS} steps
+ *   with an integer counter, and the last point found in fluid is returned. A segment that leaves
+ *   fluid, crosses a thin wall and re-enters clips at one of its crossings, as on the CPU.
+ *
+ * Cost: one solid test, and four more on a hit.
+ *
+ * ## Seam
+ *
+ * The enclosing shader defines `fn mac_cell_solid(cell: vec3<i32>) -> bool` for any window-local
+ * cell. The CPU clamps a point beyond its grid to the edge cell; the fluid's passes answer a cell
+ * beyond the window as fluid, and a spec that clamps the cell reproduces the CPU.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_v3_mac_clip_trace: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_v3_mac_clip_trace.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_v3_mac_clip_trace.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/mac/chunk_v3_mac_clip_trace.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,2CAFU,MAAM,CAE8B;AAE9C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,sCAFU,SAAS,CAiCjB;0BA9DwB,oCAAoC"}

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

@@ -0,0 +1,63 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * Bisection steps of {@link chunk_v3_mac_clip_trace}, the CPU's four: the end is found to 1/16 of the
+ * segment, sub-cell at the Courant numbers the fluid runs at.
+ * @type {number}
+ */
+export const V3_MAC_CLIP_TRACE_ITERATIONS = 4;
+
+/**
+ * A trace segment clipped against solid cells, twin of the CPU's `v3_mac_clip_trace`.
+ *
+ * Positions are in window-local cell coordinates, cell `c` centred at `c` and spanning
+ * `[c − 0.5, c + 0.5)`, so the cell holding a point is `floor(p + 0.5)`.
+ *
+ * - `v3_mac_point_in_solid(point)`: whether the cell holding the point is solid.
+ * - `v3_mac_clip_trace(start, end)`: `end` when it is not in a solid; otherwise the segment from the
+ *   fluid `start` is walked back by bisection, a fixed {@link V3_MAC_CLIP_TRACE_ITERATIONS} steps
+ *   with an integer counter, and the last point found in fluid is returned. A segment that leaves
+ *   fluid, crosses a thin wall and re-enters clips at one of its crossings, as on the CPU.
+ *
+ * Cost: one solid test, and four more on a hit.
+ *
+ * ## Seam
+ *
+ * The enclosing shader defines `fn mac_cell_solid(cell: vec3<i32>) -> bool` for any window-local
+ * cell. The CPU clamps a point beyond its grid to the edge cell; the fluid's passes answer a cell
+ * beyond the window as fluid, and a spec that clamps the cell reproduces the CPU.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_v3_mac_clip_trace = CodeChunk.from(
+    //language=WGSL
+    `
+const V3_MAC_CLIP_TRACE_ITERATIONS = ${V3_MAC_CLIP_TRACE_ITERATIONS}u;
+
+fn v3_mac_point_in_solid(point: vec3<f32>) -> bool {
+    return mac_cell_solid(vec3<i32>(floor(point + vec3<f32>(0.5))));
+}
+
+fn v3_mac_clip_trace(start: vec3<f32>, end: vec3<f32>) -> vec3<f32> {
+    if (!v3_mac_point_in_solid(end)) {
+        return end;
+    }
+
+    // bisect t in [t_fluid, t_solid] along start + t * (end - start)
+    var t_fluid = 0.0;
+    var t_solid = 1.0;
+
+    for (var iteration = 0u; iteration < V3_MAC_CLIP_TRACE_ITERATIONS; iteration++) {
+        let t = 0.5 * (t_fluid + t_solid);
+
+        if (v3_mac_point_in_solid(start + t * (end - start))) {
+            t_solid = t;
+        } else {
+            t_fluid = t;
+        }
+    }
+
+    return start + t_fluid * (end - start);
+}
+`
+);

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

@@ -0,0 +1,27 @@
+/**
+ * The divergence of a MAC velocity field at a cell, twin of the CPU's `v3_mac_compute_divergence`:
+ *
+ *     scale · ((u[i+1] − u[i]) + (v[j+1] − v[j]) + (w[k+1] − w[k]))
+ *
+ * summed in the CPU's order, and 0 in a solid cell, which is not a degree of freedom. Pinned faces
+ * are read at their value, which is the wall's normal velocity, so a moving wall shows here as
+ * divergence in the fluid beside it.
+ *
+ * `scale` carries the units: `1/h` gives the divergence in 1/s from face velocities in m/s and a cell
+ * of h metres, and `1/(h·dt)` the right-hand side of the pressure solve, `div/dt`.
+ *
+ * Cells and faces are window-local; u face `i` of a cell's row is its −x face.
+ *
+ * ## Seams
+ *
+ * The enclosing shader defines, for any window-local face or cell:
+ * - `fn mac_velocity_u(face: vec3<i32>) -> f32`, and `_v`, `_w`: the field whose divergence is taken;
+ * - `fn mac_cell_solid(cell: vec3<i32>) -> bool`.
+ *
+ * Six face reads and one solid test a cell.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_v3_mac_compute_divergence: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_v3_mac_compute_divergence.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_v3_mac_compute_divergence.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/mac/chunk_v3_mac_compute_divergence.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,8CAFU,SAAS,CAiBjB;0BAzCwB,oCAAoC"}

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

@@ -0,0 +1,42 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * The divergence of a MAC velocity field at a cell, twin of the CPU's `v3_mac_compute_divergence`:
+ *
+ *     scale · ((u[i+1] − u[i]) + (v[j+1] − v[j]) + (w[k+1] − w[k]))
+ *
+ * summed in the CPU's order, and 0 in a solid cell, which is not a degree of freedom. Pinned faces
+ * are read at their value, which is the wall's normal velocity, so a moving wall shows here as
+ * divergence in the fluid beside it.
+ *
+ * `scale` carries the units: `1/h` gives the divergence in 1/s from face velocities in m/s and a cell
+ * of h metres, and `1/(h·dt)` the right-hand side of the pressure solve, `div/dt`.
+ *
+ * Cells and faces are window-local; u face `i` of a cell's row is its −x face.
+ *
+ * ## Seams
+ *
+ * The enclosing shader defines, for any window-local face or cell:
+ * - `fn mac_velocity_u(face: vec3<i32>) -> f32`, and `_v`, `_w`: the field whose divergence is taken;
+ * - `fn mac_cell_solid(cell: vec3<i32>) -> bool`.
+ *
+ * Six face reads and one solid test a cell.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_v3_mac_compute_divergence = CodeChunk.from(
+    //language=WGSL
+    `
+fn v3_mac_compute_divergence(cell: vec3<i32>, scale: f32) -> f32 {
+    if (mac_cell_solid(cell)) {
+        return 0.0;
+    }
+
+    let du = mac_velocity_u(cell + vec3<i32>(1, 0, 0)) - mac_velocity_u(cell);
+    let dv = mac_velocity_v(cell + vec3<i32>(0, 1, 0)) - mac_velocity_v(cell);
+    let dw = mac_velocity_w(cell + vec3<i32>(0, 0, 1)) - mac_velocity_w(cell);
+
+    return (du + dv + dw) * scale;
+}
+`
+);

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

@@ -0,0 +1,25 @@
+/**
+ * The carrier velocity at a face, one concrete function per component: the face's own component as
+ * stored, and each cross component as the exact 4-tap mean of the faces around it. A face sits on
+ * lattice points of the other two lattices along their cross axes, so the four taps are the trilinear
+ * sample there. Twin of the averages inside the CPU's `v3_mac_advect_maccormack_velocity`, summed in
+ * its order.
+ *
+ * - `v3_mac_face_carrier_u(face)` at u face `(i, j, k)`: v from faces `(i − 1, j)`, `(i, j)`,
+ *   `(i − 1, j + 1)`, `(i, j + 1)`; w from `(i − 1, ·, k)`, `(i, ·, k)`, `(i − 1, ·, k + 1)`,
+ *   `(i, ·, k + 1)`.
+ * - `_v` and `_w` likewise.
+ *
+ * At the window's −x edge the taps `i − 1` lie beyond the window; the CPU clamps them onto `i`, and
+ * the seam decides here.
+ *
+ * ## Seam
+ *
+ * The enclosing shader defines `fn mac_carrier_u(face: vec3<i32>) -> f32`, and `_v`, `_w`, for any
+ * window-local face. Nine reads a face.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_v3_mac_face_carrier: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_v3_mac_face_carrier.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_v3_mac_face_carrier.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/mac/chunk_v3_mac_face_carrier.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wCAFU,SAAS,CA4CjB;0BAlEwB,oCAAoC"}

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

@@ -0,0 +1,67 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * The carrier velocity at a face, one concrete function per component: the face's own component as
+ * stored, and each cross component as the exact 4-tap mean of the faces around it. A face sits on
+ * lattice points of the other two lattices along their cross axes, so the four taps are the trilinear
+ * sample there. Twin of the averages inside the CPU's `v3_mac_advect_maccormack_velocity`, summed in
+ * its order.
+ *
+ * - `v3_mac_face_carrier_u(face)` at u face `(i, j, k)`: v from faces `(i − 1, j)`, `(i, j)`,
+ *   `(i − 1, j + 1)`, `(i, j + 1)`; w from `(i − 1, ·, k)`, `(i, ·, k)`, `(i − 1, ·, k + 1)`,
+ *   `(i, ·, k + 1)`.
+ * - `_v` and `_w` likewise.
+ *
+ * At the window's −x edge the taps `i − 1` lie beyond the window; the CPU clamps them onto `i`, and
+ * the seam decides here.
+ *
+ * ## Seam
+ *
+ * The enclosing shader defines `fn mac_carrier_u(face: vec3<i32>) -> f32`, and `_v`, `_w`, for any
+ * window-local face. Nine reads a face.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_v3_mac_face_carrier = CodeChunk.from(
+    //language=WGSL
+    `
+fn v3_mac_face_carrier_u(face: vec3<i32>) -> vec3<f32> {
+    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>(mac_carrier_u(face), v, w);
+}
+
+fn v3_mac_face_carrier_v(face: vec3<i32>) -> vec3<f32> {
+    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, mac_carrier_v(face), w);
+}
+
+fn v3_mac_face_carrier_w(face: vec3<i32>) -> vec3<f32> {
+    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, mac_carrier_w(face));
+}
+`
+);

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

@@ -0,0 +1,23 @@
+/**
+ * Whether a face of a MAC grid is pinned: a cell on either side of it is solid. A pinned face's
+ * normal velocity is a boundary condition, the wall's (0 for a static solid), and every pass carries
+ * it through unchanged.
+ *
+ * Faces are window-local, as in the CPU kernels: u face `(i, j, k)`, `i ∈ [0, nx]`, lies between
+ * cells `(i − 1, j, k)` and `(i, j, k)`, and likewise along y for v and z for w.
+ *
+ * The rule of the CPU's `v3_mac_compute_face_solid`, applied to every face. The CPU leaves the
+ * faces on its domain's edge open whatever their inside cell is; here a face on the window's edge is
+ * an ordinary face between a window cell and a cell outside, which `mac_cell_solid` answers for
+ * (fluid, in the fluid's passes), so an edge face beside a solid cell is pinned.
+ *
+ * ## Seam
+ *
+ * The enclosing shader defines `fn mac_cell_solid(cell: vec3<i32>) -> bool` for any window-local
+ * cell, inside the window or beyond it.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_v3_mac_face_pinned: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_v3_mac_face_pinned.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_v3_mac_face_pinned.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/mac/chunk_v3_mac_face_pinned.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,uCAFU,SAAS,CAiBjB;0BArCwB,oCAAoC"}