@pascal-app/core 0.1.3

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

@@ -0,0 +1,466 @@
+import { SpatialGrid } from './spatial-grid';
+import { WallSpatialGrid } from './wall-spatial-grid';
+// ============================================================================
+// GEOMETRY HELPERS
+// ============================================================================
+/**
+ * Point-in-polygon test using ray casting algorithm.
+ */
+export function pointInPolygon(px, pz, polygon) {
+    let inside = false;
+    const n = polygon.length;
+    for (let i = 0, j = n - 1; i < n; j = i++) {
+        const xi = polygon[i][0], zi = polygon[i][1];
+        const xj = polygon[j][0], zj = polygon[j][1];
+        if ((zi > pz) !== (zj > pz) && px < ((xj - xi) * (pz - zi)) / (zj - zi) + xi) {
+            inside = !inside;
+        }
+    }
+    return inside;
+}
+/**
+ * Compute the 4 XZ footprint corners of an item given its position, dimensions, and Y rotation.
+ */
+function getItemFootprint(position, dimensions, rotation, inset = 0) {
+    const [x, , z] = position;
+    const [w, , d] = dimensions;
+    const yRot = rotation[1];
+    const halfW = Math.max(0, w / 2 - inset);
+    const halfD = Math.max(0, d / 2 - inset);
+    const cos = Math.cos(yRot);
+    const sin = Math.sin(yRot);
+    return [
+        [x + (-halfW * cos + halfD * sin), z + (-halfW * sin - halfD * cos)],
+        [x + (halfW * cos + halfD * sin), z + (halfW * sin - halfD * cos)],
+        [x + (halfW * cos - halfD * sin), z + (halfW * sin + halfD * cos)],
+        [x + (-halfW * cos - halfD * sin), z + (-halfW * sin + halfD * cos)],
+    ];
+}
+/**
+ * Test if two line segments (a1->a2) and (b1->b2) intersect.
+ */
+function segmentsIntersect(ax1, az1, ax2, az2, bx1, bz1, bx2, bz2) {
+    const cross = (ox, oz, ax, az, bx, bz) => (ax - ox) * (bz - oz) - (az - oz) * (bx - ox);
+    const d1 = cross(bx1, bz1, bx2, bz2, ax1, az1);
+    const d2 = cross(bx1, bz1, bx2, bz2, ax2, az2);
+    const d3 = cross(ax1, az1, ax2, az2, bx1, bz1);
+    const d4 = cross(ax1, az1, ax2, az2, bx2, bz2);
+    if (((d1 > 0 && d2 < 0) || (d1 < 0 && d2 > 0)) &&
+        ((d3 > 0 && d4 < 0) || (d3 < 0 && d4 > 0))) {
+        return true;
+    }
+    // Collinear touching cases
+    const onSeg = (px, pz, qx, qz, rx, rz) => Math.min(px, qx) <= rx && rx <= Math.max(px, qx) &&
+        Math.min(pz, qz) <= rz && rz <= Math.max(pz, qz);
+    if (d1 === 0 && onSeg(bx1, bz1, bx2, bz2, ax1, az1))
+        return true;
+    if (d2 === 0 && onSeg(bx1, bz1, bx2, bz2, ax2, az2))
+        return true;
+    if (d3 === 0 && onSeg(ax1, az1, ax2, az2, bx1, bz1))
+        return true;
+    if (d4 === 0 && onSeg(ax1, az1, ax2, az2, bx2, bz2))
+        return true;
+    return false;
+}
+/**
+ * Test if a line segment intersects any edge of a polygon.
+ */
+function segmentIntersectsPolygon(sx1, sz1, sx2, sz2, polygon) {
+    const n = polygon.length;
+    for (let i = 0; i < n; i++) {
+        const j = (i + 1) % n;
+        if (segmentsIntersect(sx1, sz1, sx2, sz2, polygon[i][0], polygon[i][1], polygon[j][0], polygon[j][1])) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Test if an item's footprint overlaps with a polygon.
+ * Checks: any item corner inside polygon, or any polygon vertex inside item AABB, or edges intersect.
+ */
+export function itemOverlapsPolygon(position, dimensions, rotation, polygon, inset = 0) {
+    const corners = getItemFootprint(position, dimensions, rotation, inset);
+    // Check if any item corner is inside the polygon
+    for (const [cx, cz] of corners) {
+        if (pointInPolygon(cx, cz, polygon))
+            return true;
+    }
+    // Check if any polygon vertex is inside the item footprint
+    // (handles case where slab is fully inside a large item)
+    for (const [px, pz] of polygon) {
+        if (pointInPolygon(px, pz, corners))
+            return true;
+    }
+    // Check if any item edge intersects any polygon edge
+    for (let i = 0; i < 4; i++) {
+        const j = (i + 1) % 4;
+        if (segmentIntersectsPolygon(corners[i][0], corners[i][1], corners[j][0], corners[j][1], polygon))
+            return true;
+    }
+    return false;
+}
+/**
+ * Check if wall segment (a) is substantially on polygon edge segment (b).
+ * Returns true only if BOTH endpoints of the wall are on or very close to the edge.
+ * This prevents walls that just touch one point from being detected.
+ */
+function segmentsCollinearAndOverlap(ax1, az1, ax2, az2, bx1, bz1, bx2, bz2) {
+    const EPSILON = 1e-6;
+    // Cross product to check collinearity
+    const cross1 = (ax2 - ax1) * (bz1 - az1) - (az2 - az1) * (bx1 - ax1);
+    const cross2 = (ax2 - ax1) * (bz2 - az1) - (az2 - az1) * (bx2 - ax1);
+    if (Math.abs(cross1) > EPSILON || Math.abs(cross2) > EPSILON) {
+        return false; // Not collinear
+    }
+    // Check if a point is on segment b
+    const onSegment = (px, pz, qx, qz, rx, rz) => Math.min(px, qx) - EPSILON <= rx && rx <= Math.max(px, qx) + EPSILON &&
+        Math.min(pz, qz) - EPSILON <= rz && rz <= Math.max(pz, qz) + EPSILON;
+    // BOTH endpoints of wall (a) must be on edge (b) for substantial overlap
+    const a1OnB = onSegment(bx1, bz1, bx2, bz2, ax1, az1);
+    const a2OnB = onSegment(bx1, bz1, bx2, bz2, ax2, az2);
+    return a1OnB && a2OnB;
+}
+/**
+ * Test if a wall segment overlaps with a polygon.
+ * A wall is considered to overlap if:
+ * - Its midpoint is inside the polygon (wall crosses through)
+ * - At least one endpoint is inside (wall partially or fully in slab)
+ * - It's collinear with and overlaps a polygon edge (wall on slab boundary)
+ *
+ * Note: A wall with just one endpoint touching the edge but the rest outside
+ * is NOT considered overlapping (adjacent only).
+ */
+export function wallOverlapsPolygon(start, end, polygon) {
+    const startInside = pointInPolygon(start[0], start[1], polygon);
+    const endInside = pointInPolygon(end[0], end[1], polygon);
+    // At least one endpoint strictly inside the polygon
+    if (startInside || endInside)
+        return true;
+    // Check if midpoint is inside (catches walls crossing through)
+    const midX = (start[0] + end[0]) / 2;
+    const midZ = (start[1] + end[1]) / 2;
+    if (pointInPolygon(midX, midZ, polygon))
+        return true;
+    // Check if the wall is collinear with and overlaps any polygon edge
+    const n = polygon.length;
+    for (let i = 0; i < n; i++) {
+        const j = (i + 1) % n;
+        const [p1x, p1z] = polygon[i];
+        const [p2x, p2z] = polygon[j];
+        if (segmentsCollinearAndOverlap(start[0], start[1], end[0], end[1], p1x, p1z, p2x, p2z)) {
+            return true;
+        }
+    }
+    return false;
+}
+export class SpatialGridManager {
+    cellSize;
+    floorGrids = new Map(); // levelId -> grid
+    wallGrids = new Map(); // levelId -> wall grid
+    walls = new Map(); // wallId -> wall data (for length calculations)
+    slabsByLevel = new Map(); // levelId -> (slabId -> slab)
+    ceilingGrids = new Map(); // ceilingId -> grid
+    ceilings = new Map(); // ceilingId -> ceiling data
+    itemCeilingMap = new Map(); // itemId -> ceilingId (reverse lookup)
+    constructor(cellSize = 0.5) {
+        this.cellSize = cellSize;
+    }
+    getFloorGrid(levelId) {
+        if (!this.floorGrids.has(levelId)) {
+            this.floorGrids.set(levelId, new SpatialGrid({ cellSize: this.cellSize }));
+        }
+        return this.floorGrids.get(levelId);
+    }
+    getWallGrid(levelId) {
+        if (!this.wallGrids.has(levelId)) {
+            this.wallGrids.set(levelId, new WallSpatialGrid());
+        }
+        return this.wallGrids.get(levelId);
+    }
+    getWallLength(wallId) {
+        const wall = this.walls.get(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);
+    }
+    getWallHeight(wallId) {
+        const wall = this.walls.get(wallId);
+        return wall?.height ?? 2.5; // Default wall height
+    }
+    getCeilingGrid(ceilingId) {
+        if (!this.ceilingGrids.has(ceilingId)) {
+            this.ceilingGrids.set(ceilingId, new SpatialGrid({ cellSize: this.cellSize }));
+        }
+        return this.ceilingGrids.get(ceilingId);
+    }
+    getSlabMap(levelId) {
+        if (!this.slabsByLevel.has(levelId)) {
+            this.slabsByLevel.set(levelId, new Map());
+        }
+        return this.slabsByLevel.get(levelId);
+    }
+    // Called when nodes change
+    handleNodeCreated(node, levelId) {
+        if (node.type === 'slab') {
+            this.getSlabMap(levelId).set(node.id, node);
+        }
+        else if (node.type === 'ceiling') {
+            this.ceilings.set(node.id, node);
+        }
+        else if (node.type === 'wall') {
+            const wall = node;
+            this.walls.set(wall.id, wall);
+        }
+        else if (node.type === 'item') {
+            const item = node;
+            if (item.asset.attachTo === 'wall' || item.asset.attachTo === 'wall-side') {
+                // Wall-attached item - use parentId as the wall ID
+                const wallId = item.parentId;
+                if (wallId && this.walls.has(wallId)) {
+                    const wallLength = this.getWallLength(wallId);
+                    if (wallLength > 0) {
+                        const [width, height] = item.asset.dimensions;
+                        const halfW = width / wallLength / 2;
+                        // Calculate t from local X position (position[0] is distance along wall)
+                        const t = item.position[0] / wallLength;
+                        // position[1] is the bottom of the item
+                        this.getWallGrid(levelId).insert({
+                            itemId: item.id,
+                            wallId: wallId,
+                            tStart: t - halfW,
+                            tEnd: t + halfW,
+                            yStart: item.position[1],
+                            yEnd: item.position[1] + height,
+                            attachType: item.asset.attachTo,
+                            side: item.side,
+                        });
+                    }
+                }
+            }
+            else if (item.asset.attachTo === 'ceiling') {
+                // Ceiling item - use parentId as the ceiling ID
+                const ceilingId = item.parentId;
+                if (ceilingId && this.ceilings.has(ceilingId)) {
+                    this.getCeilingGrid(ceilingId).insert(item.id, item.position, item.asset.dimensions, item.rotation);
+                    this.itemCeilingMap.set(item.id, ceilingId);
+                }
+            }
+            else if (!item.asset.attachTo) {
+                // Floor item
+                this.getFloorGrid(levelId).insert(item.id, item.position, item.asset.dimensions, item.rotation);
+            }
+        }
+    }
+    handleNodeUpdated(node, levelId) {
+        if (node.type === 'slab') {
+            this.getSlabMap(levelId).set(node.id, node);
+        }
+        else if (node.type === 'ceiling') {
+            this.ceilings.set(node.id, node);
+        }
+        else if (node.type === 'wall') {
+            const wall = node;
+            this.walls.set(wall.id, wall);
+        }
+        else if (node.type === 'item') {
+            const item = node;
+            if (item.asset.attachTo === 'wall' || item.asset.attachTo === 'wall-side') {
+                // Remove old placement and re-insert
+                this.getWallGrid(levelId).removeByItemId(item.id);
+                const wallId = item.parentId;
+                if (wallId && this.walls.has(wallId)) {
+                    const wallLength = this.getWallLength(wallId);
+                    if (wallLength > 0) {
+                        const [width, height] = item.asset.dimensions;
+                        const halfW = width / wallLength / 2;
+                        // Calculate t from local X position (position[0] is distance along wall)
+                        const t = item.position[0] / wallLength;
+                        // position[1] is the bottom of the item
+                        this.getWallGrid(levelId).insert({
+                            itemId: item.id,
+                            wallId: wallId,
+                            tStart: t - halfW,
+                            tEnd: t + halfW,
+                            yStart: item.position[1],
+                            yEnd: item.position[1] + height,
+                            attachType: item.asset.attachTo,
+                            side: item.side,
+                        });
+                    }
+                }
+            }
+            else if (item.asset.attachTo === 'ceiling') {
+                // Remove from old ceiling grid
+                const oldCeilingId = this.itemCeilingMap.get(item.id);
+                if (oldCeilingId) {
+                    this.getCeilingGrid(oldCeilingId).remove(item.id);
+                    this.itemCeilingMap.delete(item.id);
+                }
+                // Insert into new ceiling grid
+                const ceilingId = item.parentId;
+                if (ceilingId && this.ceilings.has(ceilingId)) {
+                    this.getCeilingGrid(ceilingId).insert(item.id, item.position, item.asset.dimensions, item.rotation);
+                    this.itemCeilingMap.set(item.id, ceilingId);
+                }
+            }
+            else if (!item.asset.attachTo) {
+                this.getFloorGrid(levelId).update(item.id, item.position, item.asset.dimensions, item.rotation);
+            }
+        }
+    }
+    handleNodeDeleted(nodeId, nodeType, levelId) {
+        if (nodeType === 'slab') {
+            this.getSlabMap(levelId).delete(nodeId);
+        }
+        else if (nodeType === 'ceiling') {
+            this.ceilings.delete(nodeId);
+            this.ceilingGrids.delete(nodeId);
+        }
+        else if (nodeType === 'wall') {
+            this.walls.delete(nodeId);
+            // Remove all items attached to this wall from the spatial grid
+            const removedItemIds = this.getWallGrid(levelId).removeWall(nodeId);
+            return removedItemIds; // Caller can use this to delete the items from scene
+        }
+        else if (nodeType === 'item') {
+            this.getFloorGrid(levelId).remove(nodeId);
+            this.getWallGrid(levelId).removeByItemId(nodeId);
+            // Also clean up ceiling grid
+            const oldCeilingId = this.itemCeilingMap.get(nodeId);
+            if (oldCeilingId) {
+                this.getCeilingGrid(oldCeilingId).remove(nodeId);
+                this.itemCeilingMap.delete(nodeId);
+            }
+        }
+        return [];
+    }
+    // Query methods
+    canPlaceOnFloor(levelId, position, dimensions, rotation, ignoreIds) {
+        const grid = this.getFloorGrid(levelId);
+        return grid.canPlace(position, dimensions, rotation, ignoreIds);
+    }
+    /**
+     * Check if an item can be placed on a wall
+     * @param levelId - the level containing the wall
+     * @param wallId - the wall to check
+     * @param localX - X position in wall-local space (distance from wall start)
+     * @param localY - Y position (height from floor)
+     * @param dimensions - item dimensions [width, height, depth]
+     * @param attachType - 'wall' (needs both sides) or 'wall-side' (needs one side)
+     * @param side - which side for 'wall-side' items
+     * @param ignoreIds - item IDs to ignore in collision check
+     */
+    canPlaceOnWall(levelId, wallId, localX, localY, dimensions, attachType = 'wall', side, ignoreIds) {
+        const wallLength = this.getWallLength(wallId);
+        if (wallLength === 0) {
+            return { valid: false, conflictIds: [] };
+        }
+        const wallHeight = this.getWallHeight(wallId);
+        // Convert local X position to parametric t (0-1)
+        const tCenter = localX / wallLength;
+        const [itemWidth, itemHeight] = dimensions;
+        return this.getWallGrid(levelId).canPlaceOnWall(wallId, wallLength, wallHeight, tCenter, itemWidth, localY, itemHeight, attachType, side, ignoreIds);
+    }
+    getWallForItem(levelId, itemId) {
+        return this.getWallGrid(levelId).getWallForItem(itemId);
+    }
+    /**
+     * Get the total slab elevation at a given (x, z) position on a level.
+     * Returns the highest slab elevation if the point is inside any slab polygon, otherwise 0.
+     */
+    getSlabElevationAt(levelId, x, z) {
+        const slabMap = this.slabsByLevel.get(levelId);
+        if (!slabMap)
+            return 0;
+        let maxElevation = 0;
+        for (const slab of slabMap.values()) {
+            if (slab.polygon.length >= 3 && pointInPolygon(x, z, slab.polygon)) {
+                const elevation = slab.elevation ?? 0.05;
+                if (elevation > maxElevation) {
+                    maxElevation = elevation;
+                }
+            }
+        }
+        return maxElevation;
+    }
+    /**
+     * Get the slab elevation for an item using its full footprint (bounding box).
+     * Checks if any part of the item's rotated footprint overlaps with any slab polygon.
+     * Returns the highest overlapping slab elevation, or 0 if none.
+     */
+    getSlabElevationForItem(levelId, position, dimensions, rotation) {
+        const slabMap = this.slabsByLevel.get(levelId);
+        if (!slabMap)
+            return 0;
+        let maxElevation = -Infinity;
+        for (const slab of slabMap.values()) {
+            if (slab.polygon.length >= 3 && itemOverlapsPolygon(position, dimensions, rotation, slab.polygon, 0.01)) {
+                const elevation = slab.elevation ?? 0.05;
+                if (elevation > maxElevation) {
+                    maxElevation = elevation;
+                }
+            }
+        }
+        return maxElevation === -Infinity ? 0 : maxElevation;
+    }
+    /**
+     * Get the slab elevation for a wall by checking if it overlaps with any slab polygon.
+     * Uses wallOverlapsPolygon which handles edge cases (points on boundary, collinear segments).
+     * Returns the highest slab elevation found, or 0 if none.
+     */
+    getSlabElevationForWall(levelId, start, end) {
+        const slabMap = this.slabsByLevel.get(levelId);
+        if (!slabMap)
+            return 0;
+        let maxElevation = -Infinity;
+        for (const slab of slabMap.values()) {
+            if (slab.polygon.length < 3)
+                continue;
+            if (wallOverlapsPolygon(start, end, slab.polygon)) {
+                const elevation = slab.elevation ?? 0.05;
+                if (elevation > maxElevation) {
+                    maxElevation = elevation;
+                }
+            }
+        }
+        return maxElevation === -Infinity ? 0 : maxElevation;
+    }
+    /**
+     * Check if an item can be placed on a ceiling.
+     * Validates that the footprint is within the ceiling polygon and doesn't overlap other ceiling items.
+     */
+    canPlaceOnCeiling(ceilingId, position, dimensions, rotation, ignoreIds) {
+        const ceiling = this.ceilings.get(ceilingId);
+        if (!ceiling || ceiling.polygon.length < 3) {
+            return { valid: false, conflictIds: [] };
+        }
+        // Check that the item footprint is entirely within the ceiling polygon
+        const corners = getItemFootprint(position, dimensions, rotation);
+        for (const [cx, cz] of corners) {
+            if (!pointInPolygon(cx, cz, ceiling.polygon)) {
+                return { valid: false, conflictIds: [] };
+            }
+        }
+        // Check for overlaps with other ceiling items
+        return this.getCeilingGrid(ceilingId).canPlace(position, dimensions, rotation, ignoreIds);
+    }
+    clearLevel(levelId) {
+        this.floorGrids.delete(levelId);
+        this.wallGrids.delete(levelId);
+        this.slabsByLevel.delete(levelId);
+    }
+    clear() {
+        this.floorGrids.clear();
+        this.wallGrids.clear();
+        this.walls.clear();
+        this.slabsByLevel.clear();
+        this.ceilingGrids.clear();
+        this.ceilings.clear();
+        this.itemCeilingMap.clear();
+    }
+}
+// Singleton instance
+export const spatialGridManager = new SpatialGridManager();

package/dist/hooks/spatial-grid/spatial-grid-sync.d.ts

@@ -0,0 +1,4 @@
+import type { AnyNode } from '../../schema';
+export declare function resolveLevelId(node: AnyNode, nodes: Record<string, AnyNode>): string;
+export declare function initSpatialGridSync(): void;
+//# sourceMappingURL=spatial-grid-sync.d.ts.map

package/dist/hooks/spatial-grid/spatial-grid-sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spatial-grid-sync.d.ts","sourceRoot":"","sources":["../../../src/hooks/spatial-grid/spatial-grid-sync.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAA2C,MAAM,cAAc,CAAA;AAIpF,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAmBpF;AAGD,wBAAgB,mBAAmB,SAmElC"}

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

@@ -0,0 +1,115 @@
+import useScene from '../../store/use-scene';
+import { itemOverlapsPolygon, spatialGridManager, wallOverlapsPolygon } from './spatial-grid-manager';
+export function resolveLevelId(node, nodes) {
+    // If the node itself is a level
+    if (node.type === 'level')
+        return node.id;
+    // Walk up parent chain to find level
+    // This assumes you track parentId or can derive it
+    let current = node;
+    while (current) {
+        if (current.type === 'level')
+            return current.id;
+        // Find parent (you might need to add parentId to your schema or derive it)
+        if (!current.parentId) {
+            current = undefined;
+        }
+        else {
+            current = nodes[current.parentId];
+        }
+    }
+    return 'default'; // fallback for orphaned items
+}
+// Call this once at app initialization
+export function initSpatialGridSync() {
+    const store = useScene;
+    // 1. Initial sync - process all existing nodes
+    const state = store.getState();
+    for (const node of Object.values(state.nodes)) {
+        const levelId = resolveLevelId(node, state.nodes);
+        spatialGridManager.handleNodeCreated(node, levelId);
+    }
+    // 2. Then subscribe to future changes
+    const markDirty = (id) => store.getState().markDirty(id);
+    // Subscribe to all changes
+    store.subscribe((state, prevState) => {
+        // Detect added nodes
+        for (const [id, node] of Object.entries(state.nodes)) {
+            if (!prevState.nodes[id]) {
+                const levelId = resolveLevelId(node, state.nodes);
+                spatialGridManager.handleNodeCreated(node, levelId);
+                // When a slab is added, mark overlapping items/walls dirty
+                if (node.type === 'slab') {
+                    markNodesOverlappingSlab(node, state.nodes, markDirty);
+                }
+            }
+        }
+        // Detect removed nodes
+        for (const [id, node] of Object.entries(prevState.nodes)) {
+            if (!state.nodes[id]) {
+                const levelId = resolveLevelId(node, prevState.nodes);
+                spatialGridManager.handleNodeDeleted(id, node.type, levelId);
+                // When a slab is removed, mark items/walls that were on it dirty (using current state)
+                if (node.type === 'slab') {
+                    markNodesOverlappingSlab(node, state.nodes, markDirty);
+                }
+            }
+        }
+        // Detect updated nodes (items with position/rotation/parentId/side changes, slabs with polygon/elevation changes)
+        for (const [id, node] of Object.entries(state.nodes)) {
+            const prev = prevState.nodes[id];
+            if (!prev)
+                continue;
+            if (node.type === 'item' && prev.type === 'item') {
+                if (!arraysEqual(node.position, prev.position) ||
+                    !arraysEqual(node.rotation, prev.rotation) ||
+                    node.parentId !== prev.parentId ||
+                    node.side !== prev.side) {
+                    const levelId = resolveLevelId(node, state.nodes);
+                    spatialGridManager.handleNodeUpdated(node, levelId);
+                }
+            }
+            else if (node.type === 'slab' && prev.type === 'slab') {
+                if (node.polygon !== prev.polygon || node.elevation !== prev.elevation) {
+                    const levelId = resolveLevelId(node, state.nodes);
+                    spatialGridManager.handleNodeUpdated(node, levelId);
+                    // Mark nodes overlapping old polygon and new polygon as dirty
+                    markNodesOverlappingSlab(prev, state.nodes, markDirty);
+                    markNodesOverlappingSlab(node, state.nodes, markDirty);
+                }
+            }
+        }
+    });
+}
+function arraysEqual(a, b) {
+    return a.length === b.length && a.every((v, i) => v === b[i]);
+}
+/**
+ * Mark all floor items and walls that overlap a slab polygon as dirty.
+ */
+function markNodesOverlappingSlab(slab, nodes, markDirty) {
+    if (slab.polygon.length < 3)
+        return;
+    const slabLevelId = resolveLevelId(slab, nodes);
+    for (const node of Object.values(nodes)) {
+        if (node.type === 'item') {
+            const item = node;
+            // Only floor items are affected by slabs
+            if (item.asset.attachTo)
+                continue;
+            if (resolveLevelId(node, nodes) !== slabLevelId)
+                continue;
+            if (itemOverlapsPolygon(item.position, item.asset.dimensions, item.rotation, slab.polygon, 0.01)) {
+                markDirty(node.id);
+            }
+        }
+        else if (node.type === 'wall') {
+            const wall = node;
+            if (resolveLevelId(node, nodes) !== slabLevelId)
+                continue;
+            if (wallOverlapsPolygon(wall.start, wall.end, slab.polygon)) {
+                markDirty(node.id);
+            }
+        }
+    }
+}

package/dist/hooks/spatial-grid/spatial-grid.d.ts

@@ -0,0 +1,23 @@
+interface SpatialGridConfig {
+    cellSize: number;
+}
+export declare class SpatialGrid {
+    private config;
+    private cells;
+    private itemCells;
+    constructor(config: SpatialGridConfig);
+    private posToCell;
+    private cellKey;
+    private getItemCells;
+    insert(itemId: string, position: [number, number, number], dimensions: [number, number, number], rotation: [number, number, number]): void;
+    remove(itemId: string): void;
+    update(itemId: string, position: [number, number, number], dimensions: [number, number, number], rotation: [number, number, number]): void;
+    canPlace(position: [number, number, number], dimensions: [number, number, number], rotation: [number, number, number], ignoreIds?: string[]): {
+        valid: boolean;
+        conflictIds: string[];
+    };
+    queryRadius(x: number, z: number, radius: number): string[];
+    getItemCount(): number;
+}
+export {};
+//# sourceMappingURL=spatial-grid.d.ts.map

package/dist/hooks/spatial-grid/spatial-grid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spatial-grid.d.ts","sourceRoot":"","sources":["../../../src/hooks/spatial-grid/spatial-grid.ts"],"names":[],"mappings":"AAMA,UAAU,iBAAiB;IACzB,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,qBAAa,WAAW;IAIV,OAAO,CAAC,MAAM;IAH1B,OAAO,CAAC,KAAK,CAA+B;IAC5C,OAAO,CAAC,SAAS,CAAkC;gBAE/B,MAAM,EAAE,iBAAiB;IAE7C,OAAO,CAAC,SAAS;IAIjB,OAAO,CAAC,OAAO;IAKf,OAAO,CAAC,YAAY;IAsCpB,MAAM,CACJ,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAClC,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EACpC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;IAepC,MAAM,CAAC,MAAM,EAAE,MAAM;IAiBrB,MAAM,CACJ,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAClC,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EACpC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;IAOpC,QAAQ,CACN,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAClC,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EACpC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAClC,SAAS,GAAE,MAAM,EAAO,GACvB;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,WAAW,EAAE,MAAM,EAAE,CAAA;KAAE;IAuB5C,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE;IAkB3D,YAAY,IAAI,MAAM;CAGvB"}