@woosh/meep-engine 3.56.0 → 3.58.0

package/src/shade/renderer/camera/orbital/README.md

@@ -1,6 +1,6 @@
 # Orbital camera (momentum)
 
-A drop-in replacement for the legacy [`../OrbitalCameraController.js`](../OrbitalCameraController.js)
+A drop-in replacement for the legacy orbital camera controller
 that makes orbit/pan **responsive while dragging** and **weighty on release** —
 the "throw" feel of Google Earth / Maps, not a spring.
 
@@ -49,13 +49,10 @@ the input adapter is tested by firing synthetic signals at injected fake devices
 independent coast, hold-still-no-throw, pole clamp, precision (no-momentum) mode,
 event→intent mapping.
 
-## Switching
+## Import
 
 ```js
-// before
-import { OrbitalCameraController } from "../../webgpu/renderer/camera/OrbitalCameraController.js";
-// after
-import { OrbitalCameraController } from "../../webgpu/renderer/camera/orbital/index.js";
+import { OrbitalCameraController } from "@woosh/meep-engine/src/shade/renderer/camera/orbital/index.js";
 ```
 
 Constructor `(camera, domElement)` and `look` / `from_transform` / `pan` /

package/src/shade/renderer/deferred/chunk_shade_standard_material_direct_restir.d.ts

@@ -1,5 +1,5 @@
 /**
- * ReSTIR DI variant of {@link chunk_shade_standard_material_direct_heavy}: same
+ * ReSTIR DI variant of {@link chunk_shade_standard_material_direct}: same
  * function name/signature so the deferred shader entry is identical, but the
  * brute-force point/spot froxel-cluster loop is replaced by a single lookup into
  * the ReSTIR-resolved radiance texture (`tRestirRadiance`, already

package/src/shade/renderer/deferred/chunk_shade_standard_material_direct_restir.js

@@ -7,7 +7,7 @@ import { chunk_shade_directional_lights } from "./chunk_shade_directional_lights
 import { RESTIR_RADIANCE_RESOURCE } from "../restir/di/RESTIR_RADIANCE_RESOURCE.js";
 
 /**
- * ReSTIR DI variant of {@link chunk_shade_standard_material_direct_heavy}: same
+ * ReSTIR DI variant of {@link chunk_shade_standard_material_direct}: same
  * function name/signature so the deferred shader entry is identical, but the
  * brute-force point/spot froxel-cluster loop is replaced by a single lookup into
  * the ReSTIR-resolved radiance texture (`tRestirRadiance`, already

package/src/shade/renderer/deferred/indirect/chunk_lpv_2d_cache_sample_irradiance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_lpv_2d_cache_sample_irradiance.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/indirect/chunk_lpv_2d_cache_sample_irradiance.js"],"names":[],"mappings":"AAeA,kDAaG;AAEH,kDAgDE;AAEF,6DAwBO;6BAvGsB,mCAAmC;0BAYtC,oCAAoC"}
+{"version":3,"file":"chunk_lpv_2d_cache_sample_irradiance.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/indirect/chunk_lpv_2d_cache_sample_irradiance.js"],"names":[],"mappings":"AAeA,kDAaG;AAEH,kDAgDE;AAEF,6DA2BO;6BA1GsB,mCAAmC;0BAYtC,oCAAoC"}

package/src/shade/renderer/deferred/indirect/chunk_lpv_2d_cache_sample_irradiance.js

@@ -97,6 +97,9 @@ fn lpv_2d_cache_sample_irradiance(
     );
         
     // TODO apply convolution to specular component as well, see https://github.com/TheRealMJP/BakingLab/blob/c3868af50d72afc13cdfe513a1e0c6a4fafdac8c/BakingLab/Mesh.hlsl#L336
+    if (coord.cell == INVALID_TET) {
+        return vec3(0.0);
+    }
     return lpv_mesh_interpolate_probe_irradiance(normal, coord.barycentric, coord.cell);
 }
 `, [

package/src/shade/renderer/deferred/indirect/chunk_lpv_sample_light.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_lpv_sample_light.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/indirect/chunk_lpv_sample_light.js"],"names":[],"mappings":"AAmCA;;GAEG;AACH,qCAFU,SAAS,CAsDjB;0BA9DwB,oCAAoC"}
+{"version":3,"file":"chunk_lpv_sample_light.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/indirect/chunk_lpv_sample_light.js"],"names":[],"mappings":"AAoCA;;GAEG;AACH,qCAFU,SAAS,CA0DjB;0BAnEwB,oCAAoC"}

package/src/shade/renderer/deferred/indirect/chunk_lpv_sample_light.js

@@ -26,7 +26,8 @@ import {
     chunk_sh3_color_get_radiance_with_GGX
 } from "../../shader/chunk/spherical_harmonics/chunk_sh3_color_get_radiance_with_GGX.js";
 import { chunk_sh3_convolve_with_GGX } from "../../shader/chunk/spherical_harmonics/chunk_sh3_convolve_with_GGX.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { INVALID_TET_DECLARATION } from "../../shader/chunk/light/lpv/INVALID_TET_DECLARATION.js";
 import { LPV_SAMPLE_COORDINATES } from "./chunk_lpv_2d_cache_sample_irradiance.js";
 import {
     LPV_ATLAS_RADIANCE_RESOURCE,
@@ -46,6 +47,9 @@ fn lpv_sample_light(
     roughness: f32,
 ) -> mat2x3<f32> {
     
+    if (coord.cell == INVALID_TET) {
+        return mat2x3(vec3(0.0), vec3(0.0));
+    }
     let radiance_sh = lpv_mesh_interpolation_probe_sh(
          coord.barycentric, coord.cell
     );
@@ -80,6 +84,7 @@ fn lpv_sample_light(
     );
 }
     `, [
+        INVALID_TET_DECLARATION,
         RECIPROCAL_PI_DECLARATION,
         LPV_SAMPLE_COORDINATES.declaration_chunk,
         chunk_lpv_mesh_interpolate_radiance_via_atlas,

package/src/shade/renderer/dynamic/shader_dynamic_mesh_avboit_splat.js

@@ -113,7 +113,7 @@ fn fs_main(in : DynamicMeshAVBOITVertexOut, @builtin(sample_mask) sample_mask :
 
     // in.clip is @builtin(position): .xy the low-resolution pixel
     let texel = vec2<u32>(in.clip.xy);
-    let column = (texel.y * warp.voxel_width + texel.x) * warp.physical_count;
+    let column = texel.y * warp.voxel_width + texel.x;
 
     // linear splat between the two slices around the fragment
     let c = p - 0.5;

package/src/shade/renderer/fluid/FluidCascadePlacement.d.ts

@@ -18,63 +18,21 @@ export const FLUID_CASCADE_HYSTERESIS: number;
  * @type {number}
  */
 export const FLUID_CASCADE_NEST_MARGIN: number;
-/**
- * Smallest window side, cells, that nests: a child covers half its parent, so the other half must
- * hold the margin on both sides, rounded out to the corner lattice.
- * @type {number}
- */
-export const FLUID_CASCADE_NEST_RESOLUTION_MIN: number;
-/**
- * What {@link FluidCascadePlacementplace } did.
- */
-export type FluidCascadePlacementResult = number;
-/**
- * What {@link FluidCascadePlacement#place} did.
- * @readonly
- * @enum {number}
- */
-export const FluidCascadePlacementResult: Readonly<{
-    /** The window held. */
-    Held: 0;
-    /** The window moved, and the rest of the stack stayed. */
-    Moved: 1;
-    /** The move would have left a child outside its parent: the whole stack was re-placed. */
-    Jumped: 2;
-}>;
 /**
  * Where the windows of a stack of fluid cascades are (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §7): the
  * CPU half of `GPUFluidCascadeStack`, on the CPU alone so that placement is pinned without a device.
  *
- * Cascade `c` has cells of `cell_size·2^c` and the same resolution N; its window is
- * `[corner, corner + N)` in its own cells, and world cell `g` of it covers `[g·h_c, (g + 1)·h_c)`, so
- * the lattices nest: child cells `2G` and `2G + 1` lie in parent cell `G`. Every corner change goes
- * through S0's window maths: {@link ClipmapWindowSet} places, `window_scroll_regions` (the stack's) says
- * what a move exposed, and storage wraps, so a window that moves keeps every cell it still holds.
- *
- * **Placement** ({@link place}), on a cascade's own step tick, coarsest first:
- * 1. the hysteretic rule (`ClipmapWindowSet#place`, corners in 4s, moved past 2.1 cells of the anchor);
- * 2. a jump check: if that leaves the cascade's window not inside its parent's, or its child's window
- *    not inside its own, the move is a jump and the **whole stack is re-placed**
- *    ({@link place_all});
- * 3. the nesting clamp (`ClipmapWindowSet#clamp_corner`): the corner is held so that its window keeps
- *    {@link FLUID_CASCADE_NEST_MARGIN} parent cells inside its parent's, and so that its child's
- *    window keeps the margin inside its own. Both ranges hold the corner it had, so both clamps
- *    together land in both.
- *
- * {@link place_all} places every cascade, coarsest first, by the hysteretic rule, and clamps each into
- * its parent: the first placement, and the answer to a jump.
- *
- * {@link begin} remembers every corner, so that after a tick's placements {@link moved} and
- * {@link previous_corner} say what to fill.
- *
- * Nothing here allocates once constructed.
+ * A {@link ClipmapCascadePlacement} with the fluid's rule: corners in {@link FLUID_CASCADE_CORNER_STEP}s,
+ * moved once the anchor is more than 2.1 cells from a window's centre, and every child
+ * {@link FLUID_CASCADE_NEST_MARGIN} parent cells inside its parent, which needs 32 cells an axis. The
+ * stack places a cascade on its own step tick, coarsest first.
  */
-export class FluidCascadePlacement {
+export class FluidCascadePlacement extends ClipmapCascadePlacement {
     /**
      * @param {object} options
      * @param {number} options.cascade_count 1 to 8
-     * @param {ArrayLike<number>} options.resolution cells on each axis, powers of two; at least
-     *   {@link FLUID_CASCADE_NEST_RESOLUTION_MIN} when there is more than one cascade
+     * @param {ArrayLike<number>} options.resolution cells on each axis, powers of two; at least 32 when
+     *   there is more than one cascade
      * @param {number} options.cell_size metres, cascade 0's
      */
     constructor({ cascade_count, resolution, cell_size }: {
@@ -82,61 +40,6 @@ export class FluidCascadePlacement {
         resolution: ArrayLike<number>;
         cell_size: number;
     });
-    /** @returns {number} */
-    get cascade_count(): number;
-    /** @returns {Readonly<Int32Array>} */
-    get resolution(): Readonly<Int32Array>;
-    /**
-     * Whether the stack has been placed.
-     * @returns {boolean}
-     */
-    get placed(): boolean;
-    /**
-     * A cascade's cell, metres: `cell_size·2^c`.
-     * @param {number} cascade
-     * @returns {number}
-     */
-    cell_size(cascade: number): number;
-    /**
-     * @param {number} cascade
-     * @param {number} axis
-     * @returns {number} the cascade's corner on the axis, in its own cells
-     */
-    corner(cascade: number, axis: number): number;
-    /**
-     * @param {number} cascade
-     * @param {number} axis
-     * @returns {number} the corner it had at the last {@link begin}
-     */
-    previous_corner(cascade: number, axis: number): number;
-    /**
-     * @param {number} cascade
-     * @returns {boolean} whether its corner moved since the last {@link begin}
-     */
-    moved(cascade: number): boolean;
-    /**
-     * Remember every corner: what {@link moved} and {@link previous_corner} compare with.
-     */
-    begin(): void;
-    /**
-     * Place every cascade, coarsest first, by the hysteretic rule, each child clamped into its parent.
-     *
-     * @param {number} x the anchor, world metres
-     * @param {number} y
-     * @param {number} z
-     */
-    place_all(x: number, y: number, z: number): void;
-    /**
-     * Place one cascade on its own step tick: the hysteretic rule, then the jump check, then the
-     * nesting clamp. Before the first {@link place_all} this places the whole stack.
-     *
-     * @param {number} cascade
-     * @param {number} x the anchor, world metres
-     * @param {number} y
-     * @param {number} z
-     * @returns {FluidCascadePlacementResult}
-     */
-    place(cascade: number, x: number, y: number, z: number): FluidCascadePlacementResult;
-    #private;
 }
+import { ClipmapCascadePlacement } from "../../../core/geom/clipmap/ClipmapCascadePlacement.js";
 //# sourceMappingURL=FluidCascadePlacement.d.ts.map

package/src/shade/renderer/fluid/FluidCascadePlacement.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FluidCascadePlacement.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/fluid/FluidCascadePlacement.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;;GAIG;AACH,uCAFU,MAAM,CAE4B;AAE5C;;;;;;GAMG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;;GAIG;AACH,gDAFU,MAAM,CAEoC;;;;0CAK1C,MAAM;AAHhB;;;;GAIG;AACH;IACI,uBAAuB;;IAEvB,0DAA0D;;IAE1D,0FAA0F;;GAE3F;AAgBH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IAkBI;;;;;;OAMG;IACH;QAL2B,aAAa,EAA7B,MAAM;QACqB,UAAU,EAArC,UAAU,MAAM,CAAC;QAED,SAAS,EAAzB,MAAM;OA2BhB;IAED,wBAAwB;IACxB,4BAEC;IAED,sCAAsC;IACtC,uCAEC;IAED;;;OAGG;IACH,sBAEC;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,gBAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,yBAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,OAAO,CAQnB;IAED;;OAEG;IACH,cAMC;IA2DD;;;;;;OAMG;IACH,aAJW,MAAM,KACN,MAAM,KACN,MAAM,QAyBhB;IAED;;;;;;;;;OASG;IACH,eANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,2BAA2B,CAwCvC;;CACJ"}
+{"version":3,"file":"FluidCascadePlacement.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/fluid/FluidCascadePlacement.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;;GAIG;AACH,uCAFU,MAAM,CAE4B;AAE5C;;;;;;GAMG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;;;;;;GAQG;AACH;IACI;;;;;;OAMG;IACH;QAL2B,aAAa,EAA7B,MAAM;QACqB,UAAU,EAArC,UAAU,MAAM,CAAC;QAED,SAAS,EAAzB,MAAM;OAahB;CACJ;wCAtDuC,uDAAuD"}

package/src/shade/renderer/fluid/FluidCascadePlacement.js

@@ -1,6 +1,5 @@
 import { assert } from "../../../core/assert.js";
-import { ClipmapWindowSet } from "../../../core/geom/clipmap/ClipmapWindowSet.js";
-import { isPowerOfTwo } from "../../../core/math/isPowerOfTwo.js";
+import { ClipmapCascadePlacement } from "../../../core/geom/clipmap/ClipmapCascadePlacement.js";
 
 /**
  * Cells a cascade's corner moves in: even for exact restriction, in 4s for the 4-cell bricks of
@@ -25,325 +24,33 @@ export const FLUID_CASCADE_HYSTERESIS = 0.1;
  */
 export const FLUID_CASCADE_NEST_MARGIN = 5;
 
-/**
- * Smallest window side, cells, that nests: a child covers half its parent, so the other half must
- * hold the margin on both sides, rounded out to the corner lattice.
- * @type {number}
- */
-export const FLUID_CASCADE_NEST_RESOLUTION_MIN = 32;
-
-/**
- * What {@link FluidCascadePlacement#place} did.
- * @readonly
- * @enum {number}
- */
-export const FluidCascadePlacementResult = Object.freeze({
-    /** The window held. */
-    Held: 0,
-    /** The window moved, and the rest of the stack stayed. */
-    Moved: 1,
-    /** The move would have left a child outside its parent: the whole stack was re-placed. */
-    Jumped: 2,
-});
-
-/**
- * Round down to a multiple of `step`.
- */
-function floor_to(value, step) {
-    return Math.floor(value / step) * step;
-}
-
-/**
- * Round up to a multiple of `step`.
- */
-function ceil_to(value, step) {
-    return Math.ceil(value / step) * step;
-}
-
 /**
  * Where the windows of a stack of fluid cascades are (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §7): the
  * CPU half of `GPUFluidCascadeStack`, on the CPU alone so that placement is pinned without a device.
  *
- * Cascade `c` has cells of `cell_size·2^c` and the same resolution N; its window is
- * `[corner, corner + N)` in its own cells, and world cell `g` of it covers `[g·h_c, (g + 1)·h_c)`, so
- * the lattices nest: child cells `2G` and `2G + 1` lie in parent cell `G`. Every corner change goes
- * through S0's window maths: {@link ClipmapWindowSet} places, `window_scroll_regions` (the stack's) says
- * what a move exposed, and storage wraps, so a window that moves keeps every cell it still holds.
- *
- * **Placement** ({@link place}), on a cascade's own step tick, coarsest first:
- * 1. the hysteretic rule (`ClipmapWindowSet#place`, corners in 4s, moved past 2.1 cells of the anchor);
- * 2. a jump check: if that leaves the cascade's window not inside its parent's, or its child's window
- *    not inside its own, the move is a jump and the **whole stack is re-placed**
- *    ({@link place_all});
- * 3. the nesting clamp (`ClipmapWindowSet#clamp_corner`): the corner is held so that its window keeps
- *    {@link FLUID_CASCADE_NEST_MARGIN} parent cells inside its parent's, and so that its child's
- *    window keeps the margin inside its own. Both ranges hold the corner it had, so both clamps
- *    together land in both.
- *
- * {@link place_all} places every cascade, coarsest first, by the hysteretic rule, and clamps each into
- * its parent: the first placement, and the answer to a jump.
- *
- * {@link begin} remembers every corner, so that after a tick's placements {@link moved} and
- * {@link previous_corner} say what to fill.
- *
- * Nothing here allocates once constructed.
+ * A {@link ClipmapCascadePlacement} with the fluid's rule: corners in {@link FLUID_CASCADE_CORNER_STEP}s,
+ * moved once the anchor is more than 2.1 cells from a window's centre, and every child
+ * {@link FLUID_CASCADE_NEST_MARGIN} parent cells inside its parent, which needs 32 cells an axis. The
+ * stack places a cascade on its own step tick, coarsest first.
  */
-export class FluidCascadePlacement {
-    /** @type {ClipmapWindowSet} */
-    #windows;
-
-    /** @type {Int32Array} */
-    #resolution = new Int32Array(3);
-
-    /** @type {number} */
-    #cell_size;
-
-    /** @type {number} */
-    #cascade_count;
-
-    /** Every cascade's corner at {@link begin}, x, y, z a cascade. @type {Int32Array} */
-    #previous;
-
-    #placed = false;
-
+export class FluidCascadePlacement extends ClipmapCascadePlacement {
     /**
      * @param {object} options
      * @param {number} options.cascade_count 1 to 8
-     * @param {ArrayLike<number>} options.resolution cells on each axis, powers of two; at least
-     *   {@link FLUID_CASCADE_NEST_RESOLUTION_MIN} when there is more than one cascade
+     * @param {ArrayLike<number>} options.resolution cells on each axis, powers of two; at least 32 when
+     *   there is more than one cascade
      * @param {number} options.cell_size metres, cascade 0's
      */
     constructor({ cascade_count, resolution, cell_size }) {
-        assert.isPositiveInteger(cascade_count, 'cascade_count');
         assert.lessThanOrEqual(cascade_count, 8, 'cascade_count');
-        assert.isFinite(cell_size, 'cell_size');
-        assert.greaterThan(cell_size, 0, 'cell_size');
-
-        for (let axis = 0; axis < 3; axis++) {
-            assert.isPositiveInteger(resolution[axis], 'resolution');
-            assert.ok(isPowerOfTwo(resolution[axis]), 'resolution is a power of two on each axis');
-            assert.ok(cascade_count === 1 || resolution[axis] >= FLUID_CASCADE_NEST_RESOLUTION_MIN, `cascades nest from ${FLUID_CASCADE_NEST_RESOLUTION_MIN} cells an axis`);
 
-            this.#resolution[axis] = resolution[axis];
-        }
-
-        this.#cascade_count = cascade_count;
-        this.#cell_size = cell_size;
-        this.#previous = new Int32Array(3 * cascade_count);
-
-        this.#windows = new ClipmapWindowSet({
-            level_count: cascade_count,
-            dimensions: 3,
-            size: this.#resolution,
+        super({
+            cascade_count,
+            resolution,
+            cell_size,
             step: FLUID_CASCADE_CORNER_STEP,
             hysteresis: FLUID_CASCADE_HYSTERESIS,
+            nest_margin: FLUID_CASCADE_NEST_MARGIN,
         });
     }
-
-    /** @returns {number} */
-    get cascade_count() {
-        return this.#cascade_count;
-    }
-
-    /** @returns {Readonly<Int32Array>} */
-    get resolution() {
-        return this.#resolution;
-    }
-
-    /**
-     * Whether the stack has been placed.
-     * @returns {boolean}
-     */
-    get placed() {
-        return this.#placed;
-    }
-
-    /**
-     * A cascade's cell, metres: `cell_size·2^c`.
-     * @param {number} cascade
-     * @returns {number}
-     */
-    cell_size(cascade) {
-        return this.#cell_size * 2 ** cascade;
-    }
-
-    /**
-     * @param {number} cascade
-     * @param {number} axis
-     * @returns {number} the cascade's corner on the axis, in its own cells
-     */
-    corner(cascade, axis) {
-        return this.#windows.corner(cascade, axis);
-    }
-
-    /**
-     * @param {number} cascade
-     * @param {number} axis
-     * @returns {number} the corner it had at the last {@link begin}
-     */
-    previous_corner(cascade, axis) {
-        return this.#previous[3 * cascade + axis];
-    }
-
-    /**
-     * @param {number} cascade
-     * @returns {boolean} whether its corner moved since the last {@link begin}
-     */
-    moved(cascade) {
-        const base = 3 * cascade;
-
-        return this.#previous[base] !== this.corner(cascade, 0)
-            || this.#previous[base + 1] !== this.corner(cascade, 1)
-            || this.#previous[base + 2] !== this.corner(cascade, 2);
-    }
-
-    /**
-     * Remember every corner: what {@link moved} and {@link previous_corner} compare with.
-     */
-    begin() {
-        for (let c = 0; c < this.#cascade_count; c++) {
-            for (let axis = 0; axis < 3; axis++) {
-                this.#previous[3 * c + axis] = this.#placed ? this.corner(c, axis) : 0;
-            }
-        }
-    }
-
-    /**
-     * The range of corners on one axis that keeps a child of corner `child` nested `margin` cells
-     * (its own) inside a parent of corner `parent`, both in the child's cells: `[lo, hi]`, on the
-     * corner lattice.
-     */
-    #nest_low(parent_in_child_cells, margin) {
-        return ceil_to(parent_in_child_cells + margin, FLUID_CASCADE_CORNER_STEP);
-    }
-
-    #nest_high(parent_in_child_cells, n, margin) {
-        return floor_to(parent_in_child_cells + 2 * n - n - margin, FLUID_CASCADE_CORNER_STEP);
-    }
-
-    /**
-     * Whether cascade `child`'s window lies inside cascade `child + 1`'s, margin or not.
-     */
-    #inside_parent(child) {
-        for (let axis = 0; axis < 3; axis++) {
-            const p = 2 * this.corner(child + 1, axis);
-            const c = this.corner(child, axis);
-            const n = this.#resolution[axis];
-
-            if (c < p || c + n > p + 2 * n) {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    /**
-     * Hold cascade `c` nested inside its parent, and its child nested inside it.
-     */
-    #clamp(c) {
-        const windows = this.#windows;
-        const margin = 2 * FLUID_CASCADE_NEST_MARGIN;
-
-        for (let axis = 0; axis < 3; axis++) {
-            const n = this.#resolution[axis];
-
-            if (c + 1 < this.#cascade_count) {
-                const p = 2 * this.corner(c + 1, axis);
-
-                windows.clamp_corner(c, axis, this.#nest_low(p, margin), this.#nest_high(p, n, margin));
-            }
-
-            if (c > 0) {
-                // the child's corner in this cascade's cells, and the range of corners that keep it nested
-                const child = this.corner(c - 1, axis);
-                const lo = ceil_to((child + margin - n) / 2, FLUID_CASCADE_CORNER_STEP);
-                const hi = floor_to((child - margin) / 2, FLUID_CASCADE_CORNER_STEP);
-
-                windows.clamp_corner(c, axis, lo, hi);
-            }
-        }
-    }
-
-    /**
-     * Place every cascade, coarsest first, by the hysteretic rule, each child clamped into its parent.
-     *
-     * @param {number} x the anchor, world metres
-     * @param {number} y
-     * @param {number} z
-     */
-    place_all(x, y, z) {
-        assert.isFinite(x, 'x');
-        assert.isFinite(y, 'y');
-        assert.isFinite(z, 'z');
-
-        const windows = this.#windows;
-        const margin = 2 * FLUID_CASCADE_NEST_MARGIN;
-
-        for (let c = this.#cascade_count - 1; c >= 0; c--) {
-            const h = this.cell_size(c);
-
-            windows.place(c, x / h, y / h, z / h);
-
-            if (c + 1 < this.#cascade_count) {
-                for (let axis = 0; axis < 3; axis++) {
-                    const p = 2 * this.corner(c + 1, axis);
-
-                    windows.clamp_corner(c, axis, this.#nest_low(p, margin), this.#nest_high(p, this.#resolution[axis], margin));
-                }
-            }
-        }
-
-        this.#placed = true;
-    }
-
-    /**
-     * Place one cascade on its own step tick: the hysteretic rule, then the jump check, then the
-     * nesting clamp. Before the first {@link place_all} this places the whole stack.
-     *
-     * @param {number} cascade
-     * @param {number} x the anchor, world metres
-     * @param {number} y
-     * @param {number} z
-     * @returns {FluidCascadePlacementResult}
-     */
-    place(cascade, x, y, z) {
-        assert.isNonNegativeInteger(cascade, 'cascade');
-        assert.lessThan(cascade, this.#cascade_count, 'cascade');
-        assert.isFinite(x, 'x');
-        assert.isFinite(y, 'y');
-        assert.isFinite(z, 'z');
-
-        if (!this.#placed) {
-            this.place_all(x, y, z);
-
-            return FluidCascadePlacementResult.Jumped;
-        }
-
-        const windows = this.#windows;
-        const h = this.cell_size(cascade);
-
-        const before_x = this.corner(cascade, 0);
-        const before_y = this.corner(cascade, 1);
-        const before_z = this.corner(cascade, 2);
-
-        windows.place(cascade, x / h, y / h, z / h);
-
-        const leaves_parent = cascade + 1 < this.#cascade_count && !this.#inside_parent(cascade);
-        const leaves_child = cascade > 0 && !this.#inside_parent(cascade - 1);
-
-        if (leaves_parent || leaves_child) {
-            this.place_all(x, y, z);
-
-            return FluidCascadePlacementResult.Jumped;
-        }
-
-        this.#clamp(cascade);
-
-        const moved = this.corner(cascade, 0) !== before_x
-            || this.corner(cascade, 1) !== before_y
-            || this.corner(cascade, 2) !== before_z;
-
-        return moved ? FluidCascadePlacementResult.Moved : FluidCascadePlacementResult.Held;
-    }
 }

package/src/shade/renderer/fluid/GPUFluidCascade.d.ts

@@ -110,8 +110,8 @@ export const GPU_FLUID_CASCADE_GROWTH_EXPONENT_LIMIT: number;
  * transients: the pass creates them in the frame graph, which pools them, so the steps of every
  * cascade of one resolution share one set of memory. The pressure solve keeps its level buffers itself (`GPUFluidPressureSolve`).
  *
- * At 64×32×64 a step dispatches the ghosts, 4 MAC passes, the solve's 4 weight passes and 10 a
- * V-cycle: 29 at {@link GPU_FLUID_CASCADE_V_CYCLES}, and the curl with confinement.
+ * At 64×32×64 a step dispatches the ghosts, 4 MAC passes, and 10 passes a
+ * V-cycle: 25 at {@link GPU_FLUID_CASCADE_V_CYCLES}, and the curl with confinement.
  *
  * A face with a solid cell on either side is pinned: every pass carries its value in A through, so A
  * holds the wall's velocity there. Whoever writes the solid flags writes that velocity too: the
@@ -143,7 +143,7 @@ export class GPUFluidCascade {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#266@#execute_restrict"(record: object, _resources: any, context: {
+    static "__#275@#execute_restrict"(record: object, _resources: any, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**
@@ -151,7 +151,7 @@ export class GPUFluidCascade {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#266@#execute_fill"(record: object, _resources: any, context: {
+    static "__#275@#execute_fill"(record: object, _resources: any, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**
@@ -159,7 +159,7 @@ export class GPUFluidCascade {
      * @param {import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources} resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#266@#execute"(record: object, resources: import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
+    static "__#275@#execute"(record: object, resources: import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**

package/src/shade/renderer/fluid/GPUFluidCascade.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUFluidCascade.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/fluid/GPUFluidCascade.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"GPUFluidCascade.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/fluid/GPUFluidCascade.js"],"names":[],"mappings":"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"}