@woosh/meep-engine 3.55.0 → 3.57.0

package/src/shade/renderer/fluid/pressure/shader_fluid_mg_smooth.js

@@ -1,183 +1,219 @@
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { chunk_grid_tile_halo_f32 } from "../../shader/chunk/grid/chunk_grid_tile_halo_f32.js";
-import { GRID_TILE_WINDOW_STRUCT } from "../../shader/chunk/grid/GRID_TILE_WINDOW_STRUCT.js";
-import { chunk_is_finite } from "../../shader/chunk/math/chunk_is_finite.js";
-import { chunk_subgroup_atomic_add } from "../../shader/chunk/subgroup/chunk_subgroup_atomic_add.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import { atomic_u32, f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { chunk_fluid_mg_prolong } from "./chunk_fluid_mg_prolong.js";
-import { chunk_fluid_mg_relax } from "./chunk_fluid_mg_relax.js";
-import { chunk_fluid_pressure_ghost } from "./chunk_fluid_pressure_ghost.js";
-import { FLUID_MG_SMOOTH_SWEEP_LIMIT } from "./FLUID_MG.js";
-import { FLUID_MG_PASS_STRUCT } from "./FLUID_MG_PASS_STRUCT.js";
-
-const resources = new ShaderResourceSetDescriptor();
-
-resources.createGroup()
-    .addUniform('params', FLUID_MG_PASS_STRUCT)
-    .addStorageBuffer('input', WebGPUArray.from(f32), false)
-    .addStorageBuffer('output', WebGPUArray.from(f32), true)
-    .addStorageBuffer('rhs', WebGPUArray.from(f32), false)
-    .addStorageBuffer('words', WebGPUArray.from(u32), false)
-    .addStorageBuffer('coarse', WebGPUArray.from(f32), false)
-    .addStorageBuffer('nonfinite', WebGPUArray.from(atomic_u32), true)
-    .addStorageBuffer('ghost_pressure', WebGPUArray.from(f32), false);
-
-/**
- * The pressure V-cycle's smoother, and the SOR arm's (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §8): one
- * workgroup an 8×8×4 tile of a level, one invocation a cell.
- *
- * 1. The workgroup loads its tile and a one-cell halo from `input` into workgroup memory
- *    (`chunk_grid_tile_halo_f32`). A value that is not finite is loaded as 0. With `prolong`, every
- *    value inside the level is loaded with the coarser level's error added trilinearly
- *    (`chunk_fluid_mg_prolong`), which is the separate prolongation pass folded in. A cell beyond the
- *    level is its ghost: the cascade's Dirichlet pressure on the finest level, its parent's at the
- *    ghost cell's centre (`chunk_fluid_pressure_ghost`, from the step's `ghost_pressure`), 0 below it.
- * 2. `sweeps` times, for red then black, each cell of a colour in `colours` with a degree of freedom
- *    relaxes toward its equation (`chunk_fluid_mg_relax`) against its neighbours in the tile, the
- *    halo frozen. A colour reads only the other colour, so its cells update together, and a barrier
- *    separates the colours.
- * 3. Every cell inside the level is written to `output`, which is never `input`, so no tile reads what
- *    another wrote. With `prolong`, a cell with no degree of freedom is written as `input` held it (a
- *    non-finite value as 0): the prolongation leaves it alone.
- *
- * Both colours in one dispatch, as the V-cycle runs it, is only stable at ω = 1; the SOR arm runs one
- * colour a dispatch at ω > 1, which against a halo of the other colour is the global red-black update
- * exactly. The host asserts both.
- *
- * Each invocation counts its own cell's input and RHS when not finite, and the workgroup adds the counts
- * to `nonfinite[0]` with one atomic per subgroup.
- *
- * Dispatched as `ceil(size / (8, 8, 4))` workgroups. Workgroup memory: 2,400 bytes.
- */
-export const shader_fluid_mg_smooth = ComputeShader.from({
-    label: 'Fluid / pressure / smooth',
-    resources,
-    body: CodeChunk.from(
-        //language=WGSL
-        `
-const FLUID_MG_SOURCE_PRESSURE = 0u;
-const FLUID_MG_SOURCE_ERROR = 1u;
-const FLUID_MG_SMOOTH_SWEEP_LIMIT = ${FLUID_MG_SMOOTH_SWEEP_LIMIT}u;
-
-var<workgroup> tile_p: array<f32, GRID_TILE_HALO_CELLS>;
-
-fn fluid_mg_input_index(storage_cell: vec3<u32>) -> u32 {
-    return storage_cell.x + params.input_period.x * (storage_cell.y + params.input_period.y * storage_cell.z);
-}
-
-// the window-local cell an input storage cell holds: the inverse of grid_tile_window_storage
-fn fluid_mg_input_local(storage_cell: vec3<u32>) -> vec3<i32> {
-    let offset = vec3<i32>(storage_cell) - vec3<i32>(params.input_corner_storage);
-
-    return select(offset, offset + vec3<i32>(params.input_period), offset < vec3<i32>(0));
-}
-
-fn fluid_mg_read_coarse(cell: vec3<i32>) -> f32 {
-    let c = vec3<u32>(cell);
-
-    return coarse[c.x + params.coarse_size.x * (c.y + params.coarse_size.y * c.z)];
-}
-
-fn grid_tile_f32_fetch_inside(source: u32, storage_cell: vec3<u32>) -> f32 {
-    var value = input[fluid_mg_input_index(storage_cell)];
-
-    if (params.prolong != 0u) {
-        value += fluid_mg_prolong(fluid_mg_input_local(storage_cell), params.coarse_size);
-    }
-
-    return select(0.0, value, is_finite(value));
-}
-
-fn grid_tile_f32_fetch_outside(source: u32, world_cell: vec3<i32>) -> f32 {
-    if (source == FLUID_MG_SOURCE_PRESSURE) {
-        return fluid_pressure_ghost(world_cell);
-    }
-
-    return 0.0;
-}
-
-
-// where the finest level's window is, for its pressure ghosts
-fn fluid_pressure_ghost_corner() -> vec3<i32> {
-    return params.corner;
-}
-
-fn fluid_pressure_ghost_size() -> vec3<u32> {
-    return params.size;
-}
-fn tile_read_p(local: vec3<i32>) -> f32 {
-    return grid_tile_f32_read(&tile_p, local);
-}
-
-@compute @workgroup_size(8, 8, 4)
-fn main(
-    @builtin(workgroup_id) group: vec3<u32>,
-    @builtin(local_invocation_id) local_id: vec3<u32>,
-    @builtin(local_invocation_index) lane: u32,
-) {
-    let window = ${GRID_TILE_WINDOW_STRUCT.wgsl_ref}(params.corner, params.input_corner_storage, params.size, params.input_period);
-    let source = select(FLUID_MG_SOURCE_ERROR, FLUID_MG_SOURCE_PRESSURE, params.level == 0u);
-    let tile_origin = vec3<i32>(group) * GRID_TILE_SIZE;
-
-    grid_tile_f32_load(&tile_p, window, source, tile_origin, lane);
-
-    let local = vec3<i32>(local_id);
-    let cell = vec3<u32>(tile_origin + local);
-    let inside = all(cell < params.size);
-
-    var word = 0u;
-    var f = 0.0;
-    var held = 0.0;
-    var zeroed = 0u;
-
-    if (inside) {
-        let linear = cell.x + params.size.x * (cell.y + params.size.y * cell.z);
-        let rhs_value = rhs[linear];
-
-        held = input[fluid_mg_input_index(grid_tile_window_storage(vec3<i32>(cell), params.input_corner_storage, params.input_period))];
-        word = words[linear];
-        f = select(0.0, rhs_value, is_finite(rhs_value));
-        zeroed = select(0u, 1u, !is_finite(held)) + select(0u, 1u, !is_finite(rhs_value));
-    }
-
-    subgroup_atomic_add_u32(&nonfinite[0], zeroed);
-
-    let parity = (cell.x + cell.y + cell.z) & 1u;
-    let sweeps = min(params.sweeps, FLUID_MG_SMOOTH_SWEEP_LIMIT);
-
-    for (var sweep = 0u; sweep < sweeps; sweep++) {
-        for (var colour = 0u; colour < 2u; colour++) {
-            if (inside && word != 0u && parity == colour && ((params.colours >> colour) & 1u) != 0u) {
-                let stencil = fluid_mg_stencil(local, cell, params.size, word, params.edge_weight);
-
-                grid_tile_f32_write(&tile_p, local, fluid_mg_relax(tile_read_p(local), stencil, f, params.h2, params.omega));
-            }
-
-            workgroupBarrier();
-        }
-    }
-
-    if (inside) {
-        var value = tile_read_p(local);
-
-        if (params.prolong != 0u && word == 0u) {
-            value = select(0.0, held, is_finite(held));
-        }
-
-        let storage = grid_tile_window_storage(vec3<i32>(cell), params.output_corner_storage, params.output_period);
-
-        output[storage.x + params.output_period.x * (storage.y + params.output_period.y * storage.z)] = value;
-    }
-}
-`, [
-            chunk_grid_tile_halo_f32,
-            chunk_fluid_mg_relax,
-            chunk_fluid_mg_prolong,
-            chunk_fluid_pressure_ghost,
-            chunk_is_finite,
-            chunk_subgroup_atomic_add,
-        ]),
-});
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { chunk_grid_tile_halo_f32 } from "../../shader/chunk/grid/chunk_grid_tile_halo_f32.js";
+import { GRID_TILE_WINDOW_STRUCT } from "../../shader/chunk/grid/GRID_TILE_WINDOW_STRUCT.js";
+import { chunk_index_to_grid3d } from "../../shader/chunk/grid/chunk_index_to_grid3d.js";
+import { chunk_is_finite } from "../../shader/chunk/math/chunk_is_finite.js";
+import { chunk_subgroup_atomic_add } from "../../shader/chunk/subgroup/chunk_subgroup_atomic_add.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { atomic_u32, f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { chunk_fluid_mg_relax } from "./chunk_fluid_mg_relax.js";
+import { chunk_fluid_pressure_ghost } from "./chunk_fluid_pressure_ghost.js";
+import { FLUID_MG_SMOOTH_SWEEP_LIMIT } from "./FLUID_MG.js";
+import { FLUID_MG_PASS_STRUCT } from "./FLUID_MG_PASS_STRUCT.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .addUniform('params', FLUID_MG_PASS_STRUCT)
+    .addStorageBuffer('input', WebGPUArray.from(f32), false)
+    .addStorageBuffer('output', WebGPUArray.from(f32), true)
+    .addStorageBuffer('rhs', WebGPUArray.from(f32), false)
+    .addStorageBuffer('words', WebGPUArray.from(u32), false)
+    .addStorageBuffer('coarse', WebGPUArray.from(f32), false)
+    .addStorageBuffer('nonfinite', WebGPUArray.from(atomic_u32), true)
+    .addStorageBuffer('ghost_pressure', WebGPUArray.from(f32), false);
+
+/**
+ * The pressure V-cycle's smoother, and the SOR arm's (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §8): one
+ * workgroup an 8×8×4 tile of a level, one invocation a cell.
+ *
+ * 1. The workgroup loads its tile and a one-cell halo from `input` into workgroup memory
+ *    (`chunk_grid_tile_halo_f32`). A value that is not finite is loaded as 0. With `prolong`, the 6×6×4
+ *    coarse error neighbourhood covering the tile and its halo is first staged into workgroup memory
+ *    (`tile_coarse`, 144 cells, out-of-bounds coarse cells zeroed), and every value inside the level is
+ *    loaded with the coarser level's error added trilinearly (`fluid_mg_prolong_cached`), which is the
+ *    separate prolongation pass folded in. A cell beyond the level is its ghost: the cascade's Dirichlet
+ *    pressure on the finest level, its parent's at the ghost cell's centre (`chunk_fluid_pressure_ghost`,
+ *    from the step's `ghost_pressure`), 0 below it.
+ * 2. `sweeps` times, for red then black, each cell of a colour in `colours` with a degree of freedom
+ *    relaxes toward its equation (`chunk_fluid_mg_relax`) against its neighbours in the tile, the
+ *    halo frozen. A colour reads only the other colour, so its cells update together, and a barrier
+ *    separates the colours.
+ * 3. Every cell inside the level is written to `output`, which is never `input`, so no tile reads what
+ *    another wrote. With `prolong`, a cell with no degree of freedom is written as `input` held it (a
+ *    non-finite value as 0): the prolongation leaves it alone.
+ *
+ * Both colours in one dispatch, as the V-cycle runs it, is only stable at ω = 1; the SOR arm runs one
+ * colour a dispatch at ω > 1, which against a halo of the other colour is the global red-black update
+ * exactly. The host asserts both.
+ *
+ * Each invocation counts its own cell's input and RHS when not finite, and the workgroup adds the counts
+ * to `nonfinite[0]` with one atomic per subgroup.
+ *
+ * Dispatched as `ceil(size / (8, 8, 4))` workgroups. Workgroup memory: 2,976 bytes.
+ */
+export const shader_fluid_mg_smooth = ComputeShader.from({
+    label: 'Fluid / pressure / smooth',
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+const FLUID_MG_SOURCE_PRESSURE = 0u;
+const FLUID_MG_SOURCE_ERROR = 1u;
+const FLUID_MG_SMOOTH_SWEEP_LIMIT = ${FLUID_MG_SMOOTH_SWEEP_LIMIT}u;
+const FLUID_MG_COARSE_TILE_CELLS = 144u;
+
+var<workgroup> tile_p: array<f32, GRID_TILE_HALO_CELLS>;
+var<workgroup> tile_coarse: array<f32, FLUID_MG_COARSE_TILE_CELLS>;
+var<private> coarse_tile_origin: vec3<i32>;
+
+fn fluid_mg_input_index(storage_cell: vec3<u32>) -> u32 {
+    return storage_cell.x + params.input_period.x * (storage_cell.y + params.input_period.y * storage_cell.z);
+}
+
+// the window-local cell an input storage cell holds: the inverse of grid_tile_window_storage
+fn fluid_mg_input_local(storage_cell: vec3<u32>) -> vec3<i32> {
+    let offset = vec3<i32>(storage_cell) - vec3<i32>(params.input_corner_storage);
+
+    return select(offset, offset + vec3<i32>(params.input_period), offset < vec3<i32>(0));
+}
+
+fn fluid_mg_prolong_cached(fine: vec3<i32>) -> f32 {
+    let c = vec3<u32>((fine >> vec3<u32>(1u)) - coarse_tile_origin);
+    let base = i32(c.x + 6u * (c.y + 6u * c.z));
+    let dx = select(-1, 1, (fine.x & 1) != 0);
+    let dy = select(-6, 6, (fine.y & 1) != 0);
+    let dz = select(-36, 36, (fine.z & 1) != 0);
+
+    var v = 0.421875 * tile_coarse[u32(base)];
+    v += 0.140625 * tile_coarse[u32(base + dx)];
+    v += 0.140625 * tile_coarse[u32(base + dy)];
+    v += 0.046875 * tile_coarse[u32(base + dx + dy)];
+    v += 0.140625 * tile_coarse[u32(base + dz)];
+    v += 0.046875 * tile_coarse[u32(base + dx + dz)];
+    v += 0.046875 * tile_coarse[u32(base + dy + dz)];
+    v += 0.015625 * tile_coarse[u32(base + dx + dy + dz)];
+
+    return v;
+}
+
+fn grid_tile_f32_fetch_inside(source: u32, storage_cell: vec3<u32>) -> f32 {
+    var value = input[fluid_mg_input_index(storage_cell)];
+
+    if (params.prolong != 0u) {
+        value += fluid_mg_prolong_cached(fluid_mg_input_local(storage_cell));
+    }
+
+    return select(0.0, value, is_finite(value));
+}
+
+fn grid_tile_f32_fetch_outside(source: u32, world_cell: vec3<i32>) -> f32 {
+    if (source == FLUID_MG_SOURCE_PRESSURE) {
+        return fluid_pressure_ghost(world_cell);
+    }
+
+    return 0.0;
+}
+
+
+// where the finest level's window is, for its pressure ghosts
+fn fluid_pressure_ghost_corner() -> vec3<i32> {
+    return params.corner;
+}
+
+fn fluid_pressure_ghost_size() -> vec3<u32> {
+    return params.size;
+}
+fn tile_read_p(local: vec3<i32>) -> f32 {
+    return grid_tile_f32_read(&tile_p, local);
+}
+
+@compute @workgroup_size(8, 8, 4)
+fn main(
+    @builtin(workgroup_id) group: vec3<u32>,
+    @builtin(local_invocation_id) local_id: vec3<u32>,
+    @builtin(local_invocation_index) lane: u32,
+) {
+    let window = ${GRID_TILE_WINDOW_STRUCT.wgsl_ref}(params.corner, params.input_corner_storage, params.size, params.input_period);
+    let source = select(FLUID_MG_SOURCE_ERROR, FLUID_MG_SOURCE_PRESSURE, params.level == 0u);
+    let tile_origin = vec3<i32>(group) * GRID_TILE_SIZE;
+    coarse_tile_origin = (tile_origin >> vec3<u32>(1u)) - vec3<i32>(1);
+
+    if (params.prolong != 0u) {
+        if (lane < FLUID_MG_COARSE_TILE_CELLS) {
+            let coarse_local = vec3<i32>(index_to_grid3d(lane, vec2<u32>(6u, 6u)));
+            let coarse_cell = coarse_tile_origin + coarse_local;
+            var coarse_value = 0.0;
+
+            if (all(coarse_cell >= vec3<i32>(0)) && all(coarse_cell < vec3<i32>(params.coarse_size))) {
+                let c = vec3<u32>(coarse_cell);
+                coarse_value = coarse[c.x + params.coarse_size.x * (c.y + params.coarse_size.y * c.z)];
+            }
+
+            tile_coarse[lane] = coarse_value;
+        }
+
+        workgroupBarrier();
+    }
+
+    grid_tile_f32_load(&tile_p, window, source, tile_origin, lane);
+
+    let local = vec3<i32>(local_id);
+    let cell = vec3<u32>(tile_origin + local);
+    let inside = all(cell < params.size);
+
+    var word = 0u;
+    var f = 0.0;
+    var zeroed = 0u;
+
+    if (inside) {
+        let linear = cell.x + params.size.x * (cell.y + params.size.y * cell.z);
+        let rhs_value = rhs[linear];
+        let held = input[fluid_mg_input_index(grid_tile_window_storage(vec3<i32>(cell), params.input_corner_storage, params.input_period))];
+
+        word = words[linear];
+        let keep = select(rhs_value, held, word == 0u);
+        f = select(0.0, keep, is_finite(keep));
+        zeroed = select(0u, 1u, !is_finite(held)) + select(0u, 1u, !is_finite(rhs_value));
+    }
+
+    subgroup_atomic_add_u32(&nonfinite[0], zeroed);
+
+    let parity = (cell.x + cell.y + cell.z) & 1u;
+    let sweeps = min(params.sweeps, FLUID_MG_SMOOTH_SWEEP_LIMIT);
+
+    for (var sweep = 0u; sweep < sweeps; sweep++) {
+        for (var colour = 0u; colour < 2u; colour++) {
+            if (inside && word != 0u && parity == colour && ((params.colours >> colour) & 1u) != 0u) {
+                let stencil = fluid_mg_stencil(local, cell, params.size, word, params.edge_weight);
+
+                grid_tile_f32_write(&tile_p, local, fluid_mg_relax(tile_read_p(local), stencil, f, params.h2, params.omega));
+            }
+
+            workgroupBarrier();
+        }
+    }
+
+    if (inside) {
+        var value = tile_read_p(local);
+
+        if (params.prolong != 0u && word == 0u) {
+            value = f;
+        }
+
+        let storage = grid_tile_window_storage(vec3<i32>(cell), params.output_corner_storage, params.output_period);
+
+        output[storage.x + params.output_period.x * (storage.y + params.output_period.y * storage.z)] = value;
+    }
+}
+`, [
+            chunk_grid_tile_halo_f32,
+            chunk_index_to_grid3d,
+            chunk_fluid_mg_relax,
+            chunk_fluid_pressure_ghost,
+            chunk_is_finite,
+            chunk_subgroup_atomic_add,
+        ]),
+});

package/src/shade/renderer/fluid/publish/shader_fluid_wind_publish.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_fluid_wind_publish.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/publish/shader_fluid_wind_publish.js"],"names":[],"mappings":"AAWA;;;GAGG;AACH,4CAFU,MAAM,EAAE,CAEoD;AAqEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wCAFU,aAAa,CAMpB;8BAzH2B,+BAA+B"}
+{"version":3,"file":"shader_fluid_wind_publish.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/publish/shader_fluid_wind_publish.js"],"names":[],"mappings":"AAWA;;;GAGG;AACH,4CAFU,MAAM,EAAE,CAEoD;AAyFtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wCAFU,aAAa,CAMpB;8BA7I2B,+BAA+B"}