@woosh/meep-engine 3.24.0 → 3.25.0

package/src/engine/physics/cloth/playground/wind_build.js

@@ -0,0 +1,141 @@
+import { FluidField } from "../../fluid/FluidField.js";
+import { FluidSimulator } from "../../fluid/FluidSimulator.js";
+import { GlobalFluidEffector } from "../../fluid/effector/GlobalFluidEffector.js";
+import { FluidComponent } from "../../fluid/ecs/FluidComponent.js";
+
+/**
+ * # The wind tunnel the banner hangs in
+ *
+ * A real {@link FluidField} stepped by a real {@link FluidSimulator}, with a
+ * real {@link GlobalFluidEffector} driving the flow and a solid post standing in
+ * it — which is the whole of §10's argument made visible. Nothing here is a
+ * wind model: the wake behind the post is the incompressible projection's
+ * answer, and the cloth reads it through the same {@link FluidComponent} an
+ * ordinary scene would.
+ *
+ * At the grid a sixty-hertz page can afford the wake is a **steady** velocity
+ * deficit rather than a shedding street — measured at 18, 26 and 34 cells
+ * across, with and without damping and confinement, the air a banner's width
+ * downstream varies by under 0.03 m/s. That is the fluid solver's answer at
+ * this scale rather than the cloth's, and `MEASUREMENTS.md` §49 records it so
+ * the page is not read as promising something it does not do.
+ *
+ * The post is written straight into `FluidField#solid` rather than voxelised by
+ * `FluidObstacle`, because the page has no ECS to hang a `Collider` on and the
+ * obstacle is not what is being demonstrated. `FluidSimulator#step` refreshes
+ * the derived masks itself, so writing the cells is the whole of it.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+/**
+ * @typedef {object} WindTunnel
+ * @property {FluidComponent} component the volume, placed in world space
+ * @property {FluidSimulator} simulator
+ * @property {GlobalFluidEffector} effector the prevailing flow
+ * @property {Float32Array} world_to_grid
+ * @property {number} cell_size
+ * @property {number[]} resolution
+ */
+
+/**
+ * @param {object} options
+ * @param {number} options.cell_size metres
+ * @param {number[]} options.resolution cells along x, y, z
+ * @param {number[]} options.origin world position of cell (0,0,0)'s centre
+ * @returns {WindTunnel}
+ */
+export function build_wind_tunnel({ cell_size, resolution, origin }) {
+    const component = new FluidComponent();
+
+    component.cell_size = cell_size;
+    component.origin = origin.slice();
+
+    const field = new FluidField();
+
+    field.setResolution(resolution[0], resolution[1], resolution[2]);
+    field.build();
+
+    component.field = field;
+
+    const simulator = new FluidSimulator();
+
+    // A little damping so a gust decays rather than accumulating forever, and a
+    // little confinement so the wake keeps its eddies at this cell count. Both
+    // are the simulator's own documented knobs.
+    simulator.velocity_damping = 0.2;
+    simulator.vorticity_confinement = 0.35;
+
+    const effector = new GlobalFluidEffector();
+
+    // Wind plus drag is `GlobalFluidEffector`'s "prevailing wind" regime: the
+    // air relaxes toward `wind`, so the volume's far field *is* the ambient the
+    // cloth reads outside it, and a garment carried out of the volume does not
+    // walk into still air.
+    // Six per second, so the volume reaches nine tenths of the driving wind
+    // within a second and the slider means roughly what it says. Measured on
+    // this grid: 8.7 m/s of a 9 m/s wind in the free stream, and 3.1 m/s
+    // directly behind the post, which is the wake the banner hangs in.
+    effector.drag = 6;
+
+    return {
+        component,
+        simulator,
+        effector,
+        world_to_grid: new Float32Array(16),
+        cell_size,
+        resolution: resolution.slice()
+    };
+}
+
+/**
+ * Stand a solid post across the flow, upstream of the banner.
+ *
+ * @param {WindTunnel} tunnel
+ * @param {object} options
+ * @param {boolean} options.present
+ * @param {number} options.x world x of the post's centre
+ * @param {number} options.z world z of the post's centre
+ * @param {number} options.radius metres
+ * @returns {void}
+ */
+export function place_wind_post(tunnel, { present, x, z, radius }) {
+    const field = tunnel.component.field;
+
+    const solid = field.solid;
+
+    solid.fill(0);
+
+    if (!present) {
+        return;
+    }
+
+    const [res_x, res_y, res_z] = tunnel.resolution;
+
+    const cell_size = tunnel.cell_size;
+
+    const origin = tunnel.component.origin;
+
+    const radius_squared = radius * radius;
+
+    for (let k = 0; k < res_z; k++) {
+        const world_z = origin[2] + k * cell_size;
+
+        const dz = world_z - z;
+
+        for (let i = 0; i < res_x; i++) {
+            const dx = origin[0] + i * cell_size - x;
+
+            // A round post: solid where the cell centre is inside the circle in
+            // the flow's own plane, spanning the whole height.
+            if (dx * dx + dz * dz > radius_squared) {
+                continue;
+            }
+
+            for (let j = 0; j < res_y; j++) {
+                solid[k * res_x * res_y + j * res_x + i] = 1;
+            }
+        }
+    }
+}

package/src/engine/physics/cloth/playground/wind_main.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=wind_main.d.ts.map

package/src/engine/physics/cloth/playground/wind_main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wind_main.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/playground/wind_main.js"],"names":[],"mappings":""}