@woosh/meep-engine 3.57.0 → 3.58.0

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

@@ -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/GPUFluidCascadeStack.d.ts

@@ -63,7 +63,7 @@ export class GPUFluidCascadeStack {
      * @param {*} _resources
      * @param {{encoder: import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext}} context
      */
-    static "__#268@#execute_publish"(pass: object, _resources: any, context: {
+    static "__#277@#execute_publish"(pass: object, _resources: any, context: {
         encoder: import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
     }): void;
     /**

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

@@ -90,19 +90,19 @@ export class GPUFluidForcing {
      * @param {number} clear_size bytes cleared from 0 when the pool reuses the buffer
      * @returns {BufferResourceDescriptor}
      */
-    static "__#269@#descriptor"(kept: BufferResourceDescriptor[], role: number, size: number, usage: number, clear_size: number): BufferResourceDescriptor;
+    static "__#278@#descriptor"(kept: BufferResourceDescriptor[], role: number, size: number, usage: number, clear_size: number): BufferResourceDescriptor;
     /**
      * @param {object} record
      * @param {FramePassResources} resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#269@#execute_extract"(record: object, resources: FramePassResources, context: {
+    static "__#278@#execute_extract"(record: object, resources: FramePassResources, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
-    static "__#269@#execute_clear"(record: any, _resources: any, context: any): void;
-    static "__#269@#execute_query"(record: any, resources: any, context: any): void;
-    static "__#269@#execute_command"(record: any, resources: any, context: any): void;
-    static "__#269@#execute_apply"(record: any, resources: any, context: any): void;
+    static "__#278@#execute_clear"(record: any, _resources: any, context: any): void;
+    static "__#278@#execute_query"(record: any, resources: any, context: any): void;
+    static "__#278@#execute_command"(record: any, resources: any, context: any): void;
+    static "__#278@#execute_apply"(record: any, resources: any, context: any): void;
     /**
      * @param {object} options
      * @param {GPUDevice} options.device

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

@@ -1 +1 @@
-{"version":3,"file":"shader_fluid_forcing_command.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/forcing/shader_fluid_forcing_command.js"],"names":[],"mappings":"AAQA;;;GAGG;AACH,0CAFU,MAAM,CAE6B;AAqC7C;;;;;;;;;GASG;AACH,2CAFU,aAAa,CAMpB;8BA7D2B,+BAA+B"}
+{"version":3,"file":"shader_fluid_forcing_command.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/forcing/shader_fluid_forcing_command.js"],"names":[],"mappings":"AAQA;;;GAGG;AACH,0CAFU,MAAM,CAE6B;AA+B7C;;;;;;;;;GASG;AACH,2CAFU,aAAa,CAMpB;8BAvD2B,+BAA+B"}

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

@@ -1,5 +1,5 @@
 import { COLLECTION_U32_STRUCT_READ } from "../../gpu_primitive/COLLECTION_U32_STRUCT_READ.js";
-import { WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION } from "../../gpu_primitive/indirect/WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION.js";
+import { chunk_folded_dispatch } from "../../gpu_primitive/indirect/chunk_folded_dispatch.js";
 import { ComputeShader } from "../../shader/ComputeShader.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
@@ -22,22 +22,14 @@ resources.createGroup()
 const body = CodeChunk.from(
     //language=WGSL
     `
-// the width chunk_folded_workgroup_index strides by
-const LIMIT = ${WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION}u;
-
-fn divide_round_up(value: u32, divisor: u32) -> u32 {
-    return (value + divisor - 1u) / divisor;
-}
-
 // a workgroup a listed brick, folded: x to the limit, then rows of x, then slices of x·y
 fn fluid_forcing_write_command(slot: u32, groups: u32) {
-    let rows = divide_round_up(groups, LIMIT);
-    let slices = divide_round_up(rows, LIMIT);
+    let folded = folded_dispatch(groups);
     let word = slot * ${FLUID_FORCING_COMMAND_WORDS}u;
 
-    commands[word] = min(groups, LIMIT);
-    commands[word + 1u] = min(max(rows, 1u), LIMIT);
-    commands[word + 2u] = max(slices, 1u);
+    commands[word] = folded.x;
+    commands[word + 1u] = folded.y;
+    commands[word + 2u] = folded.z;
 }
 
 @compute @workgroup_size(1, 1, 1)
@@ -45,7 +37,9 @@ fn main() {
     fluid_forcing_write_command(0u, list_0.count);
     fluid_forcing_write_command(1u, list_1.count);
 }
-`);
+`, [
+    chunk_folded_dispatch,
+]);
 
 /**
  * Q2 of a tick (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §10): the forcing's indirect commands, one

package/src/shade/renderer/fluid/pressure/GPUFluidPressureSolve.d.ts

@@ -41,7 +41,7 @@ export class GPUFluidPressureSolve {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#265@#execute"(data: {
+    static "__#274@#execute"(data: {
         solve: GPUFluidPressureSolve;
         arm: number;
         count: number;

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 "__#270@#execute"(pass: object, resources: import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
+    static "__#279@#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/geometry/BoxGeometry.d.ts

@@ -11,6 +11,5 @@ export class BoxGeometry extends MeshletGeometry {
      */
     constructor(width?: number, height?: number, depth?: number);
 }
-export { PlaneGeometry } from "./PlaneGeometry.js";
 import { MeshletGeometry } from "./MeshletGeometry.js";
 //# sourceMappingURL=BoxGeometry.d.ts.map

package/src/shade/renderer/geometry/BoxGeometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BoxGeometry.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/geometry/BoxGeometry.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH;IACI;;;;OAIG;IACH,oBAJW,MAAM,WACN,MAAM,UACN,MAAM,EAKhB;CACJ;;gCAlB+B,sBAAsB"}
+{"version":3,"file":"BoxGeometry.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/geometry/BoxGeometry.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH;IACI;;;;OAIG;IACH,oBAJW,MAAM,WACN,MAAM,UACN,MAAM,EAKhB;CACJ;gCAlB+B,sBAAsB"}

package/src/shade/renderer/geometry/BoxGeometry.js

@@ -18,12 +18,3 @@ export class BoxGeometry extends MeshletGeometry {
         meshlet_geometry_build_from_geometry(make_box_geometry(width, height, depth), this);
     }
 }
-
-export {
-    // The tag goes on the specifier, inside the braces: on the statement, TypeScript never sees it.
-    /**
-     * @deprecated `PlaneGeometry` moved to its own module, one class per file like every other
-     * primitive. Import {@link PlaneGeometry} from "./PlaneGeometry.js" instead.
-     */
-    PlaneGeometry
-} from "./PlaneGeometry.js";

package/src/shade/renderer/geometry/GPUGeometryManager.d.ts

@@ -42,10 +42,12 @@ export class GPUGeometryManager {
      */
     get blas(): GPUGeometryBVHManager;
     /**
+     * Sparse signed distance fields by geometry id, baked from the BLAS on request. Holds no device
+     * memory until something asks for a cache.
      *
      * @return {GPUGeometrySDFManager}
      */
-    get sdf(): import("./sdf/GPUGeometrySDFManager.js").GPUGeometrySDFManager;
+    get sdf(): GPUGeometrySDFManager;
     /**
      *
      * @return {number} in bytes
@@ -151,8 +153,8 @@ export class GPUGeometryManager {
 }
 export type ShadeGPUCommandContext = import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
 export type MeshletGeometry = import("./MeshletGeometry.js").MeshletGeometry;
-export type GPUGeometrySDFManager = import("./sdf/GPUGeometrySDFManager.js").GPUGeometrySDFManager;
 import { GPUGeometryMetadata } from "./GPUGeometryMetadata.js";
 import { GPUMeshletManager } from "./meshlet/GPUMeshletManager.js";
 import { GPUGeometryBVHManager } from "./bvh/GPUGeometryBVHManager.js";
+import { GPUGeometrySDFManager } from "./sdf/GPUGeometrySDFManager.js";
 //# sourceMappingURL=GPUGeometryManager.d.ts.map

package/src/shade/renderer/geometry/GPUGeometryManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUGeometryManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/geometry/GPUGeometryManager.js"],"names":[],"mappings":"AAmBA;;;;GAIG;AACH;IAiKI;;;OAGG;IACH,+BAUC;IAzKD;;;OAGG;IACH,iBAFU,YAAU,IAAI,CAED;IAsDvB;;;OAGG;IACH,4GAEC;IAED;;;;OAIG;IACH,8BAA0B;IAE1B;;;;OAIG;IACH,uBAAsB;IAOtB;;;OAGG;IACH,kCAEC;IAwBD;;;OAGG;IACH,kCAEC;IAGD;;;OAGG;IACH,0EAEC;IAED;;;OAGG;IACH,+BAiBC;IAkBD;;;;OAIG;IACH,qBAHW,mBAAmB,GAClB,MAAM,CAMjB;IAED;;;;OAIG;IACH,cAHW,eAAe,GACd,OAAO,CAIlB;IAGD;;;;OAIG;IACH,cAHW,eAAe,GACb,OAAO,CAwEnB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,2BAPW,eAAe,GACb,mBAAmB,CAmC/B;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,uBAHW,mBAAmB,GACjB,OAAO,CAkBnB;IAED;;;;;;;OAOG;IACH,uBAHW,eAAe,GACb,mBAAmB,GAAC,SAAS,CAIzC;IAED;;;;OAIG;IACH,iBAHW,eAAe,GACb,OAAO,CAuCnB;IAyBD,gBAUC;IAED;;;;;;OAMG;IACH,qBANW,sBAAsB,QAuChC;IAmDD,cAqCC;IAED,0CAWC;;CAuFJ;qCAjsBY,OAAO,wCAAwC,EAAE,sBAAsB;8BACvE,OAAO,sBAAsB,EAAE,eAAe;oCAC9C,OAAO,gCAAgC,EAAE,qBAAqB;oCANvC,0BAA0B;kCAC5B,gCAAgC;sCAH5B,gCAAgC"}
+{"version":3,"file":"GPUGeometryManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/geometry/GPUGeometryManager.js"],"names":[],"mappings":"AAmBA;;;;GAIG;AACH;IAwKI;;;OAGG;IACH,+BAWC;IAjLD;;;OAGG;IACH,iBAFU,YAAU,IAAI,CAED;IAsDvB;;;OAGG;IACH,4GAEC;IAED;;;;OAIG;IACH,8BAA0B;IAE1B;;;;OAIG;IACH,uBAAsB;IAOtB;;;OAGG;IACH,kCAEC;IAwBD;;;OAGG;IACH,kCAEC;IAQD;;;;;OAKG;IACH,iCAEC;IAED;;;OAGG;IACH,+BAiBC;IAmBD;;;;OAIG;IACH,qBAHW,mBAAmB,GAClB,MAAM,CAMjB;IAED;;;;OAIG;IACH,cAHW,eAAe,GACd,OAAO,CAIlB;IAGD;;;;OAIG;IACH,cAHW,eAAe,GACb,OAAO,CAwEnB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,2BAPW,eAAe,GACb,mBAAmB,CAmC/B;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,uBAHW,mBAAmB,GACjB,OAAO,CAmBnB;IAED;;;;;;;OAOG;IACH,uBAHW,eAAe,GACb,mBAAmB,GAAC,SAAS,CAIzC;IAED;;;;OAIG;IACH,iBAHW,eAAe,GACb,OAAO,CAwCnB;IAyBD,gBAWC;IAED;;;;;;OAMG;IACH,qBANW,sBAAsB,QAuChC;IAmDD,cAqCC;IAED,0CAWC;;CAuFJ;qCA3sBY,OAAO,wCAAwC,EAAE,sBAAsB;8BACvE,OAAO,sBAAsB,EAAE,eAAe;oCANvB,0BAA0B;kCAC5B,gCAAgC;sCAH5B,gCAAgC;sCAIhC,gCAAgC"}

package/src/shade/renderer/geometry/GPUGeometryManager.js

@@ -8,11 +8,11 @@ import { GPUGeometryBVHManager } from "./bvh/GPUGeometryBVHManager.js";
 import { GEOMETRY_METADATA_STRUCT } from "./GEOMETRY_METADATA_STRUCT.js";
 import { GPUGeometryMetadata } from "./GPUGeometryMetadata.js";
 import { GPUMeshletManager } from "./meshlet/GPUMeshletManager.js";
+import { GPUGeometrySDFManager } from "./sdf/GPUGeometrySDFManager.js";
 
 /**
  * @typedef {import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext} ShadeGPUCommandContext
  * @typedef {import("./MeshletGeometry.js").MeshletGeometry} MeshletGeometry
- * @typedef {import("./sdf/GPUGeometrySDFManager.js").GPUGeometrySDFManager} GPUGeometrySDFManager
  */
 
 const WORDS_PER_MEGABYTE = 1024 * 1024 / 4;
@@ -153,11 +153,18 @@ export class GPUGeometryManager {
 
 
     /**
+     * @type {GPUGeometrySDFManager}
+     */
+    #sdf;
+
+    /**
+     * Sparse signed distance fields by geometry id, baked from the BLAS on request. Holds no device
+     * memory until something asks for a cache.
      *
      * @return {GPUGeometrySDFManager}
      */
     get sdf() {
-        throw new Error("Not implemented");
+        return this.#sdf;
     }
 
     /**
@@ -191,6 +198,7 @@ export class GPUGeometryManager {
         this.#device = device;
         this.#blas = new GPUGeometryBVHManager(device);
         this.#meshlets = new GPUMeshletManager({ device });
+        this.#sdf = new GPUGeometrySDFManager(device, this);
 
         this.buffer_metadata = device.createBuffer(BufferDescriptor.fromJSON({
             label: "GPUGeometryContext/metadata",
@@ -388,6 +396,7 @@ export class GPUGeometryManager {
         this.#unfollow_batch(metadata);
         this.#meshlets.remove_batch(metadata.meshlets);
         this.#blas.remove(metadata);
+        this.#sdf.forget(metadata);
 
         // without this the released clone's row stays addressable with stale data until an
         // unrelated add() rebuilds the table — the same reason `remove` sets it
@@ -440,6 +449,7 @@ export class GPUGeometryManager {
             this.#meshlets.remove_batch(metadata.meshlets);
         }
         this.#blas.remove(metadata);
+        this.#sdf.forget(metadata);
 
         // rebuild the GPU metadata table without this entry — without the dirty flag the
         // removed geometry's row stayed addressable with stale data until an unrelated add()
@@ -483,6 +493,7 @@ export class GPUGeometryManager {
 
         this.#meshlets.destroy();
         this.#blas.destroy();
+        this.#sdf.destroy();
 
         this.__needs_update = true;
     }

package/src/shade/renderer/geometry/Geometry.js

@@ -15,7 +15,7 @@ import {
     geometry_compute_vertex_normals_unindexed
 } from "../../../engine/graphics/geometry/buffered/geometry_compute_vertex_normals_unindexed.js";
 import { optional_clone } from "../../../core/model/object/optional_clone.js";
-import { optional_equality } from "../../../core/model/object/optional_equality.js";
+import { objectsEqual } from "../../../core/function/objectsEqual.js";
 import { optional_hash } from "../../../core/model/object/optional_hash.js";
 import { Attribute } from "./Attribute.js";
 import { build_tangent_from_normal } from "./normals/build_tangent_from_normal.js";
@@ -170,7 +170,7 @@ export class Geometry {
         }
 
         return this.name === other.name
-            && optional_equality(this.index, other.index)
+            && objectsEqual(this.index, other.index)
             && isArrayEqual(this.attributes, other.attributes)
             ;
 

package/src/shade/renderer/geometry/blas_from_meshlets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"blas_from_meshlets.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/geometry/blas_from_meshlets.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,4EAJW,MAAM,gBACN,YAAY,GACV,WAAW,CA+BvB"}
+{"version":3,"file":"blas_from_meshlets.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/geometry/blas_from_meshlets.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,4EAJW,MAAM,gBACN,YAAY,GACV,WAAW,CAyCvB"}

package/src/shade/renderer/geometry/blas_from_meshlets.js

@@ -20,6 +20,10 @@ export function blas_from_meshlets(
     assert.isNonNegativeInteger(primitive_count, 'primitive_count');
     assert.isArrayLike(bounding_box, 'bounding_box');
 
+    if (primitive_count === 0 || meshlets.count === 0) {
+        return new ArrayBuffer(0);
+    }
+
     const bvh2 = new BVH();
 
     meshlet_batch_to_bvh({
@@ -29,12 +33,18 @@ export function blas_from_meshlets(
         primitive_count,
     });
 
-    const compressed = new ArrayBuffer(8 * 4 * bvh2.node_capacity);
+    assert.equal(bvh2.size, bvh2.node_capacity, 'bvh2 must be trimmed so size matches node_capacity');
+
+    if (bvh2.size === 0) {
+        return new ArrayBuffer(0);
+    }
+
+    const compressed = new ArrayBuffer(8 * 4 * bvh2.size);
 
     bvh2_compress(
         compressed, 0,
         bvh2.data_buffer, 0,
-        bvh2.node_capacity
+        bvh2.size
     );