@woosh/meep-engine 3.68.0 → 3.70.0

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

@@ -12,9 +12,18 @@ import { chunk_fluid_forcing_constants } from "./FLUID_FORCING.js";
  *   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
@@ -52,6 +61,10 @@ fn fluid_forcing_solid(x: vec3<f32>, count: u32) -> u32 {
 
         let record = fluid_forcing_obstacle(slot);
 
+        if (record.drag != 0.0) {
+            continue;
+        }
+
         if (fluid_obstacle_record_signed_distance(record, fluid_forcing_obstacle_global(slot), x) <= record.inflation) {
             found = slot;
             break;
@@ -61,6 +74,50 @@ fn fluid_forcing_solid(x: vec3<f32>, count: u32) -> u32 {
     return found;
 }
 
+fn fluid_forcing_porous(x: vec3<f32>, cell_size: f32, count: u32) -> vec4<f32> {
+    var drag = 0.0;
+    var moving = vec3<f32>(0.0);
+
+    for (var slot = 0u; slot < FLUID_FORCING_OBSTACLE_LIMIT; slot++) {
+        if (slot >= count) {
+            break;
+        }
+
+        let record = fluid_forcing_obstacle(slot);
+
+        if (record.drag <= 0.0) {
+            continue;
+        }
+
+        let global = fluid_forcing_obstacle_global(slot);
+
+        // up four vertical lines from the cell's floor, a quarter of the cell in from its sides
+        var filled = 0.0;
+
+        for (var line = 0u; line < 4u; line++) {
+            let across = vec2<f32>(f32(line & 1u), f32(line >> 1u)) * 0.5 - vec2<f32>(0.25);
+            let foot = x + vec3<f32>(across.x, -0.5, across.y) * cell_size;
+
+            let span = fluid_obstacle_record_line_span(record, global, foot, vec3<f32>(0.0, 1.0, 0.0));
+
+            filled += max(min(span.y, cell_size) - max(span.x, 0.0), 0.0);
+        }
+
+        let part = record.drag * filled / (4.0 * cell_size);
+
+        if (part > 0.0) {
+            drag += part;
+            moving += fluid_obstacle_record_wall_velocity(record, global, x) * part;
+        }
+    }
+
+    if (drag <= 0.0) {
+        return vec4<f32>(0.0);
+    }
+
+    return vec4<f32>(drag, moving * (1.0 / drag));
+}
+
 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);
 }

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

@@ -10,7 +10,10 @@
  * 2. **The solid test** (`fluid_forcing_solid_prenorm`) 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
+ * 3. **Per cell:** its solid flags, `FLUID_FORCED_FLAG` with `FLUID_SOLID_FLAG` where solid, and
+ *    `FLUID_POROUS_FLAG` where a porous obstacle drags on a cell that is not solid, whose drag over the
+ *    step and the velocity it drags toward go into the forcing buffer's porous block
+ *    (`fluid_forcing_porous`, the drag times `dt_c`); 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

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

@@ -1 +1 @@
-{"version":3,"file":"shader_fluid_forcing_apply.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/forcing/shader_fluid_forcing_apply.js"],"names":[],"mappings":"AA4SA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,yCAFU,aAAa,CAMpB;8BA1U2B,+BAA+B"}
+{"version":3,"file":"shader_fluid_forcing_apply.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/forcing/shader_fluid_forcing_apply.js"],"names":[],"mappings":"AAmUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,yCAFU,aAAa,CAMpB;8BApW2B,+BAA+B"}