@pascal-app/core 1.0.4 → 1.0.5

package/dist/systems/roof/roof-elevation.js

@@ -1,48 +1,52 @@
-import { getWallBaseElevationForNodes, getWallEffectiveHeightForNodes, } from '../../hooks/spatial-grid/spatial-grid-manager.js';
-import { resolveLevelId } from '../../hooks/spatial-grid/spatial-grid-sync.js';
-import { findLevelBelowId, getLevelElevations } from '../../services/storey.js';
+import { resolveLevelId } from '../../lib/node-ancestry.js';
+import { wallSupportForNodes } from '../../lib/opening-floor-datum.js';
+import { coveredStoreyId, servesAsRoofLevel } from '../../services/roof-level.js';
+import { findLevelBelowId, getLevelElevations, getWallTop } from '../../services/storey.js';
 import { wallOverlapsSlabFootprint } from '../slab/slab-support.js';
 import { getWallArcData } from '../wall/wall-curve.js';
 import { resolveRoomRoofFootprintOnLevel } from './roof-footprint.js';
 export function resolveRoofWallTopElevation(targetLevelId, wall, nodes, elevations = getLevelElevations(nodes)) {
-    const sourceLevelY = elevations.get(resolveLevelId(wall, nodes))?.baseY ?? 0;
+    const sourceLevelId = resolveLevelId(wall, nodes);
+    const sourceLevelY = elevations.get(sourceLevelId)?.baseY ?? 0;
     const targetLevelY = elevations.get(targetLevelId)?.baseY ?? 0;
-    return (sourceLevelY +
-        getWallBaseElevationForNodes(wall, nodes) +
-        getWallEffectiveHeightForNodes(wall, nodes) -
-        targetLevelY);
+    const support = wallSupportForNodes(wall, nodes);
+    return sourceLevelY + getWallTop(wall, sourceLevelId, nodes, support.elevation) - targetLevelY;
 }
-export function resolveRoofElevation(roof, nodes) {
-    if (roof.support?.kind !== 'walls')
-        return roof.position[1];
-    const levelId = resolveLevelId(roof, nodes);
-    if (nodes[levelId]?.type !== 'level')
-        return roof.position[1];
-    const elevations = getLevelElevations(nodes);
-    // A roof usually sits on the storey above its walls, but the top floor (or a
-    // roof armed from the walls' own level) keeps roof and walls on one level.
-    const belowId = findLevelBelowId(levelId, elevations);
-    const candidateWallIds = [levelId, belowId]
-        .map((id) => (id ? nodes[id] : undefined))
-        .filter((node) => node?.type === 'level')
-        .flatMap((level) => level.children);
-    const conicalSegments = roof.children
+/**
+ * The walls among `wallIds` a roof stands on: those under its segments' footprints, closed room or
+ * not (a room missing a wall, an L-shaped room whose centre falls outside, or a redrawn enclosure
+ * all still hold the roof up); a cone's, its round wall. Null for a roof with no segments yet.
+ */
+function wallsUnderRoof(roof, nodes, wallIds) {
+    const segments = roof.children
         .map((id) => nodes[id])
-        .filter((node) => node?.type === 'roof-segment' && node.roofType === 'conical');
+        .filter((node) => node?.type === 'roof-segment');
+    if (segments.length === 0)
+        return null;
     const cos = Math.cos(roof.rotation);
     const sin = Math.sin(roof.rotation);
     const toLevel = (x, z) => [
         roof.position[0] + x * cos + z * sin,
         roof.position[2] - x * sin + z * cos,
     ];
-    // Walls under the footprint, closed room or not: a room missing a wall, an
-    // L-shaped room whose centre falls outside, or a redrawn enclosure all still
-    // hold the roof up. The band test is curve- and thickness-aware and
-    // boundary-inclusive, so perimeter walls on the footprint edge count.
-    const footprints = roof.children
-        .map((id) => nodes[id])
-        .filter((node) => node?.type === 'roof-segment')
-        .map((segment) => {
+    const conicalSegments = segments.filter((segment) => segment.roofType === 'conical');
+    if (conicalSegments.length)
+        return wallIds.filter((id) => {
+            const wall = nodes[id];
+            if (wall?.type !== 'wall')
+                return false;
+            const arc = getWallArcData(wall);
+            if (!arc)
+                return false;
+            return conicalSegments.some((segment) => {
+                const [centerX, centerZ] = toLevel(segment.position[0], segment.position[2]);
+                return (Math.hypot(arc.center.x - centerX, arc.center.y - centerZ) <= 1e-4 &&
+                    Math.abs(arc.radius - segment.width / 2) <= 1e-4);
+            });
+        });
+    // The band test is curve- and thickness-aware and boundary-inclusive, so perimeter walls on the
+    // footprint edge count.
+    const footprints = segments.map((segment) => {
         const c = Math.cos(segment.rotation);
         const s = Math.sin(segment.rotation);
         const halfW = segment.width / 2;
@@ -55,41 +59,66 @@ export function resolveRoofElevation(roof, nodes) {
         ];
         return corners.map(([x, z]) => toLevel(segment.position[0] + x * c + z * s, segment.position[2] - x * s + z * c));
     });
-    const wallIds = conicalSegments.length
-        ? candidateWallIds.filter((id) => {
-            const wall = nodes[id];
-            if (wall?.type !== 'wall')
-                return false;
-            const arc = getWallArcData(wall);
-            if (!arc)
-                return false;
-            return conicalSegments.some((segment) => {
-                const [centerX, centerZ] = toLevel(segment.position[0], segment.position[2]);
-                return (Math.hypot(arc.center.x - centerX, arc.center.y - centerZ) <= 1e-4 &&
-                    Math.abs(arc.radius - segment.width / 2) <= 1e-4);
-            });
-        })
-        : footprints.length
-            ? candidateWallIds.filter((id) => {
-                const wall = nodes[id];
-                return (wall?.type === 'wall' &&
-                    footprints.some((polygon) => wallOverlapsSlabFootprint(wall, polygon)));
-            })
-            : ([levelId, belowId]
-                .map((id) => id
-                ? resolveRoomRoofFootprintOnLevel(id, nodes, [
-                    roof.position[0],
-                    roof.position[2],
-                ])
-                : null)
-                .find((target) => target !== null)?.wallIds ?? []);
+    return wallIds.filter((id) => {
+        const wall = nodes[id];
+        return (wall?.type === 'wall' &&
+            footprints.some((polygon) => wallOverlapsSlabFootprint(wall, polygon)));
+    });
+}
+/** The tallest of these walls' tops, from `targetLevelId`'s floor; undefined for none. */
+function highestWallTop(targetLevelId, wallIds, nodes, elevations) {
     let highest;
     for (const id of wallIds) {
         const wall = nodes[id];
         if (wall?.type !== 'wall')
             continue;
-        const top = resolveRoofWallTopElevation(levelId, wall, nodes, elevations);
+        const top = resolveRoofWallTopElevation(targetLevelId, wall, nodes, elevations);
         highest = highest === undefined ? top : Math.max(highest, top);
     }
-    return highest ?? roof.position[1];
+    return highest;
+}
+export function resolveRoofElevation(roof, nodes) {
+    if (roof.support?.kind !== 'walls')
+        return roof.position[1];
+    const levelId = resolveLevelId(roof, nodes);
+    if (nodes[levelId]?.type !== 'level')
+        return roof.position[1];
+    const elevations = getLevelElevations(nodes);
+    // A roof usually sits on the storey above its walls, but the top floor (or a
+    // roof armed from the walls' own level) keeps roof and walls on one level.
+    const belowId = findLevelBelowId(levelId, elevations);
+    // A lower wing's roof on the storey above stands on the walls below only: that storey's own
+    // walls along the wing's edge would lift it to their tops.
+    const level = nodes[levelId];
+    const supportLevelIds = belowId && !servesAsRoofLevel(nodes, level) && coveredStoreyId(nodes, roof) === belowId
+        ? [belowId]
+        : [levelId, belowId];
+    const candidateWallIds = supportLevelIds
+        .map((id) => (id ? nodes[id] : undefined))
+        .filter((node) => node?.type === 'level')
+        .flatMap((level) => level.children);
+    const wallIds = wallsUnderRoof(roof, nodes, candidateWallIds) ??
+        supportLevelIds
+            .map((id) => id
+            ? resolveRoomRoofFootprintOnLevel(id, nodes, [
+                roof.position[0],
+                roof.position[2],
+            ])
+            : null)
+            .find((target) => target !== null)?.wallIds ??
+        [];
+    return highestWallTop(levelId, wallIds, nodes, elevations) ?? roof.position[1];
+}
+/**
+ * The tallest top of `levelId`'s walls a roof stands on, from the floor of the level holding the
+ * roof (m); null when it stands on none of them, or has no segments to stand with.
+ */
+export function roofWallTop(roof, nodes, levelId) {
+    const level = nodes[levelId];
+    if (level?.type !== 'level')
+        return null;
+    const wallIds = wallsUnderRoof(roof, nodes, level.children);
+    if (!wallIds)
+        return null;
+    return (highestWallTop(resolveLevelId(roof, nodes), wallIds, nodes, getLevelElevations(nodes)) ?? null);
 }