@pascal-app/core 1.0.3 → 1.0.5

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

@@ -1,19 +1,19 @@
-import { itemOverlapsPolygon } from '../../lib/item-polygon-overlap.js';
+import { liftedManualSlab } from '../../lib/floor-construction-lift.js';
+import { selectSlabSupportForItem, slabSupportsItemFootprint } from '../../lib/item-slab-support.js';
 import { planFootprintAABB, planFootprintCorners } from '../../lib/plan-footprint.js';
 import { getRenderableSlabPolygon } from '../../lib/slab-polygon.js';
 import { levelBaseElevationAt } from '../../lib/terrain-support.js';
-import { nodeRegistry } from '../../registry/index.js';
+import { floorPlacedCollides, nodeRegistry } from '../../registry/index.js';
 import { getScaledDimensions, isLowProfileItemSurface } from '../../schema/index.js';
-import { getWallPlaneTop } from '../../services/storey.js';
+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 useScene from '../../store/use-scene.js';
-import { computeWallSlabSupport, pointInPolygon, SUPPORT_ELEVATION_EPSILON, } from '../../systems/slab/slab-support.js';
+import { computeWallSlabSupport, pointInPolygon, wallOverlapsPolygon, } from '../../systems/slab/slab-support.js';
 import { DEFAULT_WALL_THICKNESS } from '../../systems/wall/wall-footprint.js';
-import { resolveWallEffectiveHeight } from '../../systems/wall/wall-top.js';
 import { getFloorPlacedFootprints } from './floor-placed-elevation.js';
 import { SpatialGrid } from './spatial-grid.js';
-import { GROUND_SUPPORT_ID } from './support-host-id.js';
 import { WallSpatialGrid } from './wall-spatial-grid.js';
 export { itemOverlapsPolygon } from '../../lib/item-polygon-overlap.js';
 export { computeWallSlabElevation, computeWallSlabSupport, pointInPolygon, SUPPORT_ELEVATION_EPSILON, wallOverlapsPolygon, } from '../../systems/slab/slab-support.js';
@@ -148,12 +148,10 @@ export class SpatialGridManager {
         const wall = this.walls.get(wallId);
         if (!wall)
             return 0;
-        if (wall.height != null)
-            return wall.height;
         const nodes = useScene.getState().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);
-        return resolveWallEffectiveHeight(wall, getWallPlaneTop(wall, levelId, nodes), support.elevation);
+        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;
     }
     getCeilingGrid(ceilingId) {
         if (!this.ceilingGrids.has(ceilingId)) {
@@ -236,7 +234,7 @@ export class SpatialGridManager {
                 };
             }
         }
-        return effective;
+        return liftedManualSlab(useScene.getState().nodes, effective);
     }
     getRenderedSlabPolygon(levelId, slab) {
         const live = this.levelHasLivePreview(levelId);
@@ -267,17 +265,7 @@ export class SpatialGridManager {
      * are data, never render-offset).
      */
     slabSupportsFootprint(levelId, slab, position, dimensions, rotation) {
-        if (slab.polygon.length < 3)
-            return false;
-        const rendered = this.getRenderedSlabPolygon(levelId, slab);
-        if (!itemOverlapsPolygon(position, dimensions, rotation, rendered, 0.01))
-            return false;
-        const [cx, , cz] = position;
-        for (const hole of slab.holes || []) {
-            if (hole.length >= 3 && pointInPolygon(cx, cz, hole))
-                return false;
-        }
-        return true;
+        return slabSupportsItemFootprint(slab, { position, dimensions, rotation }, this.getRenderedSlabPolygon(levelId, slab));
     }
     // Called when nodes change
     handleNodeCreated(node, levelId) {
@@ -452,7 +440,7 @@ export class SpatialGridManager {
             if (ignoreSet.has(node.id))
                 continue;
             const floorPlaced = nodeRegistry.get(node.type)?.capabilities?.floorPlaced;
-            if (!floorPlaced?.collides)
+            if (!floorPlaced || !floorPlacedCollides(floorPlaced, node))
                 continue;
             if (floorPlaced.applies && !floorPlaced.applies(node))
                 continue;
@@ -590,23 +578,10 @@ export class SpatialGridManager {
         const slabMap = this.slabsByLevel.get(levelId);
         if (!slabMap)
             return { elevation: 0, slabId: null };
-        let winningElevation = Number.NEGATIVE_INFINITY;
-        let winnerId = null;
-        for (const stored of slabMap.values()) {
-            const slab = this.effectiveSlabRecord(stored);
-            const elevation = slab.elevation ?? 0.05;
-            if (maxElevation != null && elevation > maxElevation + SUPPORT_ELEVATION_EPSILON)
-                continue;
-            if (!this.slabSupportsFootprint(levelId, slab, position, dimensions, rotation))
-                continue;
-            if (elevation > winningElevation) {
-                winningElevation = elevation;
-                winnerId = slab.id;
-            }
-        }
-        return winnerId === null
-            ? { elevation: 0, slabId: null }
-            : { elevation: winningElevation, slabId: winnerId };
+        const winner = selectSlabSupportForItem(Array.from(slabMap.values(), (slab) => this.effectiveSlabRecord(slab)), { position, dimensions, rotation }, (slab) => this.getRenderedSlabPolygon(levelId, slab), { maxElevation });
+        return winner
+            ? { elevation: winner.elevation ?? 0.05, slabId: winner.id }
+            : { elevation: 0, slabId: null };
     }
     /**
      * The walking surface the pointer actually points at: the nearest slab
@@ -712,24 +687,14 @@ export class SpatialGridManager {
      * Accepts an optional `curveOffset` so curved walls evaluate overlap
      * against their actual centerline samples, not just the chord.
      */
-    getSlabElevationForWall(levelId, start, end, curveOffset = 0, thickness = DEFAULT_WALL_THICKNESS, preferredSlabId) {
-        return this.getSlabSupportForWall(levelId, start, end, curveOffset, thickness, preferredSlabId)
-            .elevation;
+    getSlabElevationForWall(levelId, start, end, curveOffset = 0, thickness = DEFAULT_WALL_THICKNESS, preferredSlabId, justification) {
+        return this.getSlabSupportForWall(levelId, start, end, curveOffset, thickness, preferredSlabId, undefined, 0, justification).elevation;
     }
-    getSlabSupportForWall(levelId, start, end, curveOffset = 0, thickness = DEFAULT_WALL_THICKNESS, preferredSlabId, maxElevation, supportOffset = 0) {
+    getSlabSupportForWall(levelId, start, end, curveOffset = 0, thickness = DEFAULT_WALL_THICKNESS, preferredSlabId, maxElevation, supportOffset = 0, justification) {
         // 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]);
-        if (preferredSlabId === GROUND_SUPPORT_ID) {
-            const elevation = levelBase + supportOffset;
-            return {
-                elevation,
-                electedSlabId: null,
-                baseElevation: elevation,
-                baseSegments: [{ start: 0, end: 1, elevation }],
-            };
-        }
         const slabMap = this.slabsByLevel.get(levelId);
         if (!slabMap) {
             const elevation = levelBase + supportOffset;
@@ -738,21 +703,15 @@ export class SpatialGridManager {
                 electedSlabId: null,
                 baseElevation: elevation,
                 baseSegments: [{ start: 0, end: 1, elevation }],
+                faceDatum: { a: [{ start: 0, end: 1, elevation }], b: [{ start: 0, end: 1, elevation }] },
+                faceBottom: { a: [{ start: 0, end: 1, elevation }], b: [{ start: 0, end: 1, elevation }] },
             };
         }
         const inputs = this.getSupportInputs(levelId, slabMap);
-        const support = computeWallSlabSupport({ start, end, curveOffset, thickness }, inputs.slabs, inputs.walls, preferredSlabId, maxElevation, levelBase);
-        if (supportOffset === 0)
-            return support;
-        return {
-            ...support,
-            elevation: support.elevation + supportOffset,
-            baseElevation: support.baseElevation + supportOffset,
-            baseSegments: support.baseSegments.map((segment) => ({
-                ...segment,
-                elevation: segment.elevation + supportOffset,
-            })),
-        };
+        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()
+            : undefined);
+        return support;
     }
     /**
      * Effective slab and wall records for a level, held BY IDENTITY. A single
@@ -777,12 +736,39 @@ export class SpatialGridManager {
             cached.transforms === transforms) {
             return cached;
         }
+        const slabs = [...slabMap.values()].map((slab) => {
+            const effective = this.effectiveSlabRecord(slab);
+            const lifted = liftedManualSlab(nodes, slab);
+            return lifted === slab
+                ? effective
+                : { ...effective, elevation: effective.elevation - (lifted.elevation - slab.elevation) };
+        });
+        const supportNodes = slabs.some((slab) => slab.plateRole === 'base' && slab.floorHeight !== undefined)
+            ? { ...nodes }
+            : {};
+        for (const slab of slabs)
+            for (const id of slab.zoneIds ?? []) {
+                const zone = nodes[id];
+                if (zone?.type === 'zone')
+                    supportNodes[id] = getEffectiveNode(zone);
+            }
+        for (const node of Object.values(nodes))
+            if (node.parentId === levelId && (node.type === 'separator' || node.type === 'zone'))
+                supportNodes[node.id] = getEffectiveNode(node);
+        for (const node of Object.values(nodes))
+            if (node.type === 'site' || node.type === 'building' || node.type === 'level')
+                supportNodes[node.id] = node;
         const next = {
             revision: this.supportInputsRevision,
             nodes,
             overrides,
             transforms,
-            slabs: [...slabMap.values()].map((slab) => this.effectiveSlabRecord(slab)),
+            terrainPlates: slabs.filter((slab) => slab.boundary === 'auto' &&
+                !slab.recessed &&
+                (slab.elevation - slab.thickness > 1e-4 || slab.elevation < -1e-4)),
+            baseAt: (x, z) => levelBaseElevationAt(nodes, levelId, x, z),
+            slabs,
+            supportNodes,
             walls: this.getLevelWallNodes(levelId).map((wall) => getEffectiveNode(wall)),
         };
         this.supportInputs.set(levelId, next);
@@ -904,18 +890,17 @@ export const spatialGridManager = new SpatialGridManager();
 /** 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).elevation;
+    return spatialGridManager.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:
- * {@link resolveWallEffectiveHeight} over the covering-clamped plane top
- * (`getWallPlaneTop`) and the singleton manager's slab election — so the
+ * {@link getWallTop} minus the singleton manager's slab election — so the
  * 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.
  */
 export function getWallEffectiveHeightForNodes(wall, nodes) {
     const levelId = resolveNodeLevelId(wall, nodes);
-    const baseElevation = getWallBaseElevationForNodes(wall, nodes);
-    return resolveWallEffectiveHeight(wall, getWallPlaneTop(wall, levelId, nodes), baseElevation);
+    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;
 }