@woosh/meep-engine 3.49.0 → 3.50.0

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

@@ -0,0 +1,32 @@
+/**
+ * The per-cell and per-face maths of the forcing (`shader_fluid_forcing_apply`, Q3), as pure functions
+ * over a brick's survivors, which the emulator runs:
+ *
+ * - `fluid_forcing_world(corner, cell_size, p) -> vec3<f32>`: a window-local cell coordinate (cell `c`
+ *   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,
+ *   `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_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
+ *   add at `x` over a step of `dt` on a lattice of `cell_size`, the sum of
+ *   `fluid_effector_record_deposit`, kernel floor and all: the GPU half of one record, two executors,
+ *   whose CPU half is `fluid_record_apply`. At most `FLUID_FORCING_EFFECTOR_LIMIT` kernels.
+ *
+ * ## Seams
+ *
+ * The enclosing shader defines, for every slot below its count:
+ * - `fn fluid_forcing_obstacle(slot: u32) -> FluidObstacleRecord` and
+ *   `fn fluid_forcing_obstacle_global(slot: u32) -> mat4x4<f32>`, the record and its node's `global`;
+ * - `fn fluid_forcing_effector(slot: u32) -> FluidEffectorRecord`, a world record (node 0, or brought
+ *   there by `fluid_effector_record_resolve`);
+ * - `fn shape_record_plane(index: u32) -> vec4<f32>`, the hull planes the obstacles name.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_fluid_forcing_cell: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_fluid_forcing_cell.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,87 @@
+import { chunk_fluid_effector_record_deposit } from "../../../../engine/physics/fluid/effector/record/chunk_fluid_effector_record_deposit.js";
+import { FLUID_EFFECTOR_RECORD_STRUCT } from "../../../../engine/physics/fluid/effector/record/FLUID_EFFECTOR_RECORD_STRUCT.js";
+import { chunk_fluid_obstacle_record } from "../../../../engine/physics/fluid/obstacle/chunk_fluid_obstacle_record.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_fluid_forcing_constants } from "./FLUID_FORCING.js";
+
+/**
+ * The per-cell and per-face maths of the forcing (`shader_fluid_forcing_apply`, Q3), as pure functions
+ * over a brick's survivors, which the emulator runs:
+ *
+ * - `fluid_forcing_world(corner, cell_size, p) -> vec3<f32>`: a window-local cell coordinate (cell `c`
+ *   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,
+ *   `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_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
+ *   add at `x` over a step of `dt` on a lattice of `cell_size`, the sum of
+ *   `fluid_effector_record_deposit`, kernel floor and all: the GPU half of one record, two executors,
+ *   whose CPU half is `fluid_record_apply`. At most `FLUID_FORCING_EFFECTOR_LIMIT` kernels.
+ *
+ * ## Seams
+ *
+ * The enclosing shader defines, for every slot below its count:
+ * - `fn fluid_forcing_obstacle(slot: u32) -> FluidObstacleRecord` and
+ *   `fn fluid_forcing_obstacle_global(slot: u32) -> mat4x4<f32>`, the record and its node's `global`;
+ * - `fn fluid_forcing_effector(slot: u32) -> FluidEffectorRecord`, a world record (node 0, or brought
+ *   there by `fluid_effector_record_resolve`);
+ * - `fn shape_record_plane(index: u32) -> vec4<f32>`, the hull planes the obstacles name.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_fluid_forcing_cell = CodeChunk.from(
+    //language=WGSL
+    `
+const FLUID_FORCING_NONE: u32 = 0xffffffffu;
+
+fn fluid_forcing_world(corner: vec3<i32>, cell_size: f32, p: vec3<f32>) -> vec3<f32> {
+    return (vec3<f32>(corner) + p + vec3<f32>(0.5)) * cell_size;
+}
+
+fn fluid_forcing_solid(x: vec3<f32>, count: u32) -> u32 {
+    var found = FLUID_FORCING_NONE;
+
+    for (var slot = 0u; slot < FLUID_FORCING_OBSTACLE_LIMIT; slot++) {
+        if (slot >= count) {
+            break;
+        }
+
+        let record = fluid_forcing_obstacle(slot);
+
+        if (fluid_obstacle_record_signed_distance(record, fluid_forcing_obstacle_global(slot), x) <= record.inflation) {
+            found = slot;
+            break;
+        }
+    }
+
+    return found;
+}
+
+fn fluid_forcing_wall_velocity(slot: u32, x: vec3<f32>) -> vec3<f32> {
+    return fluid_obstacle_record_wall_velocity(fluid_forcing_obstacle(slot), fluid_forcing_obstacle_global(slot), x);
+}
+
+fn fluid_forcing_deposit(x: vec3<f32>, dt: f32, cell_size: f32, count: u32) -> vec3<f32> {
+    var sum = vec3<f32>(0.0);
+
+    for (var slot = 0u; slot < FLUID_FORCING_EFFECTOR_LIMIT; slot++) {
+        if (slot >= count) {
+            break;
+        }
+
+        sum += fluid_effector_record_deposit(fluid_forcing_effector(slot), x, dt, cell_size);
+    }
+
+    return sum;
+}
+`, [
+        chunk_fluid_forcing_constants,
+        FLUID_EFFECTOR_RECORD_STRUCT.declaration_chunk,
+        chunk_fluid_obstacle_record,
+        chunk_fluid_effector_record_deposit,
+    ]
+);

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

@@ -0,0 +1,28 @@
+/**
+ * The world boxes of the GPU fluid's LBVH leaves (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §10, L1),
+ * as pure functions of a record, its node's pose and the frame's numbers, which is what the leaf
+ * extraction runs per leaf:
+ *
+ * - `fluid_forcing_obstacle_box(record, global, dilation) -> FluidForcingBox`: an obstacle record's
+ *   solid region, `SDF ≤ inflation`, boxed under its node's world matrix: the record's local box
+ *   (`shape_record_local_half_extents`) turned by the node's rotation (its columns normalised, the
+ *   scale ignored, as the field ignores it) and the record's own, about the record's world origin,
+ *   grown by the inflation; then `dilation` more on the + sides, the finest cell of the frame's
+ *   cascades. A kind with no box (a plane) is every point, `±F32_MAX`.
+ * - `fluid_forcing_effector_box(record, sweep_time) -> FluidForcingBox`: a world effector record's
+ *   reach before the kernel floor: a push's ball `p ± R`; a wake's capsule over the longest step of the
+ *   frame's stepping cascades, `[p − v·sweep_time, p] ± R`; a swirl's segment `[p, p + axis·length] ± R`.
+ *   The floor (`2·h_c` of the cascade a brick belongs to) is the brick query's to add.
+ * - `fluid_forcing_box_clip(box, low, high) -> FluidForcingBox`: the box clamped into `[low, high]`,
+ *   corner by corner. A box inside is itself; one that straddles is its part inside; one wholly outside
+ *   collapses onto the clip box's surface, a box of zero extent on the axes it missed. Every result of
+ *   finite `low` and `high` is finite, ±F32_MAX and infinities included, so a plane, a kilometre-scale
+ *   heightmap box or a far row hands the Morton pass a finite centroid.
+ *
+ * `FluidForcingBox` is `{low, high}`, world metres.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_fluid_forcing_leaf: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_fluid_forcing_leaf.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_fluid_forcing_leaf.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/forcing/chunk_fluid_forcing_leaf.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,uCAFU,SAAS,CAmEjB;0BA5FwB,oCAAoC"}

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

@@ -0,0 +1,99 @@
+import { FLUID_EFFECTOR_RECORD_STRUCT } from "../../../../engine/physics/fluid/effector/record/FLUID_EFFECTOR_RECORD_STRUCT.js";
+import { FluidEffectorRecordKind } from "../../../../engine/physics/fluid/effector/record/FluidEffectorRecordKind.js";
+import { FLUID_OBSTACLE_RECORD_STRUCT } from "../../../../engine/physics/fluid/obstacle/FLUID_OBSTACLE_RECORD_STRUCT.js";
+import { chunk_quat_rotate_v3 } from "../../shader/chunk/geometry/quaternion/chunk_v3_apply_quat.js";
+import { F32_MAX_DEFINITION } from "../../shader/chunk/math/F32_MAX_DEFINITION.js";
+import { chunk_shape_record_local_bounds } from "../../shader/chunk/sdf/chunk_shape_record_local_bounds.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * The world boxes of the GPU fluid's LBVH leaves (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §10, L1),
+ * as pure functions of a record, its node's pose and the frame's numbers, which is what the leaf
+ * extraction runs per leaf:
+ *
+ * - `fluid_forcing_obstacle_box(record, global, dilation) -> FluidForcingBox`: an obstacle record's
+ *   solid region, `SDF ≤ inflation`, boxed under its node's world matrix: the record's local box
+ *   (`shape_record_local_half_extents`) turned by the node's rotation (its columns normalised, the
+ *   scale ignored, as the field ignores it) and the record's own, about the record's world origin,
+ *   grown by the inflation; then `dilation` more on the + sides, the finest cell of the frame's
+ *   cascades. A kind with no box (a plane) is every point, `±F32_MAX`.
+ * - `fluid_forcing_effector_box(record, sweep_time) -> FluidForcingBox`: a world effector record's
+ *   reach before the kernel floor: a push's ball `p ± R`; a wake's capsule over the longest step of the
+ *   frame's stepping cascades, `[p − v·sweep_time, p] ± R`; a swirl's segment `[p, p + axis·length] ± R`.
+ *   The floor (`2·h_c` of the cascade a brick belongs to) is the brick query's to add.
+ * - `fluid_forcing_box_clip(box, low, high) -> FluidForcingBox`: the box clamped into `[low, high]`,
+ *   corner by corner. A box inside is itself; one that straddles is its part inside; one wholly outside
+ *   collapses onto the clip box's surface, a box of zero extent on the axes it missed. Every result of
+ *   finite `low` and `high` is finite, ±F32_MAX and infinities included, so a plane, a kilometre-scale
+ *   heightmap box or a far row hands the Morton pass a finite centroid.
+ *
+ * `FluidForcingBox` is `{low, high}`, world metres.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_fluid_forcing_leaf = CodeChunk.from(
+    //language=WGSL
+    `
+struct FluidForcingBox {
+    low: vec3<f32>,
+    high: vec3<f32>,
+}
+
+fn fluid_forcing_obstacle_box(
+    record: ${FLUID_OBSTACLE_RECORD_STRUCT.wgsl_ref}, global: mat4x4<f32>, dilation: f32
+) -> FluidForcingBox {
+    if (!shape_record_local_bounded(record.shape_kind)) {
+        return FluidForcingBox(vec3<f32>(-F32_MAX), vec3<f32>(F32_MAX));
+    }
+
+    let local_extent = shape_record_local_half_extents(record.shape_kind, record.shape_parameters);
+
+    // the node's rotation: its columns normalised
+    let r0 = global[0].xyz * (1.0 / length(global[0].xyz));
+    let r1 = global[1].xyz * (1.0 / length(global[1].xyz));
+    let r2 = global[2].xyz * (1.0 / length(global[2].xyz));
+
+    // the record's local axes in the world, R·q·e
+    let q = record.pose_rotation;
+    let a0 = quat_rotate_v3(q, vec3<f32>(1.0, 0.0, 0.0));
+    let a1 = quat_rotate_v3(q, vec3<f32>(0.0, 1.0, 0.0));
+    let a2 = quat_rotate_v3(q, vec3<f32>(0.0, 0.0, 1.0));
+
+    let w0 = r0 * a0.x + r1 * a0.y + r2 * a0.z;
+    let w1 = r0 * a1.x + r1 * a1.y + r2 * a1.z;
+    let w2 = r0 * a2.x + r1 * a2.y + r2 * a2.z;
+
+    let t = record.pose_translation;
+    let centre = global[3].xyz + r0 * t.x + r1 * t.y + r2 * t.z;
+
+    let extent = abs(w0) * local_extent.x + abs(w1) * local_extent.y + abs(w2) * local_extent.z + vec3<f32>(record.inflation);
+
+    return FluidForcingBox(centre - extent, centre + extent + vec3<f32>(dilation));
+}
+
+fn fluid_forcing_effector_box(record: ${FLUID_EFFECTOR_RECORD_STRUCT.wgsl_ref}, sweep_time: f32) -> FluidForcingBox {
+    let reach = vec3<f32>(max(record.radius, 0.0));
+
+    var start = record.position;
+    var end = record.position;
+
+    if (record.kind == ${FluidEffectorRecordKind.SWEPT_CAPSULE}u) {
+        start = record.position - record.vector * sweep_time;
+    } else if (record.kind == ${FluidEffectorRecordKind.SWIRL}u) {
+        end = record.position + record.vector * record.length;
+    }
+
+    return FluidForcingBox(min(start, end) - reach, max(start, end) + reach);
+}
+
+fn fluid_forcing_box_clip(box: FluidForcingBox, low: vec3<f32>, high: vec3<f32>) -> FluidForcingBox {
+    return FluidForcingBox(clamp(box.low, low, high), clamp(box.high, low, high));
+}
+`, [
+        FLUID_OBSTACLE_RECORD_STRUCT.declaration_chunk,
+        FLUID_EFFECTOR_RECORD_STRUCT.declaration_chunk,
+        chunk_shape_record_local_bounds,
+        chunk_quat_rotate_v3,
+        F32_MAX_DEFINITION,
+    ]
+);

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

@@ -0,0 +1,29 @@
+/**
+ * The per-invocation decisions of a brick query (`shader_fluid_forcing_query`, Q1), as pure functions
+ * the emulator runs:
+ *
+ * - `fluid_forcing_brick_box(corner, cell_size, brick) -> array<f32, 6>`: the query box of brick
+ *   `brick` (in bricks) of a window whose world cell `corner` sits at window-local 0: its cells, world
+ *   cell `g` covering `[g·h, (g + 1)·h)`, grown by `FLUID_FORCING_QUERY_GROWTH_CELLS` cells on every
+ *   side, the kernel floor.
+ * - `fluid_forcing_obstacle_split(count, obstacle_leaf_count) -> u32`: how many of the first `count`
+ *   candidates, ascending, are obstacle leaves (below `obstacle_leaf_count`): a binary search over
+ *   them, eight steps, which a candidate list of at most 128 needs.
+ * - `fluid_forcing_survivor_header(obstacles, effectors) -> u32`: the counts a brick keeps, the low and
+ *   high 16 bits of its survivor header.
+ *
+ * Survivors are the lowest leaves, which are the lowest rows: the leaf list holds obstacle rows
+ * ascending and then effector rows ascending, so taking the first `FLUID_FORCING_OBSTACLE_LIMIT`
+ * obstacle candidates and the first `FLUID_FORCING_EFFECTOR_LIMIT` effector ones is "by row index",
+ * whatever order the traversal found them in, and stable under motion.
+ *
+ * ## Seam
+ *
+ * The enclosing shader defines `fn fluid_forcing_candidate(index: u32) -> u32`, the query's sorted
+ * candidate list.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_fluid_forcing_query_select: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_fluid_forcing_query_select.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_fluid_forcing_query_select.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/forcing/chunk_fluid_forcing_query_select.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,+CAFU,SAAS,CAuCjB;0BAlEwB,oCAAoC"}

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

@@ -0,0 +1,67 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_fluid_forcing_constants } from "./FLUID_FORCING.js";
+
+/**
+ * The per-invocation decisions of a brick query (`shader_fluid_forcing_query`, Q1), as pure functions
+ * the emulator runs:
+ *
+ * - `fluid_forcing_brick_box(corner, cell_size, brick) -> array<f32, 6>`: the query box of brick
+ *   `brick` (in bricks) of a window whose world cell `corner` sits at window-local 0: its cells, world
+ *   cell `g` covering `[g·h, (g + 1)·h)`, grown by `FLUID_FORCING_QUERY_GROWTH_CELLS` cells on every
+ *   side, the kernel floor.
+ * - `fluid_forcing_obstacle_split(count, obstacle_leaf_count) -> u32`: how many of the first `count`
+ *   candidates, ascending, are obstacle leaves (below `obstacle_leaf_count`): a binary search over
+ *   them, eight steps, which a candidate list of at most 128 needs.
+ * - `fluid_forcing_survivor_header(obstacles, effectors) -> u32`: the counts a brick keeps, the low and
+ *   high 16 bits of its survivor header.
+ *
+ * Survivors are the lowest leaves, which are the lowest rows: the leaf list holds obstacle rows
+ * ascending and then effector rows ascending, so taking the first `FLUID_FORCING_OBSTACLE_LIMIT`
+ * obstacle candidates and the first `FLUID_FORCING_EFFECTOR_LIMIT` effector ones is "by row index",
+ * whatever order the traversal found them in, and stable under motion.
+ *
+ * ## Seam
+ *
+ * The enclosing shader defines `fn fluid_forcing_candidate(index: u32) -> u32`, the query's sorted
+ * candidate list.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_fluid_forcing_query_select = CodeChunk.from(
+    //language=WGSL
+    `
+fn fluid_forcing_brick_box(corner: vec3<i32>, cell_size: f32, brick: vec3<u32>) -> array<f32, 6> {
+    let first = vec3<f32>(corner + vec3<i32>(brick * FLUID_FORCING_BRICK));
+
+    let low = (first - vec3<f32>(FLUID_FORCING_QUERY_GROWTH_CELLS)) * cell_size;
+    let high = (first + vec3<f32>(f32(FLUID_FORCING_BRICK) + FLUID_FORCING_QUERY_GROWTH_CELLS)) * cell_size;
+
+    return array<f32, 6>(low.x, low.y, low.z, high.x, high.y, high.z);
+}
+
+fn fluid_forcing_obstacle_split(count: u32, obstacle_leaf_count: u32) -> u32 {
+    var low = 0u;
+    var high = count;
+
+    for (var step = 0u; step < 8u; step++) {
+        if (low < high) {
+            let middle = (low + high) >> 1u;
+
+            if (fluid_forcing_candidate(middle) < obstacle_leaf_count) {
+                low = middle + 1u;
+            } else {
+                high = middle;
+            }
+        }
+    }
+
+    return low;
+}
+
+fn fluid_forcing_survivor_header(obstacles: u32, effectors: u32) -> u32 {
+    return obstacles | (effectors << 16u);
+}
+`, [
+        chunk_fluid_forcing_constants,
+    ]
+);

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

@@ -0,0 +1,38 @@
+/**
+ * Q3 of a tick, the forcing (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §10), for one stepping
+ * cascade: one workgroup of 4×4×4 for each brick its query listed, dispatched indirectly from Q2's
+ * command, the brick found by `folded_workgroup_index`.
+ *
+ * 1. **The survivors, posed:** the brick's obstacle records with their nodes' `global`, and its
+ *    effector records brought to the world (`fluid_effector_record_resolve` with the node's `global`
+ *    and `prev_global`), into workgroup memory; one barrier.
+ * 2. **The solid test** (`fluid_forcing_solid`) at the centre of every cell of the brick and the layer
+ *    before it on each axis (125 cells, two rounds), recording the solid's obstacle; a cell before the
+ *    window is fluid, as the step reads it. One barrier.
+ * 3. **Per cell:** its solid flags, `FLUID_FORCED_FLAG` with `FLUID_SOLID_FLAG` where solid; then each
+ *    of its −x, −y, −z faces, and the window's last cells their +boundary faces: a face with a solid
+ *    cell on either side is pinned, as every pass of the step will find it from the flags, and takes
+ *    the wall's velocity (`fluid_forcing_wall_velocity`, the solid cell's obstacle, the + side's when
+ *    both are) **in the cascade's persistent faces**, before the step reads them, with forcing 0;
+ *    any other face's forcing is the effectors' deposit over `dt_c` on `h_c`
+ *    (`fluid_forcing_deposit`).
+ *
+ * Writing the wall's velocity into the persistent faces is what makes a face that just became pinned
+ * carry the wall, never the fluid value it held: advection reads it as a boundary value and every pass
+ * carries it through. A brick listed only because its flags held an earlier tick's has no survivors
+ * and writes its cells' flags to 0, which is also what leaves no reader of this tick's forcing there.
+ *
+ * Per invocation: two solid tests of at most 24 fields (768 hull planes at worst), three to six faces
+ * of at most 16 kernels. Workgroup memory: 24 records and matrices, 16 records, 125 slots, 4,724
+ * bytes.
+ *
+ * Bindings: `settings` ({@link FLUID_FORCING_APPLY_STRUCT}); `fluid_database` and `scene_database`;
+ * `list`, `survivors` and `leaf_rows` from the tick's query and the frame's leaf list; `solid`, the
+ * cascade's flags; `forcing`, the tick's; `out_u`, `out_v`, `out_w`, the cascade's persistent faces.
+ * Seven storage buffers and three storage textures.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_fluid_forcing_apply: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_fluid_forcing_apply.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_fluid_forcing_apply.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/forcing/shader_fluid_forcing_apply.js"],"names":[],"mappings":"AAuPA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,yCAFU,aAAa,CAMpB;8BApR2B,+BAA+B"}