@woosh/meep-engine 3.69.0 → 3.70.0

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

@@ -1 +1 @@
-{"version":3,"file":"shader_fluid_cascade_fill.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/coupling/shader_fluid_cascade_fill.js"],"names":[],"mappings":"AA2GA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wCAFU,aAAa,CAMpB;8BAxI2B,+BAA+B"}
+{"version":3,"file":"shader_fluid_cascade_fill.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/coupling/shader_fluid_cascade_fill.js"],"names":[],"mappings":"AA4GA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wCAFU,aAAa,CAMpB;8BAzI2B,+BAA+B"}

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

@@ -10,10 +10,11 @@ import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
 import { chunk_fluid_cascade_parent_pressure, chunk_fluid_cascade_parent_velocity } from "./chunk_fluid_cascade_parent.js";
 import { FLUID_CASCADE_FILL_BRICK, FLUID_CASCADE_FILL_STRUCT } from "./FLUID_CASCADE_FILL_STRUCT.js";
 import { FLUID_CASCADE_PARENT_STRUCT } from "./FLUID_CASCADE_PARENT_STRUCT.js";
+import { fluid_turbulence_add_resources } from "../../wind/chunk_fluid_turbulence.js";
 
 const resources = new ShaderResourceSetDescriptor();
 
-resources.createGroup()
+fluid_turbulence_add_resources(resources.createGroup())
     .addUniform("fill", FLUID_CASCADE_FILL_STRUCT)
     .addUniform("parent", FLUID_CASCADE_PARENT_STRUCT)
     .addTexture("parent_u", "unfilterable-float", "3d")

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":"AAwEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,0CAFU,aAAa,CAMpB;8BA1G2B,+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":"AAyEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,0CAFU,aAAa,CAMpB;8BA3G2B,+BAA+B"}

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

@@ -1,108 +1,109 @@
-import { chunk_grid_tile_window } from "../../shader/chunk/grid/chunk_grid_tile_window.js";
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import { f32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { FLUID_MAC_STEP_STRUCT } from "../mac/FLUID_MAC_STEP_STRUCT.js";
-import { FLUID_CASCADE_GHOST_DEPTH } from "./FLUID_CASCADE_GHOSTS.js";
-import { chunk_fluid_cascade_parent_pressure, chunk_fluid_cascade_parent_velocity } from "./chunk_fluid_cascade_parent.js";
-import { FLUID_CASCADE_PARENT_STRUCT } from "./FLUID_CASCADE_PARENT_STRUCT.js";
-
-const resources = new ShaderResourceSetDescriptor();
-
-resources.createGroup()
-    .addUniform("step", FLUID_MAC_STEP_STRUCT)
-    .addUniform("parent", FLUID_CASCADE_PARENT_STRUCT)
-    .addTexture("parent_u", "unfilterable-float", "3d")
-    .addTexture("parent_v", "unfilterable-float", "3d")
-    .addTexture("parent_w", "unfilterable-float", "3d")
-    .addStorageBuffer("parent_pressure", WebGPUArray.from(f32), false)
-    .addStorageTexture("ghost_u", "r32float", "3d", "write-only")
-    .addStorageTexture("ghost_v", "r32float", "3d", "write-only")
-    .addStorageTexture("ghost_w", "r32float", "3d", "write-only")
-    .addStorageBuffer("ghost_pressure", WebGPUArray.from(f32), true);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-const FLUID_CASCADE_GHOST_DEPTH = ${FLUID_CASCADE_GHOST_DEPTH};
-
-@compute @workgroup_size(4, 4, 4)
-fn main(@builtin(global_invocation_id) id: vec3<u32>) {
-    // the velocity ghosts: shell texel t holds window-local face t - depth, of every face past the window.
-    // Pressure ghosts also use cell = face (t - depth), so any invocation inside step.cells.size is inside
-    // all three face lattices and the pressure window, and exits immediately.
-    let face = vec3<i32>(id) - vec3<i32>(FLUID_CASCADE_GHOST_DEPTH);
-
-    if (grid_tile_window_contains(face, step.cells.size)) {
-        return;
-    }
-
-    let offset = step.cells.corner - parent.origin;
-    let reach = vec3<u32>(2u * u32(FLUID_CASCADE_GHOST_DEPTH));
-
-    if (all(id < step.faces_u.size + reach) && !grid_tile_window_contains(face, step.faces_u.size)) {
-        textureStore(ghost_u, id, vec4<f32>(fluid_parent_face_u(face, offset), 0.0, 0.0, 0.0));
-    }
-
-    if (all(id < step.faces_v.size + reach) && !grid_tile_window_contains(face, step.faces_v.size)) {
-        textureStore(ghost_v, id, vec4<f32>(fluid_parent_face_v(face, offset), 0.0, 0.0, 0.0));
-    }
-
-    if (all(id < step.faces_w.size + reach) && !grid_tile_window_contains(face, step.faces_w.size)) {
-        textureStore(ghost_w, id, vec4<f32>(fluid_parent_face_w(face, offset), 0.0, 0.0, 0.0));
-    }
-
-    // the pressure ghosts: element p_id = face + 1, x fastest over the window and a cell each side
-    let p_coord = face + vec3<i32>(1);
-    let n = step.cells.size + vec3<u32>(2u);
-
-    if (all(p_coord >= vec3<i32>(0)) && all(vec3<u32>(p_coord) < n)) {
-        let p_id = vec3<u32>(p_coord);
-        ghost_pressure[p_id.x + n.x * (p_id.y + n.y * p_id.z)] = fluid_parent_pressure(face + offset);
-    }
-}
-`, [
-        chunk_grid_tile_window,
-        chunk_fluid_cascade_parent_velocity,
-        chunk_fluid_cascade_parent_pressure,
-    ]
-);
-
-/**
- * A step's ghosts (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §7, §9, D3): the parent's identity read,
- * evaluated once at every face of a shell `FLUID_CASCADE_GHOST_DEPTH` faces deep around the
- * window, and the parent's pressure at the centre of every cell one past it, into transients the
- * step's passes read with one texel or element where the parent read takes eight.
- *
- * Read as of the cascade's record, the step's start, as the seams read the parent. A per-step cache:
- * the persistent textures still hold no ghost, and the toroidal windows are the window's alone.
- *
- * Measured on an RTX 4090 at 64×32×64 against the seams reading the parent per tap (four cascades,
- * the stacks driven alike, their recorded ticks replayed paired and interleaved, p10 of 200; the four
- * cascades' state after 32 ticks bit for bit the same): a tick that steps cascade 0 alone
- * 246.8 → 144.4 µs, one with a coarse step 489.5 → 291.8. Of cascade 0's step, predict 45 → 16 µs,
- * correct 89 → 27, the smoother 63 → 53, residual and restriction 22 → 18, the gradient 6 → 4, for
- * this pass's 9.
- *
- * One invocation a texel of the largest face shell, 4 × 4 × 4 a workgroup, dispatched
- * `ceil((N + 1 + 2·depth) / 4)` on each axis; an invocation inside the window writes nothing.
- *
- * Bindings:
- * - `step`: {@link FLUID_MAC_STEP_STRUCT}, the window;
- * - `parent`: {@link FLUID_CASCADE_PARENT_STRUCT}, `parent_u`, `parent_v`, `parent_w` and
- *   `parent_pressure`, the parent;
- * - `ghost_u`, `ghost_v`, `ghost_w`: written, `r32float` 3-D storage textures of the face lattices
- *   grown by the depth on every side, window-local face `f` at texel `f + depth`;
- * - `ghost_pressure`: written, `array<f32>` over the window grown by one cell on every side, x fastest.
- *
- * Two storage buffers and three storage textures.
- *
- * @type {ComputeShader}
- */
-export const shader_fluid_cascade_ghosts = ComputeShader.from({
-    label: "Fluid / cascade ghosts",
-    body,
-    resources,
-});
+import { chunk_grid_tile_window } from "../../shader/chunk/grid/chunk_grid_tile_window.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { f32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { FLUID_MAC_STEP_STRUCT } from "../mac/FLUID_MAC_STEP_STRUCT.js";
+import { FLUID_CASCADE_GHOST_DEPTH } from "./FLUID_CASCADE_GHOSTS.js";
+import { chunk_fluid_cascade_parent_pressure, chunk_fluid_cascade_parent_velocity } from "./chunk_fluid_cascade_parent.js";
+import { FLUID_CASCADE_PARENT_STRUCT } from "./FLUID_CASCADE_PARENT_STRUCT.js";
+import { fluid_turbulence_add_resources } from "../../wind/chunk_fluid_turbulence.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+fluid_turbulence_add_resources(resources.createGroup())
+    .addUniform("step", FLUID_MAC_STEP_STRUCT)
+    .addUniform("parent", FLUID_CASCADE_PARENT_STRUCT)
+    .addTexture("parent_u", "unfilterable-float", "3d")
+    .addTexture("parent_v", "unfilterable-float", "3d")
+    .addTexture("parent_w", "unfilterable-float", "3d")
+    .addStorageBuffer("parent_pressure", WebGPUArray.from(f32), false)
+    .addStorageTexture("ghost_u", "r32float", "3d", "write-only")
+    .addStorageTexture("ghost_v", "r32float", "3d", "write-only")
+    .addStorageTexture("ghost_w", "r32float", "3d", "write-only")
+    .addStorageBuffer("ghost_pressure", WebGPUArray.from(f32), true);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const FLUID_CASCADE_GHOST_DEPTH = ${FLUID_CASCADE_GHOST_DEPTH};
+
+@compute @workgroup_size(4, 4, 4)
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+    // the velocity ghosts: shell texel t holds window-local face t - depth, of every face past the window.
+    // Pressure ghosts also use cell = face (t - depth), so any invocation inside step.cells.size is inside
+    // all three face lattices and the pressure window, and exits immediately.
+    let face = vec3<i32>(id) - vec3<i32>(FLUID_CASCADE_GHOST_DEPTH);
+
+    if (grid_tile_window_contains(face, step.cells.size)) {
+        return;
+    }
+
+    let offset = step.cells.corner - parent.origin;
+    let reach = vec3<u32>(2u * u32(FLUID_CASCADE_GHOST_DEPTH));
+
+    if (all(id < step.faces_u.size + reach) && !grid_tile_window_contains(face, step.faces_u.size)) {
+        textureStore(ghost_u, id, vec4<f32>(fluid_parent_face_u(face, offset), 0.0, 0.0, 0.0));
+    }
+
+    if (all(id < step.faces_v.size + reach) && !grid_tile_window_contains(face, step.faces_v.size)) {
+        textureStore(ghost_v, id, vec4<f32>(fluid_parent_face_v(face, offset), 0.0, 0.0, 0.0));
+    }
+
+    if (all(id < step.faces_w.size + reach) && !grid_tile_window_contains(face, step.faces_w.size)) {
+        textureStore(ghost_w, id, vec4<f32>(fluid_parent_face_w(face, offset), 0.0, 0.0, 0.0));
+    }
+
+    // the pressure ghosts: element p_id = face + 1, x fastest over the window and a cell each side
+    let p_coord = face + vec3<i32>(1);
+    let n = step.cells.size + vec3<u32>(2u);
+
+    if (all(p_coord >= vec3<i32>(0)) && all(vec3<u32>(p_coord) < n)) {
+        let p_id = vec3<u32>(p_coord);
+        ghost_pressure[p_id.x + n.x * (p_id.y + n.y * p_id.z)] = fluid_parent_pressure(face + offset);
+    }
+}
+`, [
+        chunk_grid_tile_window,
+        chunk_fluid_cascade_parent_velocity,
+        chunk_fluid_cascade_parent_pressure,
+    ]
+);
+
+/**
+ * A step's ghosts (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §7, §9, D3): the parent's identity read,
+ * evaluated once at every face of a shell `FLUID_CASCADE_GHOST_DEPTH` faces deep around the
+ * window, and the parent's pressure at the centre of every cell one past it, into transients the
+ * step's passes read with one texel or element where the parent read takes eight.
+ *
+ * Read as of the cascade's record, the step's start, as the seams read the parent. A per-step cache:
+ * the persistent textures still hold no ghost, and the toroidal windows are the window's alone.
+ *
+ * Measured on an RTX 4090 at 64×32×64 against the seams reading the parent per tap (four cascades,
+ * the stacks driven alike, their recorded ticks replayed paired and interleaved, p10 of 200; the four
+ * cascades' state after 32 ticks bit for bit the same): a tick that steps cascade 0 alone
+ * 246.8 → 144.4 µs, one with a coarse step 489.5 → 291.8. Of cascade 0's step, predict 45 → 16 µs,
+ * correct 89 → 27, the smoother 63 → 53, residual and restriction 22 → 18, the gradient 6 → 4, for
+ * this pass's 9.
+ *
+ * One invocation a texel of the largest face shell, 4 × 4 × 4 a workgroup, dispatched
+ * `ceil((N + 1 + 2·depth) / 4)` on each axis; an invocation inside the window writes nothing.
+ *
+ * Bindings:
+ * - `step`: {@link FLUID_MAC_STEP_STRUCT}, the window;
+ * - `parent`: {@link FLUID_CASCADE_PARENT_STRUCT}, `parent_u`, `parent_v`, `parent_w` and
+ *   `parent_pressure`, the parent;
+ * - `ghost_u`, `ghost_v`, `ghost_w`: written, `r32float` 3-D storage textures of the face lattices
+ *   grown by the depth on every side, window-local face `f` at texel `f + depth`;
+ * - `ghost_pressure`: written, `array<f32>` over the window grown by one cell on every side, x fastest.
+ *
+ * Two storage buffers and three storage textures.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_fluid_cascade_ghosts = ComputeShader.from({
+    label: "Fluid / cascade ghosts",
+    body,
+    resources,
+});

package/src/shade/renderer/fluid/coupling/shader_fluid_cascade_restrict.d.ts

@@ -12,8 +12,9 @@
  * more inside the child's window: the child's edge row and relaxation band are not fed back.
  *
  * Frames: the child's faces are deviations from `v_far` at its record and the parent's from `v_far`
- * at its own, which is older (the parent is about to step); the mean deviation is carried to the
- * parent's record by `keep`.
+ * at its own, which is older (the parent is about to step); the mean deviation, taken at the parent
+ * face from the child's far field there, is carried to the parent's record by `keep` and added to the
+ * parent's far field there. With turbulence each far field is one tap of the tile a face.
  *
  * One invocation a parent cell of the box, 8 × 8 × 4 a workgroup, dispatched over the box. A cell
  * writes its −x, −y, −z faces, and the box's last cell on an axis its + face there. Reads 12 child
@@ -22,7 +23,8 @@
  * Bindings:
  * - `restriction`: {@link FLUID_CASCADE_RESTRICT_STRUCT};
  * - `child_u`, `child_v`, `child_w`: the child's persistent faces;
- * - `out_u`, `out_v`, `out_w`: written, the parent's persistent faces.
+ * - `out_u`, `out_v`, `out_w`: written, the parent's persistent faces;
+ * - the turbulence tile (`fluid_turbulence_add_resources`).
  *
  * @type {ComputeShader}
  */

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

@@ -1 +1 @@
-{"version":3,"file":"shader_fluid_cascade_restrict.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/coupling/shader_fluid_cascade_restrict.js"],"names":[],"mappings":"AA6FA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,4CAFU,aAAa,CAMpB;8BA5H2B,+BAA+B"}
+{"version":3,"file":"shader_fluid_cascade_restrict.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/coupling/shader_fluid_cascade_restrict.js"],"names":[],"mappings":"AAuGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,4CAFU,aAAa,CAMpB;8BAxI2B,+BAA+B"}

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

@@ -3,10 +3,12 @@ import { ComputeShader } from "../../shader/ComputeShader.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
 import { FLUID_CASCADE_RESTRICT_STRUCT } from "./FLUID_CASCADE_RESTRICT_STRUCT.js";
+import { fluid_turbulence_add_resources } from "../../wind/chunk_fluid_turbulence.js";
+import { chunk_fluid_far_field } from "../chunk_fluid_far_field.js";
 
 const resources = new ShaderResourceSetDescriptor();
 
-resources.createGroup()
+fluid_turbulence_add_resources(resources.createGroup())
     .addUniform("restriction", FLUID_CASCADE_RESTRICT_STRUCT)
     .addTexture("child_u", "unfilterable-float", "3d")
     .addTexture("child_v", "unfilterable-float", "3d")
@@ -18,28 +20,31 @@ resources.createGroup()
 const body = CodeChunk.from(
     //language=WGSL
     `
-// a child face's deviation from the far field at the child's record
+// a child face less the child's far field's mean, at the child's record
 fn fluid_restrict_child_u(face: vec3<i32>) -> f32 {
     let storage = grid_tile_window_storage(face, restriction.child_u.corner_storage, restriction.child_u.period);
-    return textureLoad(child_u, storage, 0).r - restriction.child_far_velocity.x;
+    return textureLoad(child_u, storage, 0).r - restriction.child_far.mean.x;
 }
 
 fn fluid_restrict_child_v(face: vec3<i32>) -> f32 {
     let storage = grid_tile_window_storage(face, restriction.child_v.corner_storage, restriction.child_v.period);
-    return textureLoad(child_v, storage, 0).r - restriction.child_far_velocity.y;
+    return textureLoad(child_v, storage, 0).r - restriction.child_far.mean.y;
 }
 
 fn fluid_restrict_child_w(face: vec3<i32>) -> f32 {
     let storage = grid_tile_window_storage(face, restriction.child_w.corner_storage, restriction.child_w.period);
-    return textureLoad(child_w, storage, 0).r - restriction.child_far_velocity.z;
+    return textureLoad(child_w, storage, 0).r - restriction.child_far.mean.z;
 }
 
-// parent face P of each component: the mean of the four child faces on it, as of the parent's record
+// parent face P of each component: the mean of the four child faces on it, as a deviation from the
+// child's far field at the face, carried to the parent's record and added to the parent's far field there
 fn fluid_restrict_u(face: vec3<i32>) {
     let c = 2 * face + restriction.child_offset;
     let sum = (fluid_restrict_child_u(c) + fluid_restrict_child_u(c + vec3<i32>(0, 1, 0)))
         + (fluid_restrict_child_u(c + vec3<i32>(0, 0, 1)) + fluid_restrict_child_u(c + vec3<i32>(0, 1, 1)));
-    let value = restriction.far_velocity.x + (0.25 * sum) * restriction.keep;
+    let at = vec3<f32>(face) - vec3<f32>(0.5, 0.0, 0.0);
+    let child_eddy = restriction.child_far.sigma * fluid_far_unit(restriction.child_far, at).x;
+    let value = fluid_far_field(restriction.far, at).x + (0.25 * sum - child_eddy) * restriction.keep;
 
     textureStore(out_u, grid_tile_window_storage(face, restriction.faces_u.corner_storage, restriction.faces_u.period), vec4<f32>(value, 0.0, 0.0, 0.0));
 }
@@ -48,7 +53,9 @@ fn fluid_restrict_v(face: vec3<i32>) {
     let c = 2 * face + restriction.child_offset;
     let sum = (fluid_restrict_child_v(c) + fluid_restrict_child_v(c + vec3<i32>(1, 0, 0)))
         + (fluid_restrict_child_v(c + vec3<i32>(0, 0, 1)) + fluid_restrict_child_v(c + vec3<i32>(1, 0, 1)));
-    let value = restriction.far_velocity.y + (0.25 * sum) * restriction.keep;
+    let at = vec3<f32>(face) - vec3<f32>(0.0, 0.5, 0.0);
+    let child_eddy = restriction.child_far.sigma * fluid_far_unit(restriction.child_far, at).y;
+    let value = fluid_far_field(restriction.far, at).y + (0.25 * sum - child_eddy) * restriction.keep;
 
     textureStore(out_v, grid_tile_window_storage(face, restriction.faces_v.corner_storage, restriction.faces_v.period), vec4<f32>(value, 0.0, 0.0, 0.0));
 }
@@ -57,7 +64,9 @@ fn fluid_restrict_w(face: vec3<i32>) {
     let c = 2 * face + restriction.child_offset;
     let sum = (fluid_restrict_child_w(c) + fluid_restrict_child_w(c + vec3<i32>(1, 0, 0)))
         + (fluid_restrict_child_w(c + vec3<i32>(0, 1, 0)) + fluid_restrict_child_w(c + vec3<i32>(1, 1, 0)));
-    let value = restriction.far_velocity.z + (0.25 * sum) * restriction.keep;
+    let at = vec3<f32>(face) - vec3<f32>(0.0, 0.0, 0.5);
+    let child_eddy = restriction.child_far.sigma * fluid_far_unit(restriction.child_far, at).z;
+    let value = fluid_far_field(restriction.far, at).z + (0.25 * sum - child_eddy) * restriction.keep;
 
     textureStore(out_w, grid_tile_window_storage(face, restriction.faces_w.corner_storage, restriction.faces_w.period), vec4<f32>(value, 0.0, 0.0, 0.0));
 }
@@ -88,6 +97,7 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
 }
 `, [
         chunk_grid_tile_window,
+        chunk_fluid_far_field,
     ]
 );
 
@@ -105,8 +115,9 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
  * more inside the child's window: the child's edge row and relaxation band are not fed back.
  *
  * Frames: the child's faces are deviations from `v_far` at its record and the parent's from `v_far`
- * at its own, which is older (the parent is about to step); the mean deviation is carried to the
- * parent's record by `keep`.
+ * at its own, which is older (the parent is about to step); the mean deviation, taken at the parent
+ * face from the child's far field there, is carried to the parent's record by `keep` and added to the
+ * parent's far field there. With turbulence each far field is one tap of the tile a face.
  *
  * One invocation a parent cell of the box, 8 × 8 × 4 a workgroup, dispatched over the box. A cell
  * writes its −x, −y, −z faces, and the box's last cell on an axis its + face there. Reads 12 child
@@ -115,7 +126,8 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
  * Bindings:
  * - `restriction`: {@link FLUID_CASCADE_RESTRICT_STRUCT};
  * - `child_u`, `child_v`, `child_w`: the child's persistent faces;
- * - `out_u`, `out_v`, `out_w`: written, the parent's persistent faces.
+ * - `out_u`, `out_v`, `out_w`: written, the parent's persistent faces;
+ * - the turbulence tile (`fluid_turbulence_add_resources`).
  *
  * @type {ComputeShader}
  */

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

@@ -18,8 +18,12 @@
  *
  * The step runs from `t₀`, the instant the cascade's velocity was last brought to (its read record),
  * to `t₁` (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §6, §8):
- * - `far_velocity`: `v_far(t₀)`, m/s: what the velocity the step starts from is a deviation from.
- * - `far_velocity_end`: `v_far(t₁)`, m/s.
+ * - `far`: `v_far(t₀)`, what the velocity the step starts from is a deviation from, as the air the
+ *   far field alone moves arrives at each point by `t₁`: its mean and `σ` at `t₀`, its eddies where
+ *   the mean has carried them by `t₁` ({@link FLUID_FAR_FIELD_STRUCT}, over the window's cells, cell
+ *   coordinate 0 at window-local cell 0). The eddies that arrive at a face by `t₁` are where the
+ *   end's offset puts them, so `far` and `far_end` share `origin` and `scale`, and one tap serves both.
+ * - `far_end`: `v_far(t₁)`, over the same lattice.
  * - `keep`: `e^(−(Λ(t₁) − Λ(t₀)))`, the deviation the atmosphere leaves over the step.
  * - `deviation_limit`: m/s, `FLUID_CASCADE_DEVIATION_CELLS·h/dt`, the clamp on `|v − v_far(t₁)|`.
  * - `band`: 1 when the faces of rows 2..5 relax toward the parent, 0 when they do not.

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

@@ -1 +1 @@
-{"version":3,"file":"FLUID_MAC_STEP_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/mac/FLUID_MAC_STEP_STRUCT.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,iDAamB;6BA/CU,mCAAmC"}
+{"version":3,"file":"FLUID_MAC_STEP_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/mac/FLUID_MAC_STEP_STRUCT.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,iDAamB;6BApDU,mCAAmC"}

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

@@ -1,6 +1,7 @@
 import { GRID_TILE_WINDOW_STRUCT } from "../../shader/chunk/grid/GRID_TILE_WINDOW_STRUCT.js";
-import { f32, u32, vec3f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { FLUID_FAR_FIELD_STRUCT } from "../FLUID_FAR_FIELD_STRUCT.js";
 
 /**
  * What the MAC passes of one cascade step read, as the uniform `step`.
@@ -22,8 +23,12 @@ import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
  *
  * The step runs from `t₀`, the instant the cascade's velocity was last brought to (its read record),
  * to `t₁` (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §6, §8):
- * - `far_velocity`: `v_far(t₀)`, m/s: what the velocity the step starts from is a deviation from.
- * - `far_velocity_end`: `v_far(t₁)`, m/s.
+ * - `far`: `v_far(t₀)`, what the velocity the step starts from is a deviation from, as the air the
+ *   far field alone moves arrives at each point by `t₁`: its mean and `σ` at `t₀`, its eddies where
+ *   the mean has carried them by `t₁` ({@link FLUID_FAR_FIELD_STRUCT}, over the window's cells, cell
+ *   coordinate 0 at window-local cell 0). The eddies that arrive at a face by `t₁` are where the
+ *   end's offset puts them, so `far` and `far_end` share `origin` and `scale`, and one tap serves both.
+ * - `far_end`: `v_far(t₁)`, over the same lattice.
  * - `keep`: `e^(−(Λ(t₁) − Λ(t₀)))`, the deviation the atmosphere leaves over the step.
  * - `deviation_limit`: m/s, `FLUID_CASCADE_DEVIATION_CELLS·h/dt`, the clamp on `|v − v_far(t₁)|`.
  * - `band`: 1 when the faces of rows 2..5 relax toward the parent, 0 when they do not.
@@ -39,9 +44,9 @@ export const FLUID_MAC_STEP_STRUCT = WebGPUStruct.from({
     faces_u: GRID_TILE_WINDOW_STRUCT,
     faces_v: GRID_TILE_WINDOW_STRUCT,
     faces_w: GRID_TILE_WINDOW_STRUCT,
-    far_velocity: vec3f,
+    far: FLUID_FAR_FIELD_STRUCT,
+    far_end: FLUID_FAR_FIELD_STRUCT,
     dt_over_h: f32,
-    far_velocity_end: vec3f,
     rhs_scale: f32,
     keep: f32,
     deviation_limit: f32,

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

@@ -1,18 +1,3 @@
-/**
- * @typedef {import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext} ShadeGPUCommandContext
- * @typedef {import("./FluidMacVelocitySet.js").FluidMacVelocitySet} FluidMacVelocitySet
- * @typedef {{u: GPUTextureView, v: GPUTextureView, w: GPUTextureView}} FluidMacVelocityViews a MAC
- *   velocity field's three component views: a {@link FluidMacVelocitySet}'s, or a frame graph's
- *   transient textures'
- * @typedef {{uniform: GPUBuffer, u: GPUTextureView, v: GPUTextureView, w: GPUTextureView, pressure: GPUBuffer}} FluidCascadeParentBindings
- *   what a step reads of its parent beyond its window: `uniform`, the parent as
- *   {@link FLUID_CASCADE_PARENT_STRUCT}; `u`, `v`, `w`, its persistent faces; `pressure`, its pressure.
- *   A far-field parent binds stand-ins it never reads.
- * @typedef {{u: GPUTextureView, v: GPUTextureView, w: GPUTextureView, pressure: GPUBuffer}} FluidCascadeGhostBindings
- *   a step's ghosts (`shader_fluid_cascade_ghosts`): `u`, `v`, `w`, the velocity shells, transient
- *   `r32float` textures of each face lattice grown by `FLUID_CASCADE_GHOST_DEPTH` on every side;
- *   `pressure`, the pressure ghosts over the window grown by one cell.
- */
 /**
  * Records the MAC passes of one cascade's step (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §8): the
  * advection (predict, then correct), the right-hand side of the pressure solve, and the gradient
@@ -61,15 +46,27 @@ export class FluidMacPasses {
      *
      * @param {number} h cell size, m
      * @param {number} dt time step, s
-     * @param {ArrayLike<number>} far_velocity `v_far(t₀)`, m/s: what the velocity the step starts from
-     *   is a deviation from
-     * @param {ArrayLike<number>} far_velocity_end `v_far(t₁)`, m/s
+     * @param {{mean: ArrayLike<number>, sigma: number, origin: ArrayLike<number>, scale: ArrayLike<number>}} far
+     *   `v_far(t₀)` as {@link FLUID_MAC_STEP_STRUCT} `far` holds it, over the window's cells: what the
+     *   velocity the step starts from is a deviation from
+     * @param {{mean: ArrayLike<number>, sigma: number, origin: ArrayLike<number>, scale: ArrayLike<number>}} far_end
+     *   `v_far(t₁)`, likewise
      * @param {number} keep `e^(−(Λ(t₁) − Λ(t₀)))`, in [0, 1]
      * @param {boolean} band whether the faces of rows 2..5 relax toward the parent
      * @param {number} confinement the vorticity confinement's strength ε, per second, ≥ 0: 0 for none,
      *   and then {@link record_curl} is not recorded for the step
      */
-    set_step(h: number, dt: number, far_velocity: ArrayLike<number>, far_velocity_end: ArrayLike<number>, keep: number, band: boolean, confinement: number): void;
+    set_step(h: number, dt: number, far: {
+        mean: ArrayLike<number>;
+        sigma: number;
+        origin: ArrayLike<number>;
+        scale: ArrayLike<number>;
+    }, far_end: {
+        mean: ArrayLike<number>;
+        sigma: number;
+        origin: ArrayLike<number>;
+        scale: ArrayLike<number>;
+    }, keep: number, band: boolean, confinement: number): void;
     /**
      * The step's vorticity confinement, pass 1 (`shader_fluid_mac_curl`): the curl of the persistent
      * velocity and the force it makes in every cell, for the correct pass. Recorded only for a step whose
@@ -146,8 +143,9 @@ export type FluidMacVelocityViews = {
 };
 /**
  * what a step reads of its parent beyond its window: `uniform`, the parent as
- * {@link FLUID_CASCADE_PARENT_STRUCT }; `u`, `v`, `w`, its persistent faces; `pressure`, its pressure.
- * A far-field parent binds stand-ins it never reads.
+ * {@link FLUID_CASCADE_PARENT_STRUCT }; `u`, `v`, `w`, its persistent faces; `pressure`, its pressure;
+ * `turbulence`, the far field's turbulence tile, which the step's far field reads too. A far-field
+ * parent binds stand-ins it never reads.
  */
 export type FluidCascadeParentBindings = {
     uniform: GPUBuffer;
@@ -155,6 +153,7 @@ export type FluidCascadeParentBindings = {
     v: GPUTextureView;
     w: GPUTextureView;
     pressure: GPUBuffer;
+    turbulence: GPUTextureView;
 };
 /**
  * a step's ghosts (`shader_fluid_cascade_ghosts`): `u`, `v`, `w`, the velocity shells, transient

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

@@ -1 +1 @@
-{"version":3,"file":"FluidMacPasses.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/mac/FluidMacPasses.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IACI;;;;OAIG;IACH,iCAFW,OAAO,6CAA6C,EAAE,eAAe,QAW/E;IA2ED;;;;;OAKG;IACH,kBAHW,UAAU,MAAM,CAAC,UACjB,UAAU,MAAM,CAAC,QAkC3B;IAED;;;;;;;;;;;;OAYG;IACH,YAVW,MAAM,MACN,MAAM,gBACN,UAAU,MAAM,CAAC,oBAEjB,UAAU,MAAM,CAAC,QACjB,MAAM,QACN,OAAO,eACP,MAAM,QA+BhB;IAaD;;;;;;;;;OASG;IACH,qBALW,sBAAsB,UACtB,qBAAqB,kDAmB/B;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,uBAbW,sBAAsB,UACtB,qBAAqB,WACrB,qBAAqB,OACrB,qBAAqB,wEAOrB,0BAA0B,UAC1B,yBAAyB,QAwCnC;IAED;;;;;;;OAOG;IACH,uBAJW,sBAAsB,UACtB,0BAA0B,UAC1B,yBAAyB,QAgBnC;IAuBD;;;;;;;;;OASG;IACH,2BANW,sBAAsB,YACtB,qBAAqB,6DAmB/B;IAED;;;;;;;;;OASG;IACH,yBAPW,sBAAsB,YACtB,qBAAqB,8CAGrB,qBAAqB,UACrB,yBAAyB,QAmBnC;;CACJ;qCA3ZY,OAAO,2CAA2C,EAAE,sBAAsB;kCAC1E,OAAO,0BAA0B,EAAE,mBAAmB;;;;;;oCACtD;IAAC,CAAC,iBAAiB;IAAC,CAAC,iBAAiB;IAAC,CAAC,iBAAgB;CAAC;;;;;;yCAGzD;IAAC,OAAO,YAAY;IAAC,CAAC,iBAAiB;IAAC,CAAC,iBAAiB;IAAC,CAAC,iBAAiB;IAAC,QAAQ,YAAW;CAAC;;;;;;wCAIlG;IAAC,CAAC,iBAAiB;IAAC,CAAC,iBAAiB;IAAC,CAAC,iBAAiB;IAAC,QAAQ,YAAW;CAAC"}
+{"version":3,"file":"FluidMacPasses.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/mac/FluidMacPasses.js"],"names":[],"mappings":"AAuDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IACI;;;;OAIG;IACH,iCAFW,OAAO,6CAA6C,EAAE,eAAe,QAW/E;IA2ED;;;;;OAKG;IACH,kBAHW,UAAU,MAAM,CAAC,UACjB,UAAU,MAAM,CAAC,QAkC3B;IAED;;;;;;;;;;;;;;OAcG;IACH,YAZW,MAAM,MACN,MAAM,OACN;QAAC,IAAI,EAAE,UAAU,MAAM,CAAC,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,UAAU,MAAM,CAAC,CAAC;QAAC,KAAK,EAAE,UAAU,MAAM,CAAC,CAAA;KAAC,WAG7F;QAAC,IAAI,EAAE,UAAU,MAAM,CAAC,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,UAAU,MAAM,CAAC,CAAC;QAAC,KAAK,EAAE,UAAU,MAAM,CAAC,CAAA;KAAC,QAE7F,MAAM,QACN,OAAO,eACP,MAAM,QA0BhB;IAaD;;;;;;;;;OASG;IACH,qBALW,sBAAsB,UACtB,qBAAqB,kDAmB/B;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,uBAbW,sBAAsB,UACtB,qBAAqB,WACrB,qBAAqB,OACrB,qBAAqB,wEAOrB,0BAA0B,UAC1B,yBAAyB,QA0CnC;IAED;;;;;;;OAOG;IACH,uBAJW,sBAAsB,UACtB,0BAA0B,UAC1B,yBAAyB,QAkBnC;IAuBD;;;;;;;;;OASG;IACH,2BANW,sBAAsB,YACtB,qBAAqB,6DAmB/B;IAED;;;;;;;;;OASG;IACH,yBAPW,sBAAsB,YACtB,qBAAqB,8CAGrB,qBAAqB,UACrB,yBAAyB,QAmBnC;;CACJ;qCApbY,OAAO,2CAA2C,EAAE,sBAAsB;kCAC1E,OAAO,0BAA0B,EAAE,mBAAmB;;;;;;oCACtD;IAAC,CAAC,iBAAiB;IAAC,CAAC,iBAAiB;IAAC,CAAC,iBAAgB;CAAC;;;;;;;yCAGzD;IAAC,OAAO,YAAY;IAAC,CAAC,iBAAiB;IAAC,CAAC,iBAAiB;IAAC,CAAC,iBAAiB;IAAC,QAAQ,YAAY;IAAC,UAAU,iBAAgB;CAAC;;;;;;wCAK9H;IAAC,CAAC,iBAAiB;IAAC,CAAC,iBAAiB;IAAC,CAAC,iBAAiB;IAAC,QAAQ,YAAW;CAAC"}