@pascal-app/core 1.0.6 → 1.1.0

package/dist/hooks/spatial-grid/spatial-grid-manager.js

@@ -8,7 +8,7 @@ import { getScaledDimensions, isLowProfileItemSurface } from '../../schema/index
 import { getWallTop } from '../../services/storey.js';
 import useLiveNodeOverrides, { getEffectiveNode } from '../../store/use-live-node-overrides.js';
 import useLiveTerrain from '../../store/use-live-terrain.js';
-import useLiveTransforms from '../../store/use-live-transforms.js';
+import useLiveTransforms, {} from '../../store/use-live-transforms.js';
 import useScene from '../../store/use-scene.js';
 import { computeWallSlabSupport, pointInPolygon, wallOverlapsPolygon, } from '../../systems/slab/slab-support.js';
 import { DEFAULT_WALL_THICKNESS } from '../../systems/wall/wall-footprint.js';
@@ -112,6 +112,25 @@ function expandIgnoredNodeIds(ignoreIds, nodes) {
     }
     return ignored;
 }
+/** The editor's store and its live previews: the singleton manager's source. */
+export const liveSpatialGridSource = {
+    nodes: () => useScene.getState().nodes,
+    overrides: () => useLiveNodeOverrides.getState().overrides,
+    transforms: () => useLiveTransforms.getState().transforms,
+    effective: getEffectiveNode,
+    terrain: () => useLiveTerrain.getState(),
+};
+const NO_PREVIEWS = new Map();
+/** A fixed set of nodes, without previews: what a detached scene's support queries read. */
+export function snapshotSpatialGridSource(nodes) {
+    return {
+        nodes,
+        overrides: () => NO_PREVIEWS,
+        transforms: () => NO_PREVIEWS,
+        effective: (node) => node,
+        terrain: () => undefined,
+    };
+}
 export class SpatialGridManager {
     floorGrids = new Map(); // levelId -> grid
     wallGrids = new Map(); // levelId -> wall grid
@@ -121,8 +140,93 @@ export class SpatialGridManager {
     ceilings = new Map(); // ceilingId -> ceiling data
     itemCeilingMap = new Map(); // itemId -> ceilingId (reverse lookup)
     cellSize;
-    constructor(cellSize = 0.5) {
+    source;
+    /**
+     * Item collision cells (floor, wall, ceiling) are only built when a placement query needs
+     * them: support queries read slabs, walls and ceilings. The editor's manager keeps them live.
+     */
+    itemsIndexed;
+    levelIdOf;
+    constructor(cellSize = 0.5, source = liveSpatialGridSource, options = {}) {
         this.cellSize = cellSize;
+        this.source = source;
+        this.levelIdOf = options.lazyItems ?? null;
+        this.itemsIndexed = !options.lazyItems;
+    }
+    ensureItemIndex() {
+        if (this.itemsIndexed || !this.levelIdOf)
+            return;
+        this.itemsIndexed = true;
+        const nodes = this.source.nodes();
+        for (const node of Object.values(nodes))
+            if (node.type === 'item')
+                this.handleNodeCreated(node, this.levelIdOf(node, nodes));
+    }
+    dropItemIndex() {
+        if (!this.levelIdOf || !this.itemsIndexed)
+            return;
+        this.itemsIndexed = false;
+        this.floorGrids.clear();
+        this.wallGrids.clear();
+        this.ceilingGrids.clear();
+        this.itemCeilingMap.clear();
+    }
+    /** Indexes `nodes` at once: support structures only, caches dropped once rather than per node. */
+    bulkLoad(nodes) {
+        const levelIdOf = this.levelIdOf;
+        if (!levelIdOf)
+            throw new Error('bulkLoad is for snapshot managers');
+        for (const node of Object.values(nodes)) {
+            if (node.type === 'slab')
+                this.getSlabMap(levelIdOf(node, nodes)).set(node.id, node);
+            else if (node.type === 'wall')
+                this.walls.set(node.id, node);
+            else if (node.type === 'ceiling')
+                this.ceilings.set(node.id, node);
+        }
+        this.renderedSlabPolygons.clear();
+        this.supportInputsRevision += 1;
+    }
+    /**
+     * Brings a snapshot manager from `before` to `after` in place. Returns false, changing nothing,
+     * when a rebuild is simpler and exact: many changes, or a node changing kind or level.
+     */
+    syncSnapshot(before, after) {
+        const levelIdOf = this.levelIdOf;
+        if (!levelIdOf)
+            return false;
+        const changed = [];
+        for (const id in after)
+            if (after[id] !== before[id])
+                changed.push(id);
+        for (const id in before)
+            if (!(id in after))
+                changed.push(id);
+        if (changed.length > 256)
+            return false;
+        for (const id of changed) {
+            const previous = before[id];
+            const next = after[id];
+            if (previous &&
+                next &&
+                (previous.type !== next.type || levelIdOf(previous, before) !== levelIdOf(next, after)))
+                return false;
+        }
+        for (const id of changed) {
+            const previous = before[id];
+            const next = after[id];
+            if (previous?.type === 'wall' || previous?.type === 'item' || previous?.type === 'ceiling')
+                this.dropItemIndex();
+            if (next?.type === 'wall' || next?.type === 'item' || next?.type === 'ceiling')
+                this.dropItemIndex();
+            if (previous && !next)
+                this.handleNodeDeleted(id, previous.type, levelIdOf(previous, before));
+            else if (!previous && next)
+                this.handleNodeCreated(next, levelIdOf(next, after));
+            else if (next)
+                this.handleNodeUpdated(next, levelIdOf(next, after));
+        }
+        return true;
     }
     getFloorGrid(levelId) {
         if (!this.floorGrids.has(levelId)) {
@@ -136,22 +240,30 @@ export class SpatialGridManager {
         }
         return this.wallGrids.get(levelId);
     }
+    getWall(wallId) {
+        const fromScene = this.source.nodes()[wallId];
+        if (fromScene && fromScene.type === 'wall') {
+            this.walls.set(wallId, fromScene);
+            return fromScene;
+        }
+        return this.walls.get(wallId);
+    }
     getWallLength(wallId) {
-        const wall = this.walls.get(wallId);
+        const wall = this.getWall(wallId);
         if (!wall)
             return 0;
         const dx = wall.end[0] - wall.start[0];
         const dy = wall.end[1] - wall.start[1];
-        return Math.sqrt(dx * dx + dy * dy);
+        return Math.hypot(dx, dy);
     }
-    getWallHeight(wallId) {
-        const wall = this.walls.get(wallId);
+    getWallHeight(wallId, t) {
+        const wall = this.getWall(wallId);
         if (!wall)
             return 0;
-        const nodes = useScene.getState().nodes;
+        const nodes = this.source.nodes();
         const levelId = resolveNodeLevelId(wall, nodes);
         const support = this.getSlabSupportForWall(levelId, wall.start, wall.end, wall.curveOffset ?? 0, wall.thickness, wall.supportSlabId ?? null, undefined, wall.supportOffset, wall.justification);
-        return getWallTop(wall, levelId, nodes, support.elevation) - support.elevation;
+        return getWallTop(wall, levelId, nodes, support.elevation, t) - support.elevation;
     }
     getCeilingGrid(ceilingId) {
         if (!this.ceilingGrids.has(ceilingId)) {
@@ -192,19 +304,19 @@ export class SpatialGridManager {
      * live-effective records and skip the rendered-polygon cache.
      */
     levelHasLivePreview(levelId) {
-        const nodes = useScene.getState().nodes;
+        const nodes = this.source.nodes();
         const structuralOnLevel = (id) => {
             const node = nodes[id];
             if (!node || (node.type !== 'slab' && node.type !== 'wall'))
                 return false;
             return resolveNodeLevelId(node, nodes) === levelId;
         };
-        const overrides = useLiveNodeOverrides.getState().overrides;
+        const overrides = this.source.overrides();
         for (const id of overrides.keys()) {
             if (structuralOnLevel(id))
                 return true;
         }
-        const transforms = useLiveTransforms.getState().transforms;
+        const transforms = this.source.transforms();
         for (const id of transforms.keys()) {
             if (structuralOnLevel(id))
                 return true;
@@ -221,8 +333,8 @@ export class SpatialGridManager {
      * never re-map, or the delta would apply twice.
      */
     effectiveSlabRecord(slab) {
-        let effective = getEffectiveNode(slab);
-        const live = useLiveTransforms.getState().get(slab.id);
+        let effective = this.source.effective(slab);
+        const live = this.source.transforms().get(slab.id);
         if (live) {
             const [dx, dy, dz] = live.position;
             if (dx !== 0 || dy !== 0 || dz !== 0) {
@@ -234,7 +346,7 @@ export class SpatialGridManager {
                 };
             }
         }
-        return liftedManualSlab(useScene.getState().nodes, effective);
+        return liftedManualSlab(this.source.nodes(), effective);
     }
     getRenderedSlabPolygon(levelId, slab) {
         const live = this.levelHasLivePreview(levelId);
@@ -250,7 +362,7 @@ export class SpatialGridManager {
         }
         const walls = this.getLevelWallNodes(levelId);
         const polygon = getRenderableSlabPolygon(slab, {
-            walls: live ? walls.map((wall) => getEffectiveNode(wall)) : walls,
+            walls: live ? walls.map((wall) => this.source.effective(wall)) : walls,
             siblingSlabs,
         });
         if (!live)
@@ -282,7 +394,7 @@ export class SpatialGridManager {
             // Rendered slab polygons adopt wall bands — a new wall can extend them.
             this.invalidateRenderedSlabPolygons(levelId);
         }
-        else if (node.type === 'item') {
+        else if (node.type === 'item' && this.itemsIndexed) {
             const item = node;
             if (item.asset.attachTo === 'wall' || item.asset.attachTo === 'wall-side') {
                 // Wall-attached item - use parentId as the wall ID
@@ -335,7 +447,7 @@ export class SpatialGridManager {
             this.walls.set(wall.id, wall);
             this.invalidateRenderedSlabPolygons(levelId);
         }
-        else if (node.type === 'item') {
+        else if (node.type === 'item' && this.itemsIndexed) {
             const item = node;
             if (item.asset.attachTo === 'wall' || item.asset.attachTo === 'wall-side') {
                 // Remove old placement and re-insert
@@ -399,7 +511,7 @@ export class SpatialGridManager {
             const removedItemIds = this.getWallGrid(levelId).removeWall(nodeId);
             return removedItemIds; // Caller can use this to delete the items from scene
         }
-        else if (nodeType === 'item') {
+        else if (nodeType === 'item' && this.itemsIndexed) {
             this.getFloorGrid(levelId).remove(nodeId);
             this.getWallGrid(levelId).removeByItemId(nodeId);
             // Also clean up ceiling grid
@@ -416,7 +528,7 @@ export class SpatialGridManager {
         return this.canPlaceOnFloorFootprints(levelId, [{ position, dimensions, rotation }], ignoreIds);
     }
     canPlaceOnFloorFootprints(levelId, footprints, ignoreIds) {
-        const nodes = useScene.getState().nodes;
+        const nodes = this.source.nodes();
         const ignoreSet = expandIgnoredNodeIds(ignoreIds, nodes);
         const draftBounds = footprints.map((footprint) => footprintBoundsXZ(footprint.position, footprint.dimensions, footprint.rotation[1] ?? 0));
         for (let i = 0; i < draftBounds.length; i += 1) {
@@ -474,18 +586,25 @@ export class SpatialGridManager {
      * @param ignoreIds - item IDs to ignore in collision check
      */
     canPlaceOnWall(levelId, wallId, localX, localY, dimensions, attachType = 'wall', side, ignoreIds) {
+        this.ensureItemIndex();
         const wallLength = this.getWallLength(wallId);
         if (wallLength === 0) {
             return { valid: false, conflictIds: [] };
         }
-        const wallHeight = this.getWallHeight(wallId);
+        const [itemWidth, itemHeight] = dimensions;
         // Convert local X position to parametric t (0-1)
         const tCenter = localX / wallLength;
-        const [itemWidth, itemHeight] = dimensions;
+        const halfW = itemWidth / wallLength / 2;
+        const tStart = Math.max(0, Math.min(1, tCenter - halfW));
+        const tEnd = Math.max(0, Math.min(1, tCenter + halfW));
+        const hStart = this.getWallHeight(wallId, tStart);
+        const hEnd = this.getWallHeight(wallId, tEnd);
+        const hCenter = this.getWallHeight(wallId, tCenter);
+        const wallHeight = Math.min(hStart, hEnd, hCenter);
         const baseResult = this.getWallGrid(levelId).canPlaceOnWall(wallId, wallLength, wallHeight, tCenter, itemWidth, localY, itemHeight, attachType, side, ignoreIds);
         if (!baseResult.valid)
             return baseResult;
-        const nodes = useScene.getState().nodes;
+        const nodes = this.source.nodes();
         const ignoreSet = new Set(ignoreIds ?? []);
         const draftBounds = {
             minX: localX - itemWidth / 2,
@@ -521,6 +640,7 @@ export class SpatialGridManager {
         };
     }
     getWallForItem(levelId, itemId) {
+        this.ensureItemIndex();
         return this.getWallGrid(levelId).getWallForItem(itemId);
     }
     /**
@@ -694,7 +814,7 @@ export class SpatialGridManager {
         // Sampled at the wall's own start point — the same anchor the mesh is
         // positioned at, so the resolver and the renderer cannot disagree about
         // where the ground is under this wall.
-        const levelBase = levelBaseElevationAt(useScene.getState().nodes, levelId, start[0], start[1]);
+        const levelBase = levelBaseElevationAt(this.source.nodes(), levelId, start[0], start[1]);
         const slabMap = this.slabsByLevel.get(levelId);
         if (!slabMap) {
             const elevation = levelBase + supportOffset;
@@ -709,7 +829,7 @@ export class SpatialGridManager {
         }
         const inputs = this.getSupportInputs(levelId, slabMap);
         const support = computeWallSlabSupport({ start, end, curveOffset, thickness, justification, supportOffset }, inputs.slabs, inputs.walls, preferredSlabId, maxElevation, levelBase, inputs.supportNodes, inputs.baseAt, inputs.terrainPlates.some((slab) => wallOverlapsPolygon({ start, end, curveOffset, thickness, justification }, slab.polygon))
-            ? useLiveTerrain.getState()
+            ? this.source.terrain()
             : undefined);
         return support;
     }
@@ -725,9 +845,9 @@ export class SpatialGridManager {
     supportInputsRevision = 0;
     supportInputs = new Map();
     getSupportInputs(levelId, slabMap) {
-        const nodes = useScene.getState().nodes;
-        const overrides = useLiveNodeOverrides.getState().overrides;
-        const transforms = useLiveTransforms.getState().transforms;
+        const nodes = this.source.nodes();
+        const overrides = this.source.overrides();
+        const transforms = this.source.transforms();
         const cached = this.supportInputs.get(levelId);
         if (cached &&
             cached.revision === this.supportInputsRevision &&
@@ -750,11 +870,11 @@ export class SpatialGridManager {
             for (const id of slab.zoneIds ?? []) {
                 const zone = nodes[id];
                 if (zone?.type === 'zone')
-                    supportNodes[id] = getEffectiveNode(zone);
+                    supportNodes[id] = this.source.effective(zone);
             }
         for (const node of Object.values(nodes))
             if (node.parentId === levelId && (node.type === 'separator' || node.type === 'zone'))
-                supportNodes[node.id] = getEffectiveNode(node);
+                supportNodes[node.id] = this.source.effective(node);
         for (const node of Object.values(nodes))
             if (node.type === 'site' || node.type === 'building' || node.type === 'level')
                 supportNodes[node.id] = node;
@@ -769,7 +889,7 @@ export class SpatialGridManager {
             baseAt: (x, z) => levelBaseElevationAt(nodes, levelId, x, z),
             slabs,
             supportNodes,
-            walls: this.getLevelWallNodes(levelId).map((wall) => getEffectiveNode(wall)),
+            walls: this.getLevelWallNodes(levelId).map((wall) => this.source.effective(wall)),
         };
         this.supportInputs.set(levelId, next);
         return next;
@@ -782,7 +902,7 @@ export class SpatialGridManager {
      */
     levelWallsCache = new WeakMap();
     getLevelWallNodes(levelId) {
-        const nodes = useScene.getState().nodes;
+        const nodes = this.source.nodes();
         let byLevel = this.levelWallsCache.get(nodes);
         if (!byLevel) {
             byLevel = new Map();
@@ -814,6 +934,7 @@ export class SpatialGridManager {
      * Validates that the footprint is within the ceiling polygon (but not in any holes) and doesn't overlap other ceiling items.
      */
     canPlaceOnCeiling(ceilingId, position, dimensions, rotation, ignoreIds) {
+        this.ensureItemIndex();
         const ceiling = this.ceilings.get(ceilingId);
         if (!ceiling || ceiling.polygon.length < 3) {
             return { valid: false, conflictIds: [] };
@@ -833,7 +954,7 @@ export class SpatialGridManager {
                 return { valid: false, conflictIds: [] };
             }
         }
-        const nodes = useScene.getState().nodes;
+        const nodes = this.source.nodes();
         const ignoreSet = new Set(ignoreIds ?? []);
         const [width, , depth] = dimensions;
         const yRot = rotation[1];
@@ -887,10 +1008,53 @@ export class SpatialGridManager {
 }
 // Singleton instance
 export const spatialGridManager = new SpatialGridManager();
+const activeGrids = [];
+/**
+ * The manager support queries read: the editor's singleton, or, inside `withSpatialGrid`, the one
+ * a detached scene builds from its own nodes (scene runtime).
+ */
+export function activeSpatialGrid() {
+    return activeGrids.at(-1)?.() ?? spatialGridManager;
+}
+export function withSpatialGrid(grid, run) {
+    activeGrids.push(grid);
+    try {
+        return run();
+    }
+    finally {
+        activeGrids.pop();
+    }
+}
+/** A manager indexed over `nodes()` as they are now, without previews. */
+export function createSnapshotSpatialGrid(nodes, levelIdOf) {
+    const grid = new SpatialGridManager(0.5, snapshotSpatialGridSource(nodes), {
+        lazyItems: levelIdOf,
+    });
+    grid.bulkLoad(nodes());
+    return grid;
+}
+const supportIndexes = new WeakMap();
+/**
+ * The support index of a store's saved nodes, kept per store and brought up to date in place on
+ * each use (`syncSnapshot`), rebuilt only when that is simpler: what reconciliation queries.
+ */
+export function supportIndexOf(store, levelIdOf) {
+    const nodes = store.getState().nodes;
+    const cached = supportIndexes.get(store);
+    if (cached?.nodes === nodes)
+        return cached.grid;
+    if (cached?.grid.syncSnapshot(cached.nodes, nodes)) {
+        cached.nodes = nodes;
+        return cached.grid;
+    }
+    const grid = createSnapshotSpatialGrid(() => store.getState().nodes, levelIdOf);
+    supportIndexes.set(store, { nodes, grid });
+    return grid;
+}
 /** Level-local Y where the rendered wall mesh begins. */
 export function getWallBaseElevationForNodes(wall, nodes) {
     const levelId = resolveNodeLevelId(wall, nodes);
-    return spatialGridManager.getSlabSupportForWall(levelId, wall.start, wall.end, wall.curveOffset ?? 0, wall.thickness, wall.supportSlabId ?? null, undefined, wall.supportOffset, wall.justification).elevation;
+    return activeSpatialGrid().getSlabSupportForWall(levelId, wall.start, wall.end, wall.curveOffset ?? 0, wall.thickness, wall.supportSlabId ?? null, undefined, wall.supportOffset, wall.justification).elevation;
 }
 /**
  * Effective (extruded) height of a wall resolved from a nodes record:
@@ -898,9 +1062,16 @@ export function getWallBaseElevationForNodes(wall, nodes) {
  * value always agrees with the rendered wall. One shared resolver for the
  * editor overlays (measurement label, action menu, side handles) that used
  * to copy this derivation locally.
+ *
+ * `t` (0 at the start, 1 at the end) picks a point on a sloped top. Without it
+ * the lower end answers: the height the whole wall clears, which is what
+ * plugins pinned to the public API (written before sloped tops) test against.
  */
-export function getWallEffectiveHeightForNodes(wall, nodes) {
+export function getWallEffectiveHeightForNodes(wall, nodes, t) {
     const levelId = resolveNodeLevelId(wall, nodes);
-    const support = spatialGridManager.getSlabSupportForWall(levelId, wall.start, wall.end, wall.curveOffset ?? 0, wall.thickness, wall.supportSlabId ?? null, undefined, wall.supportOffset, wall.justification);
-    return getWallTop(wall, levelId, nodes, support.elevation) - support.elevation;
+    const support = activeSpatialGrid().getSlabSupportForWall(levelId, wall.start, wall.end, wall.curveOffset ?? 0, wall.thickness, wall.supportSlabId ?? null, undefined, wall.supportOffset, wall.justification);
+    const top = t === undefined
+        ? Math.min(getWallTop(wall, levelId, nodes, support.elevation, 0), getWallTop(wall, levelId, nodes, support.elevation, 1))
+        : getWallTop(wall, levelId, nodes, support.elevation, t);
+    return top - support.elevation;
 }