@woosh/meep-engine 3.60.6 → 3.60.7

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

@@ -1,219 +1,221 @@
-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,
-        ]),
-});
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { chunk_grid3d_to_index } from "../../shader/chunk/grid/chunk_grid3d_to_index.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 grid3d_to_index(storage_cell, params.input_period.xy);
+}
+
+// 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(grid3d_to_index(c, vec2<u32>(6u, 6u)));
+    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[grid3d_to_index(c, params.coarse_size.xy)];
+            }
+
+            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 = grid3d_to_index(cell, params.size.xy);
+        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[grid3d_to_index(storage, params.output_period.xy)] = value;
+    }
+}
+`, [
+            chunk_grid3d_to_index,
+            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/query/GPUFluidQueries.d.ts

@@ -49,7 +49,7 @@ export class GPUFluidQueries {
      * @param {import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources} resources
      * @param {{encoder: import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext}} context
      */
-    static "__#283@#execute"(pass: object, resources: import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
+    static "__#285@#execute"(pass: object, resources: import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
         encoder: import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
     }): void;
     /**

package/src/shade/renderer/fow/shader_fog_of_war.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_fog_of_war.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/fow/shader_fog_of_war.js"],"names":[],"mappings":"AAgBA;;;GAGG;AACH,6CAqBsB;AA4KtB;;;;;;;;;;;GAWG;AACH,gCAFU,WAAW,CA0BlB;AAEH;;;;GAIG;AACH,mCAFU,2BAA2B,CAES;6BAlPjB,gCAAgC;4BAJjC,0BAA0B;4CACV,mDAAmD"}
+{"version":3,"file":"shader_fog_of_war.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/fow/shader_fog_of_war.js"],"names":[],"mappings":"AAkBA;;;GAGG;AACH,6CAqBsB;AA+JtB;;;;;;;;;;;GAWG;AACH,gCAFU,WAAW,CA0BlB;AAEH;;;;GAIG;AACH,mCAFU,2BAA2B,CAES;6BArOjB,gCAAgC;4BAJjC,0BAA0B;4CACV,mDAAmD"}

package/src/shade/renderer/fow/shader_fog_of_war.js

@@ -7,6 +7,8 @@ import { BlendState } from "../../descriptor/blend/BlendState.js";
 import { CAMERA_UNIFORM_STRUCT } from "../camera/CAMERA_UNIFORM_STRUCT.js";
 import { chunk_project_position_from_depth } from "../shader/chunk/camera/chunk_project_position_from_depth.js";
 import { chunk_mat4_extract_position } from "../shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
+import { chunk_gaussian } from "../shader/chunk/math/statistics/chunk_gaussian.js";
+import { chunk_interleaved_gradient_noise } from "../shader/chunk/noise/chunk_interleaved_gradient_noise.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 import { ImageShader } from "../shader/ImageShader.js";
 import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
@@ -72,8 +74,6 @@ const HALF_SAMPLES_Y = f32(SAMPLES_Y - 1) * 0.5;
 
 const SIGMA = vec2<f32>(${FOG_OF_WAR_BLUR_SIGMA}, ${FOG_OF_WAR_BLUR_SIGMA});
 
-const SIGMA_SQ_2 = SIGMA * SIGMA * 2.0;
-
 const TAP_SPACING = f32(${FOG_OF_WAR_BLUR_TAP_SPACING});
 
 /**
@@ -81,10 +81,6 @@ const TAP_SPACING = f32(${FOG_OF_WAR_BLUR_TAP_SPACING});
  */
 const MINIMUM_DEPTH = 1e-6;
 
-fn gaussian(sigma_sq_2: f32, x: f32) -> f32 {
-    return exp(-(x * x) / sigma_sq_2);
-}
-
 /**
  * The mask, smoothed. The fog grid is one texel per world cell, so an unsmoothed read is a grid of
  * squares — the blur is the look rather than an approximation of one.
@@ -97,11 +93,11 @@ fn sample_fog(uv: vec2<f32>) -> f32 {
 
     for (var iy = 0; iy < SAMPLES_Y; iy = iy + 1) {
         let y = f32(iy) - HALF_SAMPLES_Y;
-        let fy = gaussian(SIGMA_SQ_2.y, y);
+        let fy = gaussian(SIGMA.y, y);
 
         for (var ix = 0; ix < SAMPLES_X; ix = ix + 1) {
             let x = f32(ix) - HALF_SAMPLES_X;
-            let fx = gaussian(SIGMA_SQ_2.x, x);
+            let fx = gaussian(SIGMA.x, x);
 
             let weight = fx * fy;
 
@@ -119,15 +115,6 @@ fn sample_fog(uv: vec2<f32>) -> f32 {
     return accumulated / total;
 }
 
-/**
- * Interleaved gradient noise.
- *
- * @see Jimenez 2014, "Next Generation Post Processing in Call of Duty"
- */
-fn gradient_noise(coord: vec2<f32>) -> f32 {
-    return fract(52.9829189 * fract(dot(coord, vec2<f32>(0.06711056, 0.00583715))));
-}
-
 @fragment
 fn main(@builtin(position) coord: vec4<f32>) -> @location(0) vec4<f32> {
     let resolution = vec2<f32>(textureDimensions(tDepth).xy);
@@ -196,8 +183,8 @@ fn main(@builtin(position) coord: vec4<f32>) -> @location(0) vec4<f32> {
      colour scaled by it in the blend — so both are dithered, and the rgb noise is attenuated by
      alpha exactly as the rgb band amplitude is.
     */
-    let noise_a = gradient_noise(coord.xy) * (1.0 / 255.0) - (0.5 / 255.0);
-    let noise_rgb = gradient_noise(coord.xy + vec2<f32>(7.0, 13.0)) * (1.0 / 255.0) - (0.5 / 255.0);
+    let noise_a = interleaved_gradient_noise(coord.xy) * (1.0 / 255.0) - (0.5 / 255.0);
+    let noise_rgb = interleaved_gradient_noise(coord.xy + vec2<f32>(7.0, 13.0)) * (1.0 / 255.0) - (0.5 / 255.0);
 
     color.a = color.a + noise_a;
     color = vec4<f32>(color.rgb + vec3<f32>(noise_rgb), color.a);
@@ -208,6 +195,8 @@ fn main(@builtin(position) coord: vec4<f32>) -> @location(0) vec4<f32> {
         CAMERA_UNIFORM_STRUCT.declaration_chunk,
         chunk_project_position_from_depth,
         chunk_mat4_extract_position,
+        chunk_gaussian,
+        chunk_interleaved_gradient_noise,
     ]
 );
 

package/src/shade/renderer/geometry/sdf/GPUGeometrySDFManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUGeometrySDFManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/GPUGeometrySDFManager.js"],"names":[],"mappings":"AAsIA;;;;GAIG;AACH,uCAFU,MAAM,CAEuH;AAgDvI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH;IAyQI;;;OAGG;IACH,2CAFW,kBAAkB,EAS5B;IAxQD;;;;OAIG;IACH,aAAuB;IAEvB;;;;OAIG;IACH,iBAA2B;IAE3B;;;;OAIG;IACH,iBAA2B;IAuP3B;;;;OAIG;IACH,6BAEC;IAED;;;;;;OAMG;IACH,sBAHW,MAAM,cACN,MAAM,QAkChB;IAED;;OAEG;IACH,yBAEC;IAED;;OAEG;IACH,yBAEC;IAED;;;;;OAKG;IACH,gBAHW,mBAAmB,aACnB,OAAO,QAajB;IAiCD;;;;;OAKG;IACH,gBAHW,mBAAmB,aACnB,OAAO,QAqBjB;IAED;;OAEG;IACH,aAYC;IAED;;;;;OAKG;IACH,eAFW,mBAAmB,QAiB7B;IAED;;;;;;;;;;;;OAYG;IACH,aAHW,mBAAmB,UACnB,mBAAmB,QAwD7B;IAcD;;;;;OAKG;IACH,iBAHW,mBAAmB,GACjB,YAAY,CAaxB;IAED;;;;;;OAMG;IACH,qBAHW,mBAAmB,GACjB,OAAO,CAInB;IAED;;;;;OAKG;IACH,wBAHW,mBAAmB,GACjB,OAAO,CAInB;IAED;;;OAGG;IACH,8BAEC;IAED;;OAEG;IACH,6BAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,2BAUC;IAED;;;OAGG;IACH,6BAEC;IAED;;;OAGG;IACH,+BAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;;OAGG;IACH,4BAEC;IAED;;;OAGG;IACH,yBAIC;IAED;;;OAGG;IACH,6BAIC;IAED;;;OAGG;IACH,8EAIC;IAED;;;;;;OAMG;IACH,mCAOC;IAED;;OAEG;IACH,+BAcC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH;QAT+B,KAAK,EAAzB,UAAU;QACM,MAAM,EAAtB,MAAM;QACW,cAAc,GAA/B,MAAM;QAEoC,SAAS,GAAnD,0BAA0B,GAAC,IAAI;QAEG,iBAAiB,GAAnD,kBAAkB,GAAC,IAAI;aAuEjC;IAqjCD,gBAsBC;;CACJ;yBA1iEY,OAAO,8DAA8D,EAAE,UAAU;iCACjF,OAAO,0BAA0B,EAAE,kBAAkB;kCACrD,OAAO,2BAA2B,EAAE,mBAAmB;yCACvD,OAAO,uDAAuD,EAAE,0BAA0B;iCAC1F,OAAO,sCAAsC,EAAE,kBAAkB;gCAlBhB,4BAA4B;6BAQf,eAAe"}
+{"version":3,"file":"GPUGeometrySDFManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/GPUGeometrySDFManager.js"],"names":[],"mappings":"AAuIA;;;;GAIG;AACH,uCAFU,MAAM,CAEuH;AAgDvI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH;IAyQI;;;OAGG;IACH,2CAFW,kBAAkB,EAS5B;IAxQD;;;;OAIG;IACH,aAAuB;IAEvB;;;;OAIG;IACH,iBAA2B;IAE3B;;;;OAIG;IACH,iBAA2B;IAuP3B;;;;OAIG;IACH,6BAEC;IAED;;;;;;OAMG;IACH,sBAHW,MAAM,cACN,MAAM,QAkChB;IAED;;OAEG;IACH,yBAEC;IAED;;OAEG;IACH,yBAEC;IAED;;;;;OAKG;IACH,gBAHW,mBAAmB,aACnB,OAAO,QAajB;IAiCD;;;;;OAKG;IACH,gBAHW,mBAAmB,aACnB,OAAO,QAqBjB;IAED;;OAEG;IACH,aAYC;IAED;;;;;OAKG;IACH,eAFW,mBAAmB,QAiB7B;IAED;;;;;;;;;;;;OAYG;IACH,aAHW,mBAAmB,UACnB,mBAAmB,QAwD7B;IAcD;;;;;OAKG;IACH,iBAHW,mBAAmB,GACjB,YAAY,CAaxB;IAED;;;;;;OAMG;IACH,qBAHW,mBAAmB,GACjB,OAAO,CAInB;IAED;;;;;OAKG;IACH,wBAHW,mBAAmB,GACjB,OAAO,CAInB;IAED;;;OAGG;IACH,8BAEC;IAED;;OAEG;IACH,6BAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,2BAUC;IAED;;;OAGG;IACH,6BAEC;IAED;;;OAGG;IACH,+BAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;;OAGG;IACH,4BAEC;IAED;;;OAGG;IACH,yBAIC;IAED;;;OAGG;IACH,6BAIC;IAED;;;OAGG;IACH,8EAIC;IAED;;;;;;OAMG;IACH,mCAOC;IAED;;OAEG;IACH,+BAcC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH;QAT+B,KAAK,EAAzB,UAAU;QACM,MAAM,EAAtB,MAAM;QACW,cAAc,GAA/B,MAAM;QAEoC,SAAS,GAAnD,0BAA0B,GAAC,IAAI;QAEG,iBAAiB,GAAnD,kBAAkB,GAAC,IAAI;aAuEjC;IAojCD,gBAsBC;;CACJ;yBAziEY,OAAO,8DAA8D,EAAE,UAAU;iCACjF,OAAO,0BAA0B,EAAE,kBAAkB;kCACrD,OAAO,2BAA2B,EAAE,mBAAmB;yCACvD,OAAO,uDAAuD,EAAE,0BAA0B;iCAC1F,OAAO,sCAAsC,EAAE,kBAAkB;gCAnBhB,4BAA4B;6BAQf,eAAe"}

package/src/shade/renderer/geometry/sdf/GPUGeometrySDFManager.js

@@ -47,6 +47,7 @@ import { MESH_SDF_BRICK_TEXELS, MESH_SDF_BRICK_VOXELS, MeshSDFState } from "./ME
 import { MESH_SDF_SAMPLER } from "./MESH_SDF_RESOURCES.js";
 import { MESH_SDF_STRUCT } from "./MESH_SDF_STRUCT.js";
 import { MeshSDFLayout } from "./MeshSDFLayout.js";
+import { ceilPowerOfTwo } from "../../../../core/binary/operations/ceilPowerOfTwo.js";
 
 /**
  * @typedef {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} FrameGraph
@@ -1932,7 +1933,7 @@ export class GPUGeometrySDFManager {
      * A ring for twice the bricks of the largest geometry the cap allows, emptied.
      */
     #reset_ring() {
-        const capacity = 2 ** Math.ceil(Math.log2(2 * max_bricks_of_a_geometry(this.#max_bricks)));
+        const capacity = ceilPowerOfTwo(2 * max_bricks_of_a_geometry(this.#max_bricks));
 
         if (this.#ring === null || this.#ring_capacity !== capacity) {
             this.#ring?.destroy();
@@ -2069,11 +2070,7 @@ export class GPUGeometrySDFManager {
 
         buffer?.destroy();
 
-        let capacity = 64;
-
-        while (8 * capacity < size) {
-            capacity *= 2;
-        }
+        const capacity = Math.max(64, ceilPowerOfTwo(runs));
 
         return this.#create_buffer(name, 8 * capacity, GPUBufferUsage.COPY_DST);
     }
@@ -2085,6 +2082,9 @@ export class GPUGeometrySDFManager {
      * @returns {GPUBuffer}
      */
     #create_buffer(name, size, usage) {
+        // bound whole, as storage
+        assert.lessThanOrEqual(size, this.#device.limits.maxStorageBufferBindingSize, `${name} past maxStorageBufferBindingSize`);
+
         return this.#device.createBuffer(BufferDescriptor.fromJSON({
             label: `GPUGeometrySDFManager/${name}`,
             size,

package/src/shade/renderer/geometry/sdf/MeshSDFLayout.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MeshSDFLayout.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/MeshSDFLayout.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IACI;;;OAGG;IACH,QAFU,YAAY,CAEO;IAE7B;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,QAFU,UAAU,CAEO;IAE3B;;OAEG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,WAFU,OAAO,CAEC;IAElB;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;;OAIG;IACH,oBAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAMlB;IAED;;;OAGG;IACH,yBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,oBAHW,MAAM,GACJ,MAAM,CAUlB;IAED;;;;;;;OAOG;IACH,gBALW,UAAU,MAAM,CAAC,cACjB,MAAM,cACN,MAAM,GACJ,aAAa,CAuDzB;CACJ"}
+{"version":3,"file":"MeshSDFLayout.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/MeshSDFLayout.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IACI;;;OAGG;IACH,QAFU,YAAY,CAEO;IAE7B;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,QAFU,UAAU,CAEO;IAE3B;;OAEG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,WAFU,OAAO,CAEC;IAElB;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;;OAIG;IACH,oBAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAMlB;IAED;;;OAGG;IACH,yBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,oBAHW,MAAM,GACJ,MAAM,CAUlB;IAED;;;;;;;OAOG;IACH,gBALW,UAAU,MAAM,CAAC,cACjB,MAAM,cACN,MAAM,GACJ,aAAa,CAuDzB;CACJ"}

package/src/shade/renderer/geometry/sdf/MeshSDFLayout.js

@@ -1,5 +1,6 @@
 import { assert } from "../../../../core/assert.js";
 import { MESH_SDF_BAND_VOXELS, MESH_SDF_BRICK_VOXELS } from "./MESH_SDF.js";
+import { ceil_log2 } from "../../../../core/binary/operations/ceil_log2.js";
 
 /**
  * Where a geometry's sparse distance field sits and how it is cut (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md
@@ -142,7 +143,7 @@ export class MeshSDFLayout {
             longest = Math.max(longest, bricks);
         }
 
-        this.level_count = 1 + Math.ceil(Math.log2(longest));
+        this.level_count = 1 + ceil_log2(longest);
 
         let total = 0;