@woosh/meep-engine 3.68.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/forcing/FLUID_FORCING.d.ts

@@ -57,6 +57,20 @@ export const FLUID_SOLID_FLAG: number;
  * @type {number}
  */
 export const FLUID_FORCED_FLAG: number;
+/**
+ * Bit 2 of a cell's solid flags: the forcing wrote the cell's drag this tick, from the porous obstacles
+ * in it (the cell's words of the forcing buffer's porous block). A reader of the drag reads a cell only
+ * under it. Never set on a solid cell.
+ * @type {number}
+ */
+export const FLUID_POROUS_FLAG: number;
+/**
+ * Words a cell takes in the forcing buffer's porous block: its drag over the step, `k·dt`, 1/(m/s),
+ * and the velocity of what drags on it, world m/s (`chunk_fluid_forcing_cell`'s
+ * `fluid_forcing_porous`).
+ * @type {number}
+ */
+export const FLUID_FORCING_POROUS_WORDS: number;
 /**
  * The flags as WGSL constants.
  * @type {CodeChunk}

package/src/shade/renderer/fluid/forcing/FLUID_FORCING.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FLUID_FORCING.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/forcing/FLUID_FORCING.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,kCAFU,MAAM,CAEqB;AAErC;;;GAGG;AACH,wCAFU,MAAM,CAEkD;AAElE;;;;;GAKG;AACH,2CAFU,MAAM,CAE+B;AAE/C;;;;;GAKG;AACH,2CAFU,MAAM,CAE+B;AAE/C;;;;;GAKG;AACH,4CAFU,MAAM,CAE6F;AAE7G;;;;;;GAMG;AACH,+CAFU,MAAM,CAEkE;AAElF;;;;GAIG;AACH,wCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,+BAFU,MAAM,CAEkB;AAElC;;;;;GAKG;AACH,gCAFU,MAAM,CAEmB;AAEnC;;;GAGG;AACH,wCAFU,SAAS,CAQjB;AAEF;;;GAGG;AACH,4CAFU,SAAS,CAcjB;0BAlGwB,oCAAoC"}
+{"version":3,"file":"FLUID_FORCING.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/forcing/FLUID_FORCING.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,kCAFU,MAAM,CAEqB;AAErC;;;GAGG;AACH,wCAFU,MAAM,CAEkD;AAElE;;;;;GAKG;AACH,2CAFU,MAAM,CAE+B;AAE/C;;;;;GAKG;AACH,2CAFU,MAAM,CAE+B;AAE/C;;;;;GAKG;AACH,4CAFU,MAAM,CAE6F;AAE7G;;;;;;GAMG;AACH,+CAFU,MAAM,CAEkE;AAElF;;;;GAIG;AACH,wCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,+BAFU,MAAM,CAEkB;AAElC;;;;;GAKG;AACH,gCAFU,MAAM,CAEmB;AAEnC;;;;;GAKG;AACH,gCAFU,MAAM,CAEmB;AAEnC;;;;;GAKG;AACH,yCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,wCAFU,SAAS,CAUjB;AAEF;;;GAGG;AACH,4CAFU,SAAS,CAcjB;0BApHwB,oCAAoC"}

package/src/shade/renderer/fluid/forcing/FLUID_FORCING.js

@@ -69,6 +69,22 @@ export const FLUID_SOLID_FLAG = 1;
  */
 export const FLUID_FORCED_FLAG = 2;
 
+/**
+ * Bit 2 of a cell's solid flags: the forcing wrote the cell's drag this tick, from the porous obstacles
+ * in it (the cell's words of the forcing buffer's porous block). A reader of the drag reads a cell only
+ * under it. Never set on a solid cell.
+ * @type {number}
+ */
+export const FLUID_POROUS_FLAG = 4;
+
+/**
+ * Words a cell takes in the forcing buffer's porous block: its drag over the step, `k·dt`, 1/(m/s),
+ * and the velocity of what drags on it, world m/s (`chunk_fluid_forcing_cell`'s
+ * `fluid_forcing_porous`).
+ * @type {number}
+ */
+export const FLUID_FORCING_POROUS_WORDS = 4;
+
 /**
  * The flags as WGSL constants.
  * @type {CodeChunk}
@@ -78,6 +94,8 @@ export const chunk_fluid_forcing_flags = CodeChunk.from(
     `
 const FLUID_SOLID_FLAG: u32 = ${FLUID_SOLID_FLAG}u;
 const FLUID_FORCED_FLAG: u32 = ${FLUID_FORCED_FLAG}u;
+const FLUID_POROUS_FLAG: u32 = ${FLUID_POROUS_FLAG}u;
+const FLUID_FORCING_POROUS_WORDS: u32 = ${FLUID_FORCING_POROUS_WORDS}u;
 `
 );
 

package/src/shade/renderer/fluid/forcing/FLUID_FORCING_APPLY_STRUCT.d.ts

@@ -12,7 +12,9 @@
  * - `inverse_frame_dt`: `1 / (frame_dt · fixedStepTimeScale)`, 0 when no game time passed, which a
  *   wake's node velocity is taken with;
  * - `forcing_v`, `forcing_w`: where the v and w faces start in the forcing buffer, which holds the u
- *   faces from 0, each component's faces laid out over its own face lattice, x fastest.
+ *   faces from 0, each component's faces laid out over its own face lattice, x fastest;
+ * - `forcing_porous`: where the cells' porous block starts in it, after the w faces,
+ *   `FLUID_FORCING_POROUS_WORDS` a cell, x fastest.
  *
  * @type {WebGPUStruct}
  */

package/src/shade/renderer/fluid/forcing/FLUID_FORCING_APPLY_STRUCT.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FLUID_FORCING_APPLY_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/forcing/FLUID_FORCING_APPLY_STRUCT.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;GAiBG;AACH,yCAFU,YAAY,CAcE;6BAhCK,mCAAmC"}
+{"version":3,"file":"FLUID_FORCING_APPLY_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/forcing/FLUID_FORCING_APPLY_STRUCT.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,yCAFU,YAAY,CAeE;6BAnCK,mCAAmC"}

package/src/shade/renderer/fluid/forcing/FLUID_FORCING_APPLY_STRUCT.js

@@ -16,7 +16,9 @@ import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
  * - `inverse_frame_dt`: `1 / (frame_dt · fixedStepTimeScale)`, 0 when no game time passed, which a
  *   wake's node velocity is taken with;
  * - `forcing_v`, `forcing_w`: where the v and w faces start in the forcing buffer, which holds the u
- *   faces from 0, each component's faces laid out over its own face lattice, x fastest.
+ *   faces from 0, each component's faces laid out over its own face lattice, x fastest;
+ * - `forcing_porous`: where the cells' porous block starts in it, after the w faces,
+ *   `FLUID_FORCING_POROUS_WORDS` a cell, x fastest.
  *
  * @type {WebGPUStruct}
  */
@@ -32,4 +34,5 @@ export const FLUID_FORCING_APPLY_STRUCT = WebGPUStruct.from({
     inverse_frame_dt: f32,
     forcing_v: u32,
     forcing_w: u32,
+    forcing_porous: u32,
 }, "FluidForcingApply");

package/src/shade/renderer/fluid/forcing/GPUFluidForcing.d.ts

@@ -78,6 +78,15 @@ export class GPUFluidForcing {
      * @param {PipelineEnquiry} enquiry
      */
     static enquirePipelines(enquiry: PipelineEnquiry): void;
+    /**
+     * How wide a record is for the resolution cull. A solid narrower than half a cascade's cell slips
+     * between its cell centres and is left out of that cascade; a porous one drags on every cell it
+     * fills part of, by as much as it fills it, so every cascade keeps it.
+     *
+     * @param {FluidObstacleRecord} record
+     * @returns {number} metres
+     */
+    static "__#295@#resolved_extent"(record: FluidObstacleRecord): number;
     /**
      * The descriptor of a transient of `role`, `size` bytes, from `kept` (by role): the one kept for
      * the role while its size holds, a new one when it moves. A role's usage and clear range never

package/src/shade/renderer/fluid/forcing/GPUFluidForcing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUFluidForcing.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/forcing/GPUFluidForcing.js"],"names":[],"mappings":"AAuIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwEG;AACH;IAEI;;;;OAIG;IACH,iCAFW,eAAe,QAUzB;IA2ID;;;;;;;;;;;OAWG;IACH,kCAPW,wBAAwB,EAAE,QAC1B,MAAM,QACN,MAAM,SACN,MAAM,cACN,MAAM,GACJ,wBAAwB,CAcpC;IAmmBD;;;;OAIG;IACH,yCAJW,MAAM,0CAEN;QAAC,OAAO,yBAAwB;KAAC,QAc3C;IA+MD,iFAcC;IAWD,gFAiCC;IAWD,kFAsBC;IA+GD,gFA0CC;IA3nCD;;;OAGG;IACH;QAF8B,MAAM;OAwCnC;IA4BD;;;OAGG;IACH,4BAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;;;;OAKG;IACH,2BAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;;;;;OAOG;IACH,mBAHW,MAAM,GACJ,MAAM,CAiBlB;IAED;;;;;OAKG;IACH,4BAEC;IAED;;;;;OAKG;IACH,2BAEC;IAED;;;;;OAKG;IACH,qBAHW,mBAAmB,GACjB,MAAM,CAQlB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,UACN,mBAAmB,QAQ7B;IAED;;OAEG;IACH,qBAFW,MAAM,QAUhB;IAED;;;;;OAKG;IACH,uBAHW,mBAAmB,EAAE,GACnB,MAAM,CAsBlB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,UACN,mBAAmB,QAgB7B;IAED;;;OAGG;IACH,wBAHW,MAAM,SACN,MAAM,QAYhB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,MAAM,CAuBlB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,SACN,MAAM,QAmBhB;IAED;;;OAGG;IACH,qBAHW,MAAM,SACN,MAAM,QAUhB;IAyID;;;;;;;;;;;;;;;;;;;OAmBG;IACH;QAf+B,KAAK,EAAzB,UAAU;QACW,cAAc,EAAnC,WAAW;QAEgB,MAAM,EAAjC,UAAU,MAAM,CAAC;QAID,UAAU,EAA1B,MAAM;QAEU,gBAAgB,EAAhC,MAAM;QAEU,SAAS,EAAzB,MAAM;aA4ChB;IAyND;;;;;;;;;;;;OAYG;IACH;QAJ+B,KAAK,EAAzB,UAAU;QACe,KAAK,EAA9B,eAAe;QACe,MAAM,EAApC,eAAe,GAAC,IAAI;aA8H9B;IAmHD;;;;;;;;;;;OAWG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACe,OAAO,EAAhC,eAAe;QACC,EAAE,EAAlB,MAAM;QACJ,MAAM,GAAC,IAAI,CAuFvB;IAyDD;;;OAGG;IACH,gBAwBC;;CACJ;yBAp7CY,OAAO,8DAA8D,EAAE,UAAU;8BACjF,OAAO,6CAA6C,EAAE,eAAe;8BACrE,OAAO,uBAAuB,EAAE,eAAe;kCAC/C,OAAO,kFAAkF,EAAE,mBAAmB;kCAC9G,OAAO,2EAA2E,EAAE,mBAAmB;4BAtCxF,mCAAmC;yCADtB,mDAAmD"}
+{"version":3,"file":"GPUFluidForcing.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/forcing/GPUFluidForcing.js"],"names":[],"mappings":"AAwIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwEG;AACH;IAEI;;;;OAIG;IACH,iCAFW,eAAe,QAUzB;IAqBD;;;;;;;OAOG;IACH,yCAHW,mBAAmB,GACjB,MAAM,CAIlB;IAyHD;;;;;;;;;;;OAWG;IACH,kCAPW,wBAAwB,EAAE,QAC1B,MAAM,QACN,MAAM,SACN,MAAM,cACN,MAAM,GACJ,wBAAwB,CAcpC;IAmmBD;;;;OAIG;IACH,yCAJW,MAAM,0CAEN;QAAC,OAAO,yBAAwB;KAAC,QAc3C;IA+MD,iFAcC;IAWD,gFAiCC;IAWD,kFAsBC;IAiHD,gFA0CC;IA7nCD;;;OAGG;IACH;QAF8B,MAAM;OAwCnC;IA4BD;;;OAGG;IACH,4BAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;;;;OAKG;IACH,2BAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;;;;;OAOG;IACH,mBAHW,MAAM,GACJ,MAAM,CAiBlB;IAED;;;;;OAKG;IACH,4BAEC;IAED;;;;;OAKG;IACH,2BAEC;IAED;;;;;OAKG;IACH,qBAHW,mBAAmB,GACjB,MAAM,CAQlB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,UACN,mBAAmB,QAQ7B;IAED;;OAEG;IACH,qBAFW,MAAM,QAUhB;IAED;;;;;OAKG;IACH,uBAHW,mBAAmB,EAAE,GACnB,MAAM,CAsBlB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,UACN,mBAAmB,QAgB7B;IAED;;;OAGG;IACH,wBAHW,MAAM,SACN,MAAM,QAYhB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,MAAM,CAuBlB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,SACN,MAAM,QAmBhB;IAED;;;OAGG;IACH,qBAHW,MAAM,SACN,MAAM,QAUhB;IAyID;;;;;;;;;;;;;;;;;;;OAmBG;IACH;QAf+B,KAAK,EAAzB,UAAU;QACW,cAAc,EAAnC,WAAW;QAEgB,MAAM,EAAjC,UAAU,MAAM,CAAC;QAID,UAAU,EAA1B,MAAM;QAEU,gBAAgB,EAAhC,MAAM;QAEU,SAAS,EAAzB,MAAM;aA4ChB;IAyND;;;;;;;;;;;;OAYG;IACH;QAJ+B,KAAK,EAAzB,UAAU;QACe,KAAK,EAA9B,eAAe;QACe,MAAM,EAApC,eAAe,GAAC,IAAI;aA8H9B;IAmHD;;;;;;;;;;;OAWG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACe,OAAO,EAAhC,eAAe;QACC,EAAE,EAAlB,MAAM;QACJ,MAAM,GAAC,IAAI,CAyFvB;IAyDD;;;OAGG;IACH,gBAwBC;;CACJ;yBAn8CY,OAAO,8DAA8D,EAAE,UAAU;8BACjF,OAAO,6CAA6C,EAAE,eAAe;8BACrE,OAAO,uBAAuB,EAAE,eAAe;kCAC/C,OAAO,kFAAkF,EAAE,mBAAmB;kCAC9G,OAAO,2EAA2E,EAAE,mBAAmB;4BAvCxF,mCAAmC;yCADtB,mDAAmD"}

package/src/shade/renderer/fluid/forcing/GPUFluidForcing.js

@@ -18,6 +18,7 @@ import {
 } from "./FLUID_DATABASE_SPEC.js";
 import {
     FLUID_FORCING_BRICK,
+    FLUID_FORCING_POROUS_WORDS,
     FLUID_FORCING_REBUILD_AGE,
     FLUID_FORCING_SURVIVOR_STRIDE
 } from "./FLUID_FORCING.js";
@@ -236,11 +237,24 @@ export class GPUFluidForcing {
     #plane_record = { plane: new Float32Array(4) };
 
     /**
-     * Each obstacle row's extent (`fluid_obstacle_record_extent`), metres, indexed by row.
+     * Each obstacle row's extent (`fluid_obstacle_record_extent`), metres, indexed by row; `Infinity` for
+     * a porous one, which every cascade resolves (`GPUFluidForcing.#resolved_extent`).
      * @type {Float64Array}
      */
     #obstacle_extent = new Float64Array(0);
 
+    /**
+     * How wide a record is for the resolution cull. A solid narrower than half a cascade's cell slips
+     * between its cell centres and is left out of that cascade; a porous one drags on every cell it
+     * fills part of, by as much as it fills it, so every cascade keeps it.
+     *
+     * @param {FluidObstacleRecord} record
+     * @returns {number} metres
+     */
+    static #resolved_extent(record) {
+        return record.drag > 0 ? Infinity : fluid_obstacle_record_extent(record);
+    }
+
     /** Bumped by every add and remove of an effector or obstacle row, and by an obstacle's extent changing. */
     #sets_version = 0;
 
@@ -536,7 +550,7 @@ export class GPUFluidForcing {
         }
 
         for (let i = 0; i < records.length; i++) {
-            this.#obstacle_extent[first + i] = fluid_obstacle_record_extent(records[i]);
+            this.#obstacle_extent[first + i] = GPUFluidForcing.#resolved_extent(records[i]);
         }
 
         return first;
@@ -555,7 +569,7 @@ export class GPUFluidForcing {
 
         table.set_record(row, record, OBSTACLE_WRITER);
 
-        const extent = fluid_obstacle_record_extent(record);
+        const extent = GPUFluidForcing.#resolved_extent(record);
 
         if (extent !== this.#obstacle_extent[row]) {
             // which cascades resolve it may have moved
@@ -1365,6 +1379,7 @@ export class GPUFluidForcing {
                 inverse_frame_dt: 0,
                 forcing_v: 0,
                 forcing_w: 0,
+                forcing_porous: 0,
             },
         };
 
@@ -1390,6 +1405,7 @@ export class GPUFluidForcing {
 
         settings.forcing_v = faces_u;
         settings.forcing_w = faces_u + faces_v;
+        settings.forcing_porous = faces_u + faces_v + faces_w;
 
         apply.cascade = cascade;
         apply.tree = tick.trees[slot];
@@ -1400,7 +1416,7 @@ export class GPUFluidForcing {
         apply.list = pass.read(tick.lists[slot]);
         apply.survivors = pass.read(tick.survivors);
         apply.commands = pass.read(tick.commands);
-        apply.output = pass.create('Fluid / forcing / forcing', GPUFluidForcing.#descriptor(this.#descriptors, ROLE_FORCING, 4 * (faces_u + faces_v + faces_w), GPUBufferUsage.STORAGE, 0));
+        apply.output = pass.create('Fluid / forcing / forcing', GPUFluidForcing.#descriptor(this.#descriptors, ROLE_FORCING, 4 * (faces_u + faces_v + faces_w + nx * ny * nz * FLUID_FORCING_POROUS_WORDS), GPUBufferUsage.STORAGE, 0));
 
         // it writes the cascade's flags and persistent faces
         pass.make_side_effect();

package/src/shade/renderer/fluid/forcing/chunk_fluid_forcing_cell.d.ts

@@ -6,9 +6,18 @@
  *   centred at `c`, u face `i` at `i − ½` along x) in world metres, the window's world cell `corner` at
  *   window-local 0: `(corner + p + ½)·h`.
  * - `fluid_forcing_solid(x, count) -> u32`: the solid test at a cell centre, the first of the brick's
- *   `count` obstacles (its lowest row) whose field at `x` is within its inflation,
+ *   `count` solid obstacles (its lowest row) whose field at `x` is within its inflation,
  *   `fluid_obstacle_record_signed_distance(record, global, x) ≤ inflation`; `FLUID_FORCING_NONE` for
- *   fluid. At most `FLUID_FORCING_OBSTACLE_LIMIT` fields, each at most 16 hull planes.
+ *   fluid. A porous obstacle (`drag` above 0) is never solid. At most `FLUID_FORCING_OBSTACLE_LIMIT`
+ *   fields, each at most 16 hull planes.
+ * - `fluid_forcing_porous(x, cell_size, count) -> vec4<f32>`: the drag of the brick's porous obstacles
+ *   on the cell of side `cell_size` centred at `x`: in `x`, the sum of each one's `drag` times the
+ *   share of the cell it fills, 1/m; in `yzw`, the velocity it drags toward, each obstacle's wall
+ *   velocity at `x` weighed by its part of the drag, world m/s, zero where there is no drag. The
+ *   share is the part of the cell's height inside the obstacle along four vertical lines through it,
+ *   at a quarter of the cell in from each side (`fluid_obstacle_record_line_span`), so a layer
+ *   thinner than the cell drags on it by as much as it fills it, and a layer whose sides are vertical
+ *   fills it exactly.
  * - `fluid_forcing_wall_velocity(slot, x) -> vec3<f32>`: the wall's velocity at `x` of the brick's
  *   obstacle `slot`, `rigid_velocity_at_point(v, ω, t, x)` (`fluid_obstacle_record_wall_velocity`).
  * - `fluid_forcing_deposit(x, dt, cell_size, count) -> vec3<f32>`: what the brick's `count` effectors

package/src/shade/renderer/fluid/forcing/chunk_fluid_forcing_cell.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_fluid_forcing_cell.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/forcing/chunk_fluid_forcing_cell.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,uCAFU,SAAS,CAqDjB;0BAnFwB,oCAAoC"}
+{"version":3,"file":"chunk_fluid_forcing_cell.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/forcing/chunk_fluid_forcing_cell.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,uCAFU,SAAS,CAqGjB;0BA5IwB,oCAAoC"}