@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/roof/roof-footprint.js

@@ -1,4 +1,4 @@
-import { emitter, getLevelBelow, getLevelElevations, isCurvedWall, resolveLevelId, resolveRoofWallTopElevation, } from '@pascal-app/core';
+import { emitter, getLevelBelow, getLevelElevations, getWallCurveFrameAt, getWallCurveStationAtPoint, isCurvedWall, isOutdoorRoomType, isRailingWall, outdoorRoomRoofOutline, polygonAnchors, resolveLevelId, resolveRoofWallTopElevation, resolveRoomRoofFootprint, wallSegmentAnchors, } from '@pascal-app/core';
 const ROOF_AXIS_ALIGNMENT_EPSILON = 1e-4;
 export function isStandardRoofWallEligible(wall) {
     if (isCurvedWall(wall))
@@ -7,6 +7,94 @@ export function isStandardRoofWallEligible(wall) {
     const deltaZ = Math.abs(wall.end[1] - wall.start[1]);
     return deltaX <= ROOF_AXIS_ALIGNMENT_EPSILON || deltaZ <= ROOF_AXIS_ALIGNMENT_EPSILON;
 }
+/** A room's edge as the wall snap reads a wall: its ends, its middle and its run catch a point. */
+function edgeReference(id, parentId, start, end) {
+    return {
+        object: 'node',
+        id: id,
+        type: 'wall',
+        parentId,
+        visible: true,
+        metadata: {},
+        children: [],
+        start,
+        end,
+        frontSide: 'unknown',
+        backSide: 'unknown',
+    };
+}
+/** The levels' invisible walls, and their porches', decks' and patios' outside edges. */
+function levelEdges(nodes, levelIds) {
+    return levelIds.flatMap((levelId) => {
+        const level = nodes[levelId];
+        if (level?.type !== 'level')
+            return [];
+        const children = level.children.map((id) => nodes[id]);
+        const walls = children.filter((node) => node?.type === 'wall');
+        const separators = children.filter((node) => node?.type === 'separator');
+        const rooms = children
+            .filter((node) => node?.type === 'zone' && isOutdoorRoomType(node.roomType) && node.polygon.length >= 3)
+            .map((zone) => ({ zone, ...outdoorRoomRoofOutline(zone, walls, separators) }));
+        return [{ levelId, separators, rooms }];
+    });
+}
+const snapEdgesMemo = new WeakMap();
+function computeRoofSnapEdges(nodes, levelIds) {
+    const references = [];
+    const faced = new Set();
+    for (const { levelId, separators, rooms } of levelEdges(nodes, levelIds)) {
+        for (const separator of separators)
+            references.push(edgeReference(separator.id, levelId, separator.start, separator.end));
+        for (const { polygon, edges } of rooms)
+            edges.forEach((edge, index) => {
+                if (edge?.kind !== 'railing')
+                    return;
+                faced.add(edge.id);
+                const next = polygon[(index + 1) % polygon.length];
+                references.push(edgeReference(edge.id, levelId, polygon[index], next));
+            });
+    }
+    return { references, faced };
+}
+/**
+ * The rooms' edges on `levelIds` a drawn roof snaps to, as it snaps to walls (their corners,
+ * middles, crossings and runs): each invisible wall's line, and each railing round a porch, deck
+ * or patio at its outside face, from post corner to post corner (`outdoorRoomRoofOutline`), so a
+ * roof drawn over the room reaches its outside edge as one drawn over the house reaches its walls'.
+ * `faced` holds those railings: their faces stand in for their centre lines. Kept per scene, so a
+ * pointer move asks once.
+ */
+export function roofSnapEdges(nodes, levelIds) {
+    const key = levelIds.join('|');
+    let byKey = snapEdgesMemo.get(nodes);
+    if (!byKey) {
+        byKey = new Map();
+        snapEdgesMemo.set(nodes, byKey);
+    }
+    const cached = byKey.get(key);
+    if (cached)
+        return cached;
+    const edges = computeRoofSnapEdges(nodes, levelIds);
+    byKey.set(key, edges);
+    return edges;
+}
+/**
+ * The rooms' edges on `levelIds` as alignment anchors for a roof drawn over them: each straight
+ * invisible wall's ends and middle (as a wall's), and each porch's, deck's or patio's outside
+ * corners, railings' post corners included.
+ */
+export function roofEdgeAnchors(nodes, levelIds) {
+    return levelEdges(nodes, levelIds).flatMap(({ separators, rooms }) => [
+        ...separators
+            .filter((separator) => isStandardRoofWallEligible(separator))
+            .flatMap((separator) => wallSegmentAnchors(separator.id, separator.start, separator.end)),
+        ...rooms.flatMap(({ zone, polygon }) => polygonAnchors(zone.id, polygon)),
+    ]);
+}
+/** What a Room pick lights up while it hovers a room: its walls, a porch's edges with them. */
+export function roofFootprintPreviewIds(target) {
+    return target ? [...target.wallIds, ...(target.edgeIds ?? [])] : [];
+}
 export function isConicalRoofWallEligible(targetLevelId, wall, nodes) {
     const completeNodes = nodes;
     const sourceLevelId = resolveLevelId(wall, completeNodes);
@@ -16,11 +104,44 @@ export function isConicalRoofWallEligible(targetLevelId, wall, nodes) {
         return true;
     return getLevelBelow(targetLevelId, completeNodes)?.id === sourceLevelId;
 }
+// As far off the wall's centreline as the plan reaches for a wall a door or window goes in.
+const CONICAL_WALL_PICK_DISTANCE = 0.5;
+/**
+ * The curved wall a cone would be built over from a plan point: the nearest one in reach on the
+ * level or the level below. The plan raises no wall events, so its tool picks the wall itself.
+ */
+export function pickConicalRoofWall(levelId, nodes, point) {
+    let picked = null;
+    let pickedDistance = CONICAL_WALL_PICK_DISTANCE;
+    for (const node of Object.values(nodes)) {
+        if (!(node.type === 'wall' && isCurvedWall(node)))
+            continue;
+        if (!isConicalRoofWallEligible(levelId, node, nodes))
+            continue;
+        const nearest = getWallCurveFrameAt(node, getWallCurveStationAtPoint(node, point)).point;
+        const distance = Math.hypot(point[0] - nearest.x, point[1] - nearest.y);
+        if (distance > pickedDistance)
+            continue;
+        picked = node;
+        pickedDistance = distance;
+    }
+    return picked;
+}
 export function parseRoofFootprintSource(value, roofType) {
     if (roofType === 'conical')
         return 'walls';
     return value === 'room' ? 'room' : 'draw';
 }
+/**
+ * The room a Room pick at `point` roofs (the smallest one on the level, else on the level below),
+ * and what the pick found: a rectangle it roofs, a room it can't (not a rectangle), or none.
+ */
+export function pickRoofRoom(levelId, nodes, point) {
+    const found = resolveRoomRoofFootprint(levelId, nodes, point);
+    if (!found)
+        return { target: null, pick: 'none' };
+    return found.rectangular ? { target: found, pick: 'room' } : { target: null, pick: 'irregular' };
+}
 export function subscribeToConicalRoofWallClicks(options) {
     if (!(options.roofType === 'conical' && options.footprintSource === 'walls'))
         return () => { };
@@ -66,9 +187,10 @@ export function subscribeToConicalRoofWallClicks(options) {
 export function resolveRoofFootprintElevation(targetLevelId, target, nodes) {
     const completeNodes = nodes;
     const elevations = getLevelElevations(completeNodes);
+    // A railing is a guard round a deck or a porch, not a wall: the roof never sits on its top.
     const tops = target.wallIds.flatMap((id) => {
         const wall = nodes[id];
-        return wall?.type === 'wall'
+        return wall?.type === 'wall' && !isRailingWall(wall)
             ? [resolveRoofWallTopElevation(targetLevelId, wall, completeNodes, elevations)]
             : [];
     });

package/dist/roof/roof-materials.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"roof-materials.d.ts","sourceRoot":"","sources":["../../src/roof/roof-materials.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,WAAW,EAGhB,KAAK,aAAa,EAEnB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAM9B,wBAAgB,gBAAgB,CAC9B,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,GAChC,KAAK,CAAC,QAAQ,EAAE,CAsBlB;AAKD,wBAAgB,qBAAqB,CAAC,OAAO,GAAE,aAA0B,GAAG,KAAK,CAAC,QAAQ,EAAE,CAY3F"}
+{"version":3,"file":"roof-materials.d.ts","sourceRoot":"","sources":["../../src/roof/roof-materials.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,WAAW,EAGhB,KAAK,aAAa,EAEnB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAM9B,wBAAgB,gBAAgB,CAC9B,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,GAChC,KAAK,CAAC,QAAQ,EAAE,CA4BlB;AAKD,wBAAgB,qBAAqB,CAAC,OAAO,GAAE,aAA0B,GAAG,KAAK,CAAC,QAAQ,EAAE,CAe3F"}

package/dist/roof/roof-materials.js

@@ -1,7 +1,7 @@
 import { createDefaultMaterial, createSurfaceRoleMaterial, resolveSlotDefaultMaterial, } from '@pascal-app/viewer';
 import * as THREE from 'three';
 // Production materials — match the rest of the scene (white walls, light-gray slabs).
-// Indices: 0 = Wall/Trim, 1 = Deck, 2 = Interior, 3 = Shingle
+// Indices: 0 = Wall/Trim, 1 = Deck, 2 = Interior, 3 = Shingle, 4 = Heel band, 5/6 = Gables
 const roofMaterialsCache = new Map();
 export function getRoofMaterials(shading = 'rendered', textures = true, colorPreset = 'clay') {
     const cacheKey = `${shading}-${textures}-${colorPreset}`;
@@ -16,12 +16,18 @@ export function getRoofMaterials(shading = 'rendered', textures = true, colorPre
             resolveSlotDefaultMaterial('library:preset-softwhite', shading), // 1: Deck
             resolveSlotDefaultMaterial('library:preset-softwhite', shading), // 2: Interior
             resolveSlotDefaultMaterial('library:roof-terracottatiles', shading), // 3: Shingle
+            resolveSlotDefaultMaterial('library:concrete-drywall', shading), // 4: Heel band
+            resolveSlotDefaultMaterial('library:concrete-drywall', shading), // 5: Left gable
+            resolveSlotDefaultMaterial('library:concrete-drywall', shading), // 6: Right gable
         ]
         : [
             createSurfaceRoleMaterial('roof', colorPreset),
             createSurfaceRoleMaterial('ceiling', colorPreset),
             createSurfaceRoleMaterial('ceiling', colorPreset),
             createSurfaceRoleMaterial('roof', colorPreset),
+            createSurfaceRoleMaterial('wall', colorPreset),
+            createSurfaceRoleMaterial('roof', colorPreset),
+            createSurfaceRoleMaterial('roof', colorPreset),
         ];
     roofMaterialsCache.set(cacheKey, materials);
     return materials;
@@ -37,6 +43,9 @@ export function getRoofDebugMaterials(shading = 'rendered') {
         createDefaultMaterial('#000000', 0.9, shading, THREE.FrontSide), // 1: Deck
         createDefaultMaterial('#dddddd', 0.9, shading, THREE.DoubleSide), // 2: Interior
         createDefaultMaterial('#4ade80', 0.9, shading, THREE.FrontSide), // 3: Shingle
+        createDefaultMaterial('#f5d0a9', 0.8, shading, THREE.DoubleSide), // 4: Heel band
+        createDefaultMaterial('#93c5fd', 0.8, shading, THREE.DoubleSide), // 5: Left gable
+        createDefaultMaterial('#c4b5fd', 0.8, shading, THREE.DoubleSide), // 6: Right gable
     ];
     roofDebugMaterialsCache.set(shading, materials);
     return materials;

package/dist/roof/roof-placement-mode.d.ts

@@ -1,9 +1,7 @@
 export type RoofPlacementMode = 'auto' | 'ground' | 'roof';
 type RoofPlacementModeState = {
-    conical: boolean;
     mode: RoofPlacementMode;
     cycleMode: () => void;
-    setConical: (conical: boolean) => void;
 };
 declare const useRoofPlacementMode: import("zustand").UseBoundStore<import("zustand").StoreApi<RoofPlacementModeState>>;
 declare const subscribeToRoofKind: (onChange: () => void) => () => void;

package/dist/roof/roof-placement-mode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"roof-placement-mode.d.ts","sourceRoot":"","sources":["../../src/roof/roof-placement-mode.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,QAAQ,GAAG,MAAM,CAAA;AAI1D,KAAK,sBAAsB,GAAG;IAC5B,OAAO,EAAE,OAAO,CAAA;IAChB,IAAI,EAAE,iBAAiB,CAAA;IACvB,SAAS,EAAE,MAAM,IAAI,CAAA;IACrB,UAAU,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAA;CACvC,CAAA;AAED,QAAA,MAAM,oBAAoB,qFAQvB,CAAA;AAEH,QAAA,MAAM,mBAAmB,aAAc,MAAM,IAAI,eAG7C,CAAA;AAEJ,eAAO,MAAM,6BAA6B;IACxC,SAAS;IACT,KAAK;CACN,CAAA;AAED,eAAO,MAAM,8BAA8B;IACzC,SAAS;IACT,KAAK;CACN,CAAA;eAEc,oBAAoB"}
+{"version":3,"file":"roof-placement-mode.d.ts","sourceRoot":"","sources":["../../src/roof/roof-placement-mode.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,QAAQ,GAAG,MAAM,CAAA;AAI1D,KAAK,sBAAsB,GAAG;IAC5B,IAAI,EAAE,iBAAiB,CAAA;IACvB,SAAS,EAAE,MAAM,IAAI,CAAA;CACtB,CAAA;AAED,QAAA,MAAM,oBAAoB,qFAMvB,CAAA;AAOH,QAAA,MAAM,mBAAmB,aAAc,MAAM,IAAI,eAG7C,CAAA;AAEJ,eAAO,MAAM,6BAA6B;IACxC,SAAS;IACT,KAAK;CACN,CAAA;AAED,eAAO,MAAM,8BAA8B;IACzC,SAAS;IACT,KAAK;CACN,CAAA;eAEc,oBAAoB"}

package/dist/roof/roof-placement-mode.js

@@ -1,24 +1,26 @@
+import { useEditor } from '@pascal-app/editor';
 import { create } from 'zustand';
 const MODES = ['auto', 'ground', 'roof'];
 const useRoofPlacementMode = create((set, get) => ({
-    conical: false,
     mode: 'auto',
     cycleMode: () => {
         const current = MODES.indexOf(get().mode);
         set({ mode: MODES[(current + 1) % MODES.length] ?? 'auto' });
     },
-    setConical: (conical) => set({ conical }),
 }));
-const subscribeToRoofKind = (onChange) => useRoofPlacementMode.subscribe((state, previous) => {
-    if (state.conical !== previous.conical)
+// Read from the roof type the tool is armed with, not from whichever roof tool mounted: in a
+// 2D-only session the 3D tool never mounts, and the HUD showed a cone the standard rows.
+const isConicalRoof = (state) => state.toolDefaults.roof?.roofType === 'conical';
+const subscribeToRoofKind = (onChange) => useEditor.subscribe((state, previous) => {
+    if (isConicalRoof(state) !== isConicalRoof(previous))
         onChange();
 });
 export const conicalRoofToolHintVisibility = {
     subscribe: subscribeToRoofKind,
-    value: () => useRoofPlacementMode.getState().conical,
+    value: () => isConicalRoof(useEditor.getState()),
 };
 export const standardRoofToolHintVisibility = {
     subscribe: subscribeToRoofKind,
-    value: () => !useRoofPlacementMode.getState().conical,
+    value: () => !isConicalRoof(useEditor.getState()),
 };
 export default useRoofPlacementMode;

package/dist/roof/roof-plan-creases.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The ridges, hips and valleys a roof plan draws, read off the roof surface
+ * itself rather than off each segment on its own.
+ *
+ * A planar segment (gable, hip, shed, flat) is a convex solid: over its
+ * footprint its top is the lowest of its planes. Segments that overlap are
+ * unioned, so the roof's top is the highest of the segments there. The lines
+ * a plan draws are that surface's creases:
+ *
+ *   - two planes of one segment meeting where both are its top: a ridge
+ *     (level) or a hip (sloped), drawn wherever no other segment rises over
+ *     it, so a wing's ridge runs on past the main roof's wall line until it
+ *     dives under the main roof's slope;
+ *   - two segments' tops meeting: always a valley (the higher of two planes
+ *     is a V), from the corner where their eaves cross up to where it meets
+ *     the ridges.
+ *
+ * Everything is linear, so each crease is solved exactly along its line.
+ */
+export type PlanPoint = [number, number];
+/** A plane over the plan: its height is `a·x + b·z + c`. */
+export type RoofPlane = {
+    a: number;
+    b: number;
+    c: number;
+};
+export type RoofCreaseSurface = {
+    /** The roof node the segment belongs to: valleys between two roofs are drawn by one of them. */
+    roofId: string;
+    /** The segment's footprint in plan: a convex polygon. */
+    footprint: PlanPoint[];
+    /** The segment's roof planes; its top over the footprint is the lowest of them. */
+    planes: RoofPlane[];
+};
+export type RoofCreaseKind = 'ridge' | 'hip' | 'valley';
+export type RoofCrease = {
+    kind: RoofCreaseKind;
+    from: PlanPoint;
+    to: PlanPoint;
+    /** The roof that draws the line: the segment's own roof, or the lesser id of a valley's two. */
+    roofId: string;
+    /** The indices of the surfaces that meet there (the same one twice for a ridge or hip). */
+    between: [number, number];
+};
+/**
+ * Every ridge, hip and valley of the roof surface the planar segments make
+ * together. Each crease is reported once, under the roof that draws it.
+ */
+export declare function getRoofSurfaceCreases(surfaces: RoofCreaseSurface[]): RoofCrease[];
+//# sourceMappingURL=roof-plan-creases.d.ts.map

package/dist/roof/roof-plan-creases.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roof-plan-creases.d.ts","sourceRoot":"","sources":["../../src/roof/roof-plan-creases.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAExC,4DAA4D;AAC5D,MAAM,MAAM,SAAS,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAE3D,MAAM,MAAM,iBAAiB,GAAG;IAC9B,gGAAgG;IAChG,MAAM,EAAE,MAAM,CAAA;IACd,yDAAyD;IACzD,SAAS,EAAE,SAAS,EAAE,CAAA;IACtB,mFAAmF;IACnF,MAAM,EAAE,SAAS,EAAE,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,KAAK,GAAG,QAAQ,CAAA;AAEvD,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,cAAc,CAAA;IACpB,IAAI,EAAE,SAAS,CAAA;IACf,EAAE,EAAE,SAAS,CAAA;IACb,gGAAgG;IAChG,MAAM,EAAE,MAAM,CAAA;IACd,2FAA2F;IAC3F,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC1B,CAAA;AAuID;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,iBAAiB,EAAE,GAAG,UAAU,EAAE,CA4CjF"}

package/dist/roof/roof-plan-creases.js

@@ -0,0 +1,194 @@
+/**
+ * The ridges, hips and valleys a roof plan draws, read off the roof surface
+ * itself rather than off each segment on its own.
+ *
+ * A planar segment (gable, hip, shed, flat) is a convex solid: over its
+ * footprint its top is the lowest of its planes. Segments that overlap are
+ * unioned, so the roof's top is the highest of the segments there. The lines
+ * a plan draws are that surface's creases:
+ *
+ *   - two planes of one segment meeting where both are its top: a ridge
+ *     (level) or a hip (sloped), drawn wherever no other segment rises over
+ *     it, so a wing's ridge runs on past the main roof's wall line until it
+ *     dives under the main roof's slope;
+ *   - two segments' tops meeting: always a valley (the higher of two planes
+ *     is a V), from the corner where their eaves cross up to where it meets
+ *     the ridges.
+ *
+ * Everything is linear, so each crease is solved exactly along its line.
+ */
+const EPS = 1e-6;
+/** Shorter than this, a crease is a point where planes meet, not a line. */
+const MIN_CREASE = 0.01;
+const heightAt = (plane, x, z) => plane.a * x + plane.b * z + plane.c;
+/** The `t` where `slope·t + offset >= 0`, as an interval (empty as `null`). */
+function halfLine(slope, offset) {
+    if (Math.abs(slope) <= 1e-12)
+        return offset >= -EPS ? [-Infinity, Infinity] : null;
+    const root = -offset / slope;
+    return slope > 0 ? [root, Infinity] : [-Infinity, root];
+}
+function intersect(a, b) {
+    if (!(a && b))
+        return null;
+    const lo = Math.max(a[0], b[0]);
+    const hi = Math.min(a[1], b[1]);
+    return hi > lo ? [lo, hi] : null;
+}
+function subtract(intervals, cut) {
+    return intervals.flatMap(([lo, hi]) => {
+        if (cut[1] <= lo || cut[0] >= hi)
+            return [[lo, hi]];
+        const kept = [];
+        if (cut[0] > lo)
+            kept.push([lo, cut[0]]);
+        if (cut[1] < hi)
+            kept.push([cut[1], hi]);
+        return kept;
+    });
+}
+/** The plan line along which two planes stand at one height, or `null` when they never cross. */
+function meetingLine(p, q) {
+    const na = p.a - q.a;
+    const nb = p.b - q.b;
+    const norm2 = na * na + nb * nb;
+    if (norm2 <= 1e-12)
+        return null;
+    const dc = p.c - q.c;
+    const norm = Math.sqrt(norm2);
+    return {
+        origin: [(-dc * na) / norm2, (-dc * nb) / norm2],
+        dir: [-nb / norm, na / norm],
+    };
+}
+/** The stretch of a line inside a convex polygon. */
+function clipToPolygon(line, polygon) {
+    if (polygon.length < 3)
+        return null;
+    let area = 0;
+    for (let i = 0; i < polygon.length; i++) {
+        const [x0, z0] = polygon[i];
+        const [x1, z1] = polygon[(i + 1) % polygon.length];
+        area += x0 * z1 - x1 * z0;
+    }
+    const sign = area >= 0 ? 1 : -1;
+    let range = [-Infinity, Infinity];
+    for (let i = 0; i < polygon.length && range; i++) {
+        const [x0, z0] = polygon[i];
+        const [x1, z1] = polygon[(i + 1) % polygon.length];
+        const ex = x1 - x0;
+        const ez = z1 - z0;
+        // inside: sign · cross(edge, point − start) >= 0, linear in t
+        const slope = sign * (ex * line.dir[1] - ez * line.dir[0]);
+        const offset = sign * (ex * (line.origin[1] - z0) - ez * (line.origin[0] - x0));
+        range = intersect(range, halfLine(slope, offset + EPS));
+    }
+    return range;
+}
+/** Along a line, the height of a plane as `slope·t + offset`. */
+function along(plane, line) {
+    return [
+        plane.a * line.dir[0] + plane.b * line.dir[1],
+        heightAt(plane, line.origin[0], line.origin[1]),
+    ];
+}
+/** Where `plane` is the lowest of the surface's planes, so the surface's top, along the line. */
+function activeRange(surface, plane, line) {
+    const [ps, po] = along(plane, line);
+    let range = [-Infinity, Infinity];
+    for (const other of surface.planes) {
+        if (other === plane)
+            continue;
+        const [os, oo] = along(other, line);
+        range = intersect(range, halfLine(os - ps, oo - po + EPS));
+        if (!range)
+            return null;
+    }
+    return range;
+}
+/** Where `surface` stands higher than the crease (on `plane`) along the line. */
+function buriedRange(surface, plane, line) {
+    const [ps, po] = along(plane, line);
+    let range = clipToPolygon(line, surface.footprint);
+    for (const other of surface.planes) {
+        if (!range)
+            return null;
+        const [os, oo] = along(other, line);
+        range = intersect(range, halfLine(os - ps, oo - po - EPS * 10));
+    }
+    return range;
+}
+function pointAt(line, t) {
+    return [line.origin[0] + line.dir[0] * t, line.origin[1] + line.dir[1] * t];
+}
+/** The visible stretches of the line where plane `p` of surface `i` meets plane `q` of surface `k`. */
+function visibleStretches(surfaces, i, p, k, q, line) {
+    const si = surfaces[i];
+    const sk = surfaces[k];
+    let range = intersect(clipToPolygon(line, si.footprint), activeRange(si, p, line));
+    if (k !== i)
+        range = intersect(range, clipToPolygon(line, sk.footprint));
+    range = intersect(range, activeRange(sk, q, line));
+    if (!range)
+        return [];
+    let stretches = [range];
+    for (let m = 0; m < surfaces.length && stretches.length > 0; m++) {
+        if (m === i || m === k)
+            continue;
+        const buried = buriedRange(surfaces[m], p, line);
+        if (buried)
+            stretches = subtract(stretches, buried);
+    }
+    return stretches.filter(([lo, hi]) => hi - lo >= MIN_CREASE);
+}
+/**
+ * Every ridge, hip and valley of the roof surface the planar segments make
+ * together. Each crease is reported once, under the roof that draws it.
+ */
+export function getRoofSurfaceCreases(surfaces) {
+    const creases = [];
+    for (let i = 0; i < surfaces.length; i++) {
+        const si = surfaces[i];
+        // Within one segment: ridges and hips.
+        for (let pi = 0; pi < si.planes.length; pi++) {
+            for (let qi = pi + 1; qi < si.planes.length; qi++) {
+                const p = si.planes[pi];
+                const q = si.planes[qi];
+                const line = meetingLine(p, q);
+                if (!line)
+                    continue;
+                const level = Math.abs(along(p, line)[0]) <= 1e-6;
+                for (const [lo, hi] of visibleStretches(surfaces, i, p, i, q, line)) {
+                    creases.push({
+                        kind: level ? 'ridge' : 'hip',
+                        from: pointAt(line, lo),
+                        to: pointAt(line, hi),
+                        roofId: si.roofId,
+                        between: [i, i],
+                    });
+                }
+            }
+        }
+        // Between two segments: valleys.
+        for (let k = i + 1; k < surfaces.length; k++) {
+            const sk = surfaces[k];
+            for (const p of si.planes) {
+                for (const q of sk.planes) {
+                    const line = meetingLine(p, q);
+                    if (!line)
+                        continue;
+                    for (const [lo, hi] of visibleStretches(surfaces, i, p, k, q, line)) {
+                        creases.push({
+                            kind: 'valley',
+                            from: pointAt(line, lo),
+                            to: pointAt(line, hi),
+                            roofId: si.roofId < sk.roofId ? si.roofId : sk.roofId,
+                            between: [i, k],
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return creases;
+}

package/dist/roof/roof-ridge-mode.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Which way a placed roof's ridge runs over the drawn footprint: along its
+ * long side (the default, as a wing's roof usually does) or across it. The
+ * roof tool's R key and HUD chip flip it while placing.
+ */
+export type RoofRidgeMode = 'long' | 'short';
+type RoofRidgeModeState = {
+    mode: RoofRidgeMode;
+    toggle: () => void;
+    reset: () => void;
+};
+declare const useRoofRidgeMode: import("zustand").UseBoundStore<import("zustand").StoreApi<RoofRidgeModeState>>;
+/**
+ * Whether the segment turns a quarter so its ridge runs along z. A segment's
+ * ridge runs along its own x (its width), so a footprint deeper than it is
+ * wide turns for a long-side ridge; a square one keeps x.
+ */
+export declare function ridgeQuarterTurn(footprintWidth: number, footprintDepth: number, mode: RoofRidgeMode): boolean;
+export default useRoofRidgeMode;
+//# sourceMappingURL=roof-ridge-mode.d.ts.map

package/dist/roof/roof-ridge-mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roof-ridge-mode.d.ts","sourceRoot":"","sources":["../../src/roof/roof-ridge-mode.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,OAAO,CAAA;AAE5C,KAAK,kBAAkB,GAAG;IACxB,IAAI,EAAE,aAAa,CAAA;IACnB,MAAM,EAAE,MAAM,IAAI,CAAA;IAClB,KAAK,EAAE,MAAM,IAAI,CAAA;CAClB,CAAA;AAED,QAAA,MAAM,gBAAgB,iFAInB,CAAA;AAEH;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,cAAc,EAAE,MAAM,EACtB,cAAc,EAAE,MAAM,EACtB,IAAI,EAAE,aAAa,GAClB,OAAO,CAGT;eAEc,gBAAgB"}

package/dist/roof/roof-ridge-mode.js

@@ -0,0 +1,16 @@
+import { create } from 'zustand';
+const useRoofRidgeMode = create((set, get) => ({
+    mode: 'long',
+    toggle: () => set({ mode: get().mode === 'long' ? 'short' : 'long' }),
+    reset: () => set({ mode: 'long' }),
+}));
+/**
+ * Whether the segment turns a quarter so its ridge runs along z. A segment's
+ * ridge runs along its own x (its width), so a footprint deeper than it is
+ * wide turns for a long-side ridge; a square one keeps x.
+ */
+export function ridgeQuarterTurn(footprintWidth, footprintDepth, mode) {
+    const alongDepth = footprintDepth > footprintWidth + 1e-6;
+    return mode === 'long' ? alongDepth : !alongDepth;
+}
+export default useRoofRidgeMode;

package/dist/roof/tool.d.ts

@@ -1,10 +1,26 @@
-import { type AnyNode, type LevelNode, type RoofFootprintTarget, type SceneApi } from '@pascal-app/core';
+import { type AlignmentAnchor, type AnyNode, type GridEvent, type LevelNode, type RoofFootprintTarget, type RoofType, type SceneApi } from '@pascal-app/core';
+import * as THREE from 'three';
+import { BufferGeometry } from 'three';
 import { type RoofPlacementMode } from './roof-placement-mode.js';
+import { type RoofRidgeMode } from './roof-ridge-mode.js';
+export declare function collectRoofAlignmentAnchors(nodes: Readonly<Record<string, AnyNode>>, currentLevelId: string | null, roofType: RoofType): AlignmentAnchor[];
 /**
- * Creates a roof group with one default gable segment
+ * A grid event's point as the roof tools draft and commit it, the 3D tool and the plan's alike:
+ * through the shared surface snap pipeline, magnetic lock onto wall corners / midpoints / crossings
+ * / bodies on the active level and the floor below (raising the green beacon), falling back to
+ * alignment guides, then to the building-grid snap. The pipeline reads the active snapping mode
+ * (grid / lines / angles / off). `levelId` is intentionally omitted so the explicit floor-below
+ * `walls` aren't filtered back out.
  */
-export declare const commitRoofPlacement: (sceneApi: SceneApi, levelId: LevelNode['id'], corner1: [number, number, number], corner2: [number, number, number], selectedIds: string[], quarterTurn: boolean, placementMode: RoofPlacementMode) => AnyNode['id'] | null;
-export declare const commitRoofFootprint: (sceneApi: SceneApi, levelId: LevelNode['id'], target: RoofFootprintTarget, quarterTurn: boolean) => AnyNode['id'] | null;
+export declare function resolveRoofDraftPoint(event: GridEvent, levelId: string, nodes: Readonly<Record<string, AnyNode>>, roofType: RoofType, candidates: readonly AlignmentAnchor[]): [number, number];
+/**
+ * Creates a roof group with one default gable segment. `ridge` is a quarter
+ * turn outright, or a ridge mode: 'long' runs the ridge along the drawn
+ * rectangle's long side, 'short' across it.
+ */
+export declare const commitRoofPlacement: (sceneApi: SceneApi, levelId: LevelNode['id'], corner1: [number, number, number], corner2: [number, number, number], selectedIds: string[], ridge: boolean | RoofRidgeMode, placementMode: RoofPlacementMode) => AnyNode['id'] | null;
+export declare const commitRoofFootprint: (sceneApi: SceneApi, levelId: LevelNode['id'], target: RoofFootprintTarget, ridge: boolean | RoofRidgeMode) => AnyNode['id'] | null;
+export declare function buildRoofGhostGeometry(width: number, depth: number, wallHeight: number, pitchDeg: number, roofType: RoofType, defaults?: Record<string, unknown>): BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>;
 export declare const RoofTool: React.FC;
 export default RoofTool;
 //# sourceMappingURL=tool.d.ts.map

package/dist/roof/tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/roof/tool.tsx"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,OAAO,EAUZ,KAAK,SAAS,EACd,KAAK,mBAAmB,EAQxB,KAAK,QAAQ,EAKd,MAAM,kBAAkB,CAAA;AA+CzB,OAA6B,EAAE,KAAK,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AA6GpF;;GAEG;AACH,eAAO,MAAM,mBAAmB,aACpB,QAAQ,WACT,SAAS,CAAC,IAAI,CAAC,WACf,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,WACxB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,eACpB,MAAM,EAAE,eACR,OAAO,iBACL,iBAAiB,KAC/B,OAAO,CAAC,IAAI,CAAC,GAAG,IAkMlB,CAAA;AAED,eAAO,MAAM,mBAAmB,aACpB,QAAQ,WACT,SAAS,CAAC,IAAI,CAAC,UAChB,mBAAmB,eACd,OAAO,KACnB,OAAO,CAAC,IAAI,CAAC,GAAG,IAyClB,CAAA;AA2LD,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,EA6tB5B,CAAA;eAEc,QAAQ"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/roof/tool.tsx"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,OAAO,EAIZ,KAAK,SAAS,EAUd,KAAK,SAAS,EACd,KAAK,mBAAmB,EAGxB,KAAK,QAAQ,EAIb,KAAK,QAAQ,EAId,MAAM,kBAAkB,CAAA;AAmBzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAC9B,OAAO,EACL,cAAc,EAMf,MAAM,OAAO,CAAA;AAyBd,OAA6B,EAAE,KAAK,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AACpF,OAAyB,EAAE,KAAK,aAAa,EAAoB,MAAM,mBAAmB,CAAA;AAoI1F,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,cAAc,EAAE,MAAM,GAAG,IAAI,EAC7B,QAAQ,EAAE,QAAQ,GACjB,eAAe,EAAE,CAoBnB;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,SAAS,EAChB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,QAAQ,EAAE,QAAQ,EAClB,UAAU,EAAE,SAAS,eAAe,EAAE,GACrC,CAAC,MAAM,EAAE,MAAM,CAAC,CAiBlB;AA6BD;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,aACpB,QAAQ,WACT,SAAS,CAAC,IAAI,CAAC,WACf,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,WACxB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,eACpB,MAAM,EAAE,SACd,OAAO,GAAG,aAAa,iBACf,iBAAiB,KAC/B,OAAO,CAAC,IAAI,CAAC,GAAG,IAuMlB,CAAA;AAED,eAAO,MAAM,mBAAmB,aACpB,QAAQ,WACT,SAAS,CAAC,IAAI,CAAC,UAChB,mBAAmB,SACpB,OAAO,GAAG,aAAa,KAC7B,OAAO,CAAC,IAAI,CAAC,GAAG,IA0DlB,CAAA;AAQD,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,QAAQ,EAClB,QAAQ,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,8EA2DvC;AAED,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,EAmtB5B,CAAA;eAEc,QAAQ"}