@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/roof/tool.js

@@ -1,17 +1,22 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { collectAlignmentAnchors, emitter, getActiveRoofHeight, getWallArcData, getWallBaseElevationForNodes, getWallEffectiveHeightForNodes, isCurvedWall, RoofNode, RoofSegmentNode, RoofType as RoofTypeSchema, resolveBuildingForLevel, resolveLevelId, resolveRoomRoofFootprint, sceneRegistry, wallSegmentAnchors, } from '@pascal-app/core';
-import { CursorSphere, clearSurfacePlanSnapFeedback, EDITOR_LAYER, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, resolveSurfacePlanPointSnap, snapWorldXZForActiveBuilding, triggerSFX, useEditor, useFloorplanDraftPreview, useInteractionScope, useRegistryToolContext, } from '@pascal-app/editor';
+import { collectAlignmentAnchors, emitter, getActiveRoofHeight, getRoofModuleFaces, getRoofShapeRatios, getSegmentSlopeFrame, getWallArcData, getWallBaseElevationForNodes, getWallEffectiveHeightForNodes, getWallThickness, isCurvedWall, RoofNode, RoofSegmentNode, RoofType as RoofTypeSchema, resolveBuildingForLevel, resolveLevelId, wallSegmentAnchors, } from '@pascal-app/core';
+import { CursorSphere, clearSurfacePlanSnapFeedback, EDITOR_LAYER, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, resolveSurfacePlanPointSnap, snapWorldXZForActiveBuilding, triggerSFX, useEditor, useFloorplanDraftPreview, useInteractionScope, useRegistryToolContext, visibleScene, } from '@pascal-app/editor';
 import { generateRoofSegmentGeometry, useViewer } from '@pascal-app/viewer';
 import { useEffect, useMemo, useRef, useState, useSyncExternalStore } from 'react';
 import * as THREE from 'three';
 import { BufferGeometry, DoubleSide, Float32BufferAttribute, Vector3, } from 'three';
 import { createConicalRoofSectorAboveWall } from './conical-roof.js';
 import { resolveConicalRoofPlacement } from './conical-roof-placement.js';
-import { isStandardRoofWallEligible, parseRoofFootprintSource, resolveRoofFootprintElevation, resolveRoofFootprintWorldElevation, resolveRoofWallTopWorldElevation, subscribeToConicalRoofWallClicks, } from './roof-footprint.js';
+import { isStandardRoofWallEligible, parseRoofFootprintSource, pickRoofRoom, resolveRoofFootprintElevation, resolveRoofFootprintWorldElevation, resolveRoofWallTopWorldElevation, roofEdgeAnchors, roofFootprintPreviewIds, roofSnapEdges, subscribeToConicalRoofWallClicks, } from './roof-footprint.js';
 import useRoofFootprintSource from './roof-footprint-source.js';
 import { drawnRoofLevelTarget, drawnRoofSupport, roofLevelTarget, roofLevelTargetOffset, seatedRoofElevation, writeRoofNodes, writeSeatedRoofEdit, } from './roof-level-target.js';
 import useRoofPlacementMode, {} from './roof-placement-mode.js';
-const DEFAULT_WALL_HEIGHT = 0.5;
+import useRoofRidgeMode, { ridgeQuarterTurn } from './roof-ridge-mode.js';
+import { bearingWallThickness, roofCatchWalls, segmentWallLine, settleSegmentOnEdges, } from './wall-catch.js';
+// Rafters bear on the top plate, as standard trusses do; a raised heel is the segment's Wall Height.
+const DEFAULT_HEEL_HEIGHT = 0;
+// A cone's curb: it stands on the ground or on another roof, not on a plate.
+const DEFAULT_CONICAL_CURB_HEIGHT = 0.5;
 const DEFAULT_PITCH_DEG = 40;
 const GRID_OFFSET = 0.02;
 function placementOptions(mode) {
@@ -20,11 +25,21 @@ function placementOptions(mode) {
         requireRoofSupport: mode === 'roof',
     };
 }
-function resolveRoofDraftPlacement(footprintWidth, footprintDepth, quarterTurn, parentRotation = 0, roofType = 'gable') {
+/**
+ * A placed segment's quarter turn: given outright, or from a ridge mode, which
+ * runs the ridge along the footprint's long side ('long') or across it.
+ */
+function resolveQuarterTurn(ridge, footprintWidth, footprintDepth) {
+    return typeof ridge === 'boolean'
+        ? ridge
+        : ridgeQuarterTurn(footprintWidth, footprintDepth, ridge);
+}
+function resolveRoofDraftPlacement(footprintWidth, footprintDepth, ridge, parentRotation = 0, roofType = 'gable') {
     if (roofType === 'conical') {
         const diameter = Math.max(footprintWidth, footprintDepth);
         return { width: diameter, depth: diameter, rotation: -parentRotation };
     }
+    const quarterTurn = resolveQuarterTurn(ridge, footprintWidth, footprintDepth);
     return {
         width: quarterTurn ? footprintDepth : footprintWidth,
         depth: quarterTurn ? footprintWidth : footprintDepth,
@@ -42,47 +57,62 @@ function getLevelWalls(levelId, nodes) {
         .map((childId) => nodes[childId])
         .filter((node) => node?.type === 'wall');
 }
-// Walls on the level directly beneath the active one. Levels share the same
-// local XZ origin (they only differ in world Y), so these walls live in the
-// identical coordinate frame and feed straight into both the alignment pool
-// and the magnetic wall-snap pipeline — letting a roof drawn on the upper
-// floor snap onto the wall corners of the floor below.
-function getBelowLevelWalls(currentLevelId, nodes) {
+// The level directly beneath the active one. Levels share the same local XZ
+// origin (they only differ in world Y), so its walls live in the identical
+// coordinate frame and feed straight into both the alignment pool and the
+// magnetic wall-snap pipeline — letting a roof drawn on the upper floor snap
+// onto the wall corners of the floor below.
+function getBelowLevel(currentLevelId, nodes) {
     if (!currentLevelId)
-        return [];
+        return undefined;
     const currentLevel = nodes[currentLevelId];
     if (currentLevel?.type !== 'level')
-        return [];
+        return undefined;
     const buildingId = resolveBuildingForLevel(currentLevel.id, nodes);
     if (!buildingId)
-        return [];
+        return undefined;
     const building = nodes[buildingId];
     if (building?.type !== 'building')
-        return [];
+        return undefined;
     const currentIndex = currentLevel.level;
-    const belowLevel = (building.children ?? [])
+    return (building.children ?? [])
         .map((childId) => nodes[childId])
         .filter((node) => node?.type === 'level' && node.level < currentIndex)
         .sort((a, b) => b.level - a.level)[0];
-    return getLevelWalls(belowLevel?.id ?? null, nodes);
+}
+// Walls on the level directly beneath the active one.
+function getBelowLevelWalls(currentLevelId, nodes) {
+    return getLevelWalls(getBelowLevel(currentLevelId, nodes)?.id ?? null, nodes);
+}
+// The active level and the one beneath it, whose rooms' edges a roof draws to.
+function roofEdgeLevelIds(currentLevelId, nodes) {
+    const below = getBelowLevel(currentLevelId, nodes);
+    return [currentLevelId, below?.id].filter((id) => !!id);
 }
 // Current-level + floor-below walls — the magnetic snap targets the roof draft
 // locks onto (corners, midpoints, crossings, wall bodies), matching the wall
-// tool. Same coordinate frame, so no transform is needed.
+// tool. Same coordinate frame, so no transform is needed. A porch, deck or
+// patio is drawn to as the house is: its invisible walls, and its railings at
+// their outside faces in place of their centre lines (`roofSnapEdges`).
 function getRoofSnapWalls(currentLevelId, nodes, roofType) {
     const walls = [
         ...getLevelWalls(currentLevelId, nodes),
         ...getBelowLevelWalls(currentLevelId, nodes),
     ];
-    return roofType === 'conical'
-        ? walls.filter((wall) => isCurvedWall(wall))
-        : walls.filter(isStandardRoofWallEligible);
+    if (roofType === 'conical')
+        return walls.filter((wall) => isCurvedWall(wall));
+    const edges = roofSnapEdges(nodes, roofEdgeLevelIds(currentLevelId, nodes));
+    return [...walls.filter((wall) => !edges.faced.has(wall.id)), ...edges.references].filter(isStandardRoofWallEligible);
 }
-// Current-level alignment anchors plus the floor-below wall corners.
-function collectRoofAlignmentAnchors(nodes, currentLevelId, roofType) {
+// Current-level alignment anchors plus the floor-below wall corners, and both
+// levels' invisible walls and porch, deck and patio corners.
+export function collectRoofAlignmentAnchors(nodes, currentLevelId, roofType) {
     const anchors = [
         ...collectAlignmentAnchors(nodes, '', currentLevelId),
-        ...getBelowLevelWalls(currentLevelId, nodes).flatMap((wall) => wallSegmentAnchors(wall.id, wall.start, wall.end, wall.thickness)),
+        ...getBelowLevelWalls(currentLevelId, nodes).flatMap((wall) => wallSegmentAnchors(wall.id, wall.start, wall.end, wall.thickness, wall.justification)),
+        ...(roofType === 'conical'
+            ? []
+            : roofEdgeAnchors(nodes, roofEdgeLevelIds(currentLevelId, nodes))),
     ];
     if (roofType === 'conical') {
         return anchors.filter((anchor) => {
@@ -96,9 +126,51 @@ function collectRoofAlignmentAnchors(nodes, currentLevelId, roofType) {
     });
 }
 /**
- * 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 const commitRoofPlacement = (sceneApi, levelId, corner1, corner2, selectedIds, quarterTurn, placementMode) => {
+export function resolveRoofDraftPoint(event, levelId, nodes, roofType, candidates) {
+    const rawPoint = [event.localPosition[0], event.localPosition[2]];
+    const gridFallback = isGridSnapActive()
+        ? snapWorldXZForActiveBuilding(event.position[0], event.position[2], useEditor.getState().gridSnapStep).local
+        : rawPoint;
+    return resolveSurfacePlanPointSnap({
+        rawPoint,
+        fallbackPoint: gridFallback,
+        walls: getRoofSnapWalls(levelId, nodes, roofType),
+        candidates,
+        movingId: '__roof-draft__',
+        highlightWalls: true,
+    }).point;
+}
+/**
+ * A drawn segment whose gable and heel walls stand flush on the walls it is drawn over, and whose
+ * walls' outer faces stand on the rooms' edges it is drawn out to: a porch's invisible walls, a
+ * deck's railings at their outside faces (`settleSegmentOnEdges`).
+ */
+function onBearingWalls(segment, roof, walls) {
+    const thickness = bearingWallThickness(segmentWallLine(roof, segment), walls);
+    const bearing = thickness === null ? segment : { ...segment, wallThickness: thickness };
+    return { ...bearing, ...settleSegmentOnEdges(roof, bearing, walls) };
+}
+/**
+ * A new roof's place, and its one segment centred in it: the segment settled onto a room's edge
+ * (`onBearingWalls`) moves off the roof's centre, so the roof moves with it.
+ */
+function centredRoof(roof, segment) {
+    const [x, z] = segmentWallLine(roof, segment).center;
+    return { center: [x, z], segment: { ...segment, position: [0, segment.position[1], 0] } };
+}
+/**
+ * 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 const commitRoofPlacement = (sceneApi, levelId, corner1, corner2, selectedIds, ridge, placementMode) => {
     const nodes = sceneApi.nodes();
     // A placed roof preset seeds `toolDefaults.roof` with the flattened
     // subtree params (roofType, pitch, wallHeight, overhang, materials, …)
@@ -114,7 +186,7 @@ export const commitRoofPlacement = (sceneApi, levelId, corner1, corner2, selecte
     const footprintDepth = Math.max(Math.abs(corner2[2] - corner1[2]), 1);
     if (roofType === 'conical') {
         const diameter = Math.max(footprintWidth, footprintDepth);
-        const curbHeight = typeof defaults.wallHeight === 'number' ? defaults.wallHeight : DEFAULT_WALL_HEIGHT;
+        const curbHeight = typeof defaults.wallHeight === 'number' ? defaults.wallHeight : DEFAULT_CONICAL_CURB_HEIGHT;
         const cone = RoofSegmentNode.parse({
             pitch: DEFAULT_PITCH_DEG,
             ...defaults,
@@ -177,34 +249,24 @@ export const commitRoofPlacement = (sceneApi, levelId, corner1, corner2, selecte
     }
     if (targetRoofId) {
         const targetRoof = nodes[targetRoofId];
-        let localX = centerX;
-        let localZ = centerZ;
-        // Convert world coordinates to the local space of the parent roof
-        const targetObj = sceneRegistry.nodes.get(targetRoofId);
-        if (targetObj) {
-            const worldVec = new THREE.Vector3(centerX, 0, centerZ);
-            targetObj.worldToLocal(worldVec);
-            localX = worldVec.x;
-            localZ = worldVec.z;
-        }
-        else {
-            // Math fallback if mesh isn't ready
-            const dx = centerX - targetRoof.position[0];
-            const dz = centerZ - targetRoof.position[2];
-            const angle = -targetRoof.rotation;
-            localX = dx * Math.cos(angle) - dz * Math.sin(angle);
-            localZ = dx * Math.sin(angle) + dz * Math.cos(angle);
-        }
-        const placement = resolveRoofDraftPlacement(footprintWidth, footprintDepth, quarterTurn, targetRoof.rotation, roofType);
+        // The corners are in the level's plan, the roof's frame: its own place and turn in it. (Its
+        // mesh's world matrix also carries the building's, which would throw the plane off.)
+        const dx = centerX - targetRoof.position[0];
+        const dz = centerZ - targetRoof.position[2];
+        const angle = -targetRoof.rotation;
+        const localX = dx * Math.cos(angle) - dz * Math.sin(angle);
+        const localZ = dx * Math.sin(angle) + dz * Math.cos(angle);
+        const placement = resolveRoofDraftPlacement(footprintWidth, footprintDepth, ridge, targetRoof.rotation, roofType);
         const sibling = targetRoof.children
             .map((id) => nodes[id])
             .find((node) => node?.type === 'roof-segment');
-        const segment = RoofSegmentNode.parse({
+        const drawn = RoofSegmentNode.parse({
             roofSystem: sibling?.type === 'roof-segment' ? sibling.roofSystem : undefined,
             glazing: sibling?.type === 'roof-segment' ? sibling.glazing : undefined,
             barrelRise: sibling?.type === 'roof-segment' ? sibling.barrelRise : undefined,
             barrelSegments: sibling?.type === 'roof-segment' ? sibling.barrelSegments : undefined,
-            wallHeight: DEFAULT_WALL_HEIGHT,
+            // A wing bears where the roof it joins does: on the plate, or on the same raised heel.
+            wallHeight: sibling?.type === 'roof-segment' ? sibling.wallHeight : DEFAULT_HEEL_HEIGHT,
             pitch: DEFAULT_PITCH_DEG,
             roofType: 'gable',
             ...defaults,
@@ -213,6 +275,7 @@ export const commitRoofPlacement = (sceneApi, levelId, corner1, corner2, selecte
             position: [localX, 0, localZ],
             rotation: placement.rotation,
         });
+        const segment = onBearingWalls(drawn, targetRoof, roofCatchWalls(nodes, targetRoof.parentId));
         writeSeatedRoofEdit(sceneApi, {
             create: [{ node: segment, parentId: targetRoofId }],
         });
@@ -223,10 +286,14 @@ export const commitRoofPlacement = (sceneApi, levelId, corner1, corner2, selecte
     const roofCount = Object.values(nodes).filter((n) => n.type === 'roof').length;
     const name = `Roof ${roofCount + 1}`;
     const roofRotation = typeof defaults.rotation === 'number' ? defaults.rotation : 0;
-    const placement = resolveRoofDraftPlacement(footprintWidth, footprintDepth, quarterTurn, roofRotation, roofType);
+    const placement = resolveRoofDraftPlacement(footprintWidth, footprintDepth, ridge, roofRotation, roofType);
     // Create the segment first (centered in its new parent)
-    const segment = RoofSegmentNode.parse({
-        wallHeight: DEFAULT_WALL_HEIGHT,
+    const drawnRoof = {
+        position: [centerX, 0, centerZ],
+        rotation: roofRotation,
+    };
+    const { center: [roofX, roofZ], segment, } = centredRoof(drawnRoof, onBearingWalls(RoofSegmentNode.parse({
+        wallHeight: DEFAULT_HEEL_HEIGHT,
         pitch: DEFAULT_PITCH_DEG,
         roofType: 'gable',
         ...defaults,
@@ -234,7 +301,7 @@ export const commitRoofPlacement = (sceneApi, levelId, corner1, corner2, selecte
         depth: placement.depth,
         position: [0, 0, 0],
         rotation: placement.rotation,
-    });
+    }), drawnRoof, roofCatchWalls(nodes, levelId)));
     // Drawn over a storey's walls, the roof goes on the level above them.
     const target = drawnRoofLevelTarget(nodes, levelId, segment.wallHeight + getActiveRoofHeight(segment), { center: [centerX, centerZ], width: footprintWidth, depth: footprintDepth, roofType });
     const support = drawnRoofSupport(target, levelId);
@@ -243,14 +310,14 @@ export const commitRoofPlacement = (sceneApi, levelId, corner1, corner2, selecte
     const placed = RoofNode.parse({
         ...defaults,
         name,
-        position: [centerX, 0, centerZ],
+        position: [roofX, 0, roofZ],
         support,
         children: [segment.id],
     });
     const roof = support.kind === 'walls'
         ? RoofNode.parse({
             ...placed,
-            position: [centerX, seatedRoofElevation(target, placed, [segment]), centerZ],
+            position: [roofX, seatedRoofElevation(target, placed, [segment]), roofZ],
         })
         : placed;
     // Create roof first (so segment can be parented to it), then segment
@@ -261,9 +328,10 @@ export const commitRoofPlacement = (sceneApi, levelId, corner1, corner2, selecte
     triggerSFX('sfx:structure-build');
     return roof.id;
 };
-export const commitRoofFootprint = (sceneApi, levelId, target, quarterTurn) => {
+export const commitRoofFootprint = (sceneApi, levelId, target, ridge) => {
     if (!target.rectangular)
         return null;
+    const quarterTurn = resolveQuarterTurn(ridge, target.width, target.depth);
     const nodes = sceneApi.nodes();
     const defaults = useEditor.getState().toolDefaults.roof ?? {};
     const parsedRoofType = RoofTypeSchema.safeParse(defaults.roofType);
@@ -271,10 +339,15 @@ export const commitRoofFootprint = (sceneApi, levelId, target, quarterTurn) => {
     if (roofType === 'conical')
         return null;
     const roofCount = Object.values(nodes).filter((node) => node.type === 'roof').length;
-    const segment = RoofSegmentNode.parse({
+    const walls = target.wallIds
+        .map((id) => nodes[id])
+        .filter((node) => node?.type === 'wall');
+    const picked = RoofSegmentNode.parse({
         pitch: DEFAULT_PITCH_DEG,
         roofType: 'gable',
         ...defaults,
+        // Its gable and heel walls stand flush on the room's walls.
+        ...(walls.length > 0 && { wallThickness: Math.max(...walls.map(getWallThickness)) }),
         wallHeight: 0,
         width: quarterTurn ? target.depth : target.width,
         depth: quarterTurn ? target.width : target.depth,
@@ -283,16 +356,27 @@ export const commitRoofFootprint = (sceneApi, levelId, target, quarterTurn) => {
     });
     // A roof belongs to the level above the walls it covers, whichever level the tool was armed
     // on: over the top floor, the building's roof level.
-    const firstWall = target.wallIds.map((id) => nodes[id]).find((node) => node?.type === 'wall');
-    const wallsLevelId = (firstWall ? resolveLevelId(firstWall, nodes) : levelId);
+    const firstWall = walls[0];
+    const wallsLevelId = (target.levelId ??
+        (firstWall ? resolveLevelId(firstWall, nodes) : levelId));
+    // Over a porch, deck or patio, the roof's walls stand their outer faces on the room's outside
+    // edge, as a house roof's stand on the walls' outside faces.
+    const pickedRoof = {
+        position: [target.center[0], 0, target.center[1]],
+        rotation: target.rotation,
+    };
+    const { center, segment } = centredRoof(pickedRoof, {
+        ...picked,
+        ...settleSegmentOnEdges(pickedRoof, picked, roofCatchWalls(nodes, wallsLevelId)),
+    });
     const level = roofLevelTarget(nodes, wallsLevelId, getActiveRoofHeight(segment));
     const roof = RoofNode.parse({
         ...defaults,
         name: `Roof ${roofCount + 1}`,
         position: [
-            target.center[0],
+            center[0],
             resolveRoofFootprintElevation(level.levelId, target, level.nodes),
-            target.center[1],
+            center[1],
         ],
         rotation: target.rotation,
         support: { kind: 'walls' },
@@ -305,157 +389,59 @@ export const commitRoofFootprint = (sceneApi, levelId, target, quarterTurn) => {
     triggerSFX('sfx:structure-build');
     return roof.id;
 };
-function buildRoofGhostGeometry(width, depth, wallHeight, pitchDeg, roofType) {
-    const safeWidth = Math.max(width, 0.1);
-    const safeDepth = Math.max(depth, 0.1);
-    const halfWidth = safeWidth / 2;
-    const halfDepth = safeDepth / 2;
-    const ridgeHeight = wallHeight + Math.tan((pitchDeg * Math.PI) / 180) * halfDepth;
-    if (roofType === 'conical') {
-        const roofHeight = Math.max(0.001, Math.tan((pitchDeg * Math.PI) / 180) * halfWidth);
-        const geometry = new THREE.ConeGeometry(halfWidth, roofHeight, 48);
-        geometry.translate(0, wallHeight + roofHeight / 2, 0);
-        return geometry;
-    }
-    const vertices = [
-        // Front slope
-        -halfWidth,
-        wallHeight,
-        -halfDepth,
-        halfWidth,
-        wallHeight,
-        -halfDepth,
-        halfWidth,
-        ridgeHeight,
-        0,
-        -halfWidth,
-        wallHeight,
-        -halfDepth,
-        halfWidth,
-        ridgeHeight,
-        0,
-        -halfWidth,
-        ridgeHeight,
-        0,
-        // Back slope
-        -halfWidth,
-        ridgeHeight,
-        0,
-        halfWidth,
-        ridgeHeight,
-        0,
-        halfWidth,
-        wallHeight,
-        halfDepth,
-        -halfWidth,
-        ridgeHeight,
-        0,
-        halfWidth,
-        wallHeight,
-        halfDepth,
-        -halfWidth,
-        wallHeight,
-        halfDepth,
-        // Left gable
-        -halfWidth,
-        wallHeight,
-        -halfDepth,
-        -halfWidth,
-        ridgeHeight,
-        0,
-        -halfWidth,
-        wallHeight,
-        halfDepth,
-        // Right gable
-        halfWidth,
-        wallHeight,
-        -halfDepth,
-        halfWidth,
+export function buildRoofGhostGeometry(width, depth, wallHeight, pitchDeg, roofType, defaults = {}) {
+    const node = RoofSegmentNode.parse({
+        ...defaults,
+        width: Math.max(width, 0.1),
+        depth: Math.max(depth, 0.1),
         wallHeight,
-        halfDepth,
-        halfWidth,
-        ridgeHeight,
-        0,
-    ];
-    const geometry = new BufferGeometry();
-    geometry.setAttribute('position', new Float32BufferAttribute(vertices, 3));
-    geometry.computeVertexNormals();
-    return geometry;
-}
-function buildRoofGhostEdges(width, depth, wallHeight, pitchDeg, roofType) {
-    const safeWidth = Math.max(width, 0.1);
-    const safeDepth = Math.max(depth, 0.1);
-    const halfWidth = safeWidth / 2;
-    const halfDepth = safeDepth / 2;
-    const ridgeHeight = wallHeight + Math.tan((pitchDeg * Math.PI) / 180) * halfDepth;
-    if (roofType === 'conical') {
-        const roofHeight = Math.max(0.001, Math.tan((pitchDeg * Math.PI) / 180) * halfWidth);
-        const cone = new THREE.ConeGeometry(halfWidth, roofHeight, 48);
-        cone.translate(0, wallHeight + roofHeight / 2, 0);
-        const edges = new THREE.EdgesGeometry(cone, 10);
-        cone.dispose();
-        return edges;
+        pitch: pitchDeg,
+        roofType,
+    });
+    const { activeRh, tanTheta } = getSegmentSlopeFrame(node);
+    const faces = getRoofModuleFaces({
+        type: node.roofType,
+        w: node.width,
+        d: node.depth,
+        wh: node.wallHeight,
+        rh: activeRh,
+        baseY: 0,
+        baseW: node.width,
+        baseD: node.depth,
+        tanTheta,
+        insets: {},
+        shapeRatios: getRoofShapeRatios(node),
+        dutchTopRakeThickness: node.dutchTopRakeThickness,
+        conicalStartAngle: node.conicalFullCircle ? 0 : node.conicalStartAngle,
+        conicalSweepAngle: node.conicalFullCircle ? Math.PI * 2 : node.conicalSweepAngle,
+    });
+    const positions = [];
+    for (const face of faces) {
+        if (face.length < 3)
+            continue;
+        const origin = new THREE.Vector3(face[0].x, face[0].y, face[0].z);
+        const normal = new THREE.Vector3();
+        for (let i = 1; i + 1 < face.length && normal.lengthSq() < 1e-12; i++) {
+            normal.crossVectors(new THREE.Vector3(face[i].x, face[i].y, face[i].z).sub(origin), new THREE.Vector3(face[i + 1].x, face[i + 1].y, face[i + 1].z).sub(origin));
+        }
+        if (normal.lengthSq() < 1e-12)
+            continue;
+        const axis = Math.abs(normal.y) >= Math.max(Math.abs(normal.x), Math.abs(normal.z))
+            ? 'y'
+            : Math.abs(normal.x) > Math.abs(normal.z)
+                ? 'x'
+                : 'z';
+        const contour = face.map((v) => new THREE.Vector2(axis === 'x' ? v.y : v.x, axis === 'z' ? v.y : v.z));
+        for (const triangle of THREE.ShapeUtils.triangulateShape(contour, [])) {
+            for (const index of triangle) {
+                const vertex = face[index];
+                positions.push(vertex.x, vertex.y, vertex.z);
+            }
+        }
     }
-    const vertices = [
-        // Base rectangle
-        -halfWidth,
-        wallHeight,
-        -halfDepth,
-        halfWidth,
-        wallHeight,
-        -halfDepth,
-        halfWidth,
-        wallHeight,
-        -halfDepth,
-        halfWidth,
-        wallHeight,
-        halfDepth,
-        halfWidth,
-        wallHeight,
-        halfDepth,
-        -halfWidth,
-        wallHeight,
-        halfDepth,
-        -halfWidth,
-        wallHeight,
-        halfDepth,
-        -halfWidth,
-        wallHeight,
-        -halfDepth,
-        // Ridge + gable edges
-        -halfWidth,
-        ridgeHeight,
-        0,
-        halfWidth,
-        ridgeHeight,
-        0,
-        -halfWidth,
-        wallHeight,
-        -halfDepth,
-        -halfWidth,
-        ridgeHeight,
-        0,
-        -halfWidth,
-        ridgeHeight,
-        0,
-        -halfWidth,
-        wallHeight,
-        halfDepth,
-        halfWidth,
-        wallHeight,
-        -halfDepth,
-        halfWidth,
-        ridgeHeight,
-        0,
-        halfWidth,
-        ridgeHeight,
-        0,
-        halfWidth,
-        wallHeight,
-        halfDepth,
-    ];
     const geometry = new BufferGeometry();
-    geometry.setAttribute('position', new Float32BufferAttribute(vertices, 3));
+    geometry.setAttribute('position', new Float32BufferAttribute(positions, 3));
+    geometry.computeVertexNormals();
     return geometry;
 }
 export const RoofTool = () => {
@@ -472,16 +458,16 @@ export const RoofTool = () => {
     const roofType = parsedRoofType.success ? parsedRoofType.data : 'gable';
     const footprintSourceChoice = useRoofFootprintSource((state) => state.source);
     const footprintSource = parseRoofFootprintSource(footprintSourceChoice, roofType);
-    const previewWallHeight = typeof roofDefaults?.wallHeight === 'number' ? roofDefaults.wallHeight : DEFAULT_WALL_HEIGHT;
+    const previewWallHeight = typeof roofDefaults?.wallHeight === 'number'
+        ? roofDefaults.wallHeight
+        : roofType === 'conical'
+            ? DEFAULT_CONICAL_CURB_HEIGHT
+            : DEFAULT_HEEL_HEIGHT;
     const previewPitch = typeof roofDefaults?.pitch === 'number' ? roofDefaults.pitch : DEFAULT_PITCH_DEG;
     const selectedIdsRef = useRef(selectedIds);
     useEffect(() => {
         selectedIdsRef.current = selectedIds;
     }, [selectedIds]);
-    useEffect(() => {
-        useRoofPlacementMode.getState().setConical(roofType === 'conical');
-        return () => useRoofPlacementMode.getState().setConical(false);
-    }, [roofType]);
     useEffect(() => {
         if (!currentLevelId)
             return;
@@ -505,13 +491,11 @@ export const RoofTool = () => {
                 .endIf((scope) => scope.kind === 'placing' && scope.nodeId === draft.id);
         };
     }, [currentLevelId]);
-    // Clear preset-seeded defaults on deactivation so a later manual roof draw
-    // isn't built with a stale preset's parameters. Unmount-only.
-    useEffect(() => () => useEditor.getState().setToolDefaults('roof', null), []);
+    // Each arming starts with the ridge along the long side. Unmount-only.
+    useEffect(() => () => useRoofRidgeMode.getState().reset(), []);
     const corner1Ref = useRef(null);
     const previousGridPosRef = useRef(null);
-    const quarterTurnRef = useRef(false);
-    const [quarterTurn, setQuarterTurn] = useState(false);
+    const ridgeMode = useRoofRidgeMode((state) => state.mode);
     const [footprintTarget, setFootprintTarget] = useState(null);
     const previewTargetIdRef = useRef(null);
     const [previewedConicalWallId, setPreviewedConicalWallId] = useState(null);
@@ -531,41 +515,23 @@ export const RoofTool = () => {
         if (!currentLevelId)
             return;
         outlineRef.current.geometry = new BufferGeometry();
-        useFloorplanDraftPreview.getState().setRoofDraftQuarterTurn(quarterTurnRef.current);
+        // The 2D draft's ridge line follows the drawn rectangle and the ridge mode.
+        const syncDraftRidge = (corner1, corner2) => useFloorplanDraftPreview
+            .getState()
+            .setRoofDraftQuarterTurn(ridgeQuarterTurn(Math.abs(corner2[0] - corner1[0]), Math.abs(corner2[2] - corner1[2]), useRoofRidgeMode.getState().mode));
+        let lastCursor = null;
         // Alignment candidates — anchors of every alignable object on the active
         // level plus the wall corners of the floor directly below, so a roof drawn
         // on the upper floor aligns to the walls beneath it. Refreshed after each
         // roof commits. Both corners of the rectangle align.
         let alignmentCandidates = collectRoofAlignmentAnchors(sceneApi.nodes(), currentLevelId, roofType);
-        // Resolve a grid:move/click into the drafted corner via the shared surface
-        // snap pipeline: magnetic lock onto wall corners / midpoints / crossings /
-        // bodies on the active level + floor below (raising the green beacon),
-        // falling back to alignment guides, then to the world-grid snap. The same
-        // path the slab/ceiling tools use, so the beacon and coloring match. The
-        // pipeline reads the active snapping mode (grid / lines / angles / off),
-        // so this tool never inspects the flags. `levelId` is intentionally omitted
-        // so the explicit floor-below `walls` aren't filtered back out.
-        const resolveDraftPoint = (event) => {
-            const rawPoint = [event.localPosition[0], event.localPosition[2]];
-            const gridFallback = isGridSnapActive()
-                ? snapWorldXZForActiveBuilding(event.position[0], event.position[2], useEditor.getState().gridSnapStep).local
-                : rawPoint;
-            const nodes = sceneApi.nodes();
-            return resolveSurfacePlanPointSnap({
-                rawPoint,
-                fallbackPoint: gridFallback,
-                walls: getRoofSnapWalls(currentLevelId, nodes, roofType),
-                candidates: alignmentCandidates,
-                movingId: '__roof-draft__',
-                highlightWalls: true,
-            }).point;
-        };
+        const resolveDraftPoint = (event) => resolveRoofDraftPoint(event, currentLevelId, sceneApi.nodes(), roofType, alignmentCandidates);
         const updateFootprintPreview = (target) => {
             setFootprintTarget((previous) => (previous?.id === target?.id ? previous : target));
             if (previewTargetIdRef.current === (target?.id ?? null))
                 return;
             previewTargetIdRef.current = target?.id ?? null;
-            setPreviewSelectedIds(target?.wallIds ?? []);
+            setPreviewSelectedIds(roofFootprintPreviewIds(target));
         };
         const updateOutline = (corner1, corner2) => {
             let gridY = corner1[1] + GRID_OFFSET;
@@ -574,7 +540,9 @@ export const RoofTool = () => {
                 const centerZ = (corner1[2] + corner2[2]) / 2;
                 const diameter = Math.max(Math.abs(corner2[0] - corner1[0]), Math.abs(corner2[2] - corner1[2]));
                 const defaults = useEditor.getState().toolDefaults.roof;
-                const curbHeight = typeof defaults?.wallHeight === 'number' ? defaults.wallHeight : DEFAULT_WALL_HEIGHT;
+                const curbHeight = typeof defaults?.wallHeight === 'number'
+                    ? defaults.wallHeight
+                    : DEFAULT_CONICAL_CURB_HEIGHT;
                 const target = drawnRoofLevelTarget(sceneApi.nodes(), currentLevelId, 0, {
                     center: [centerX, centerZ],
                     width: diameter,
@@ -619,16 +587,20 @@ export const RoofTool = () => {
             outlineRef.current.geometry = new BufferGeometry().setFromPoints(groundPoints);
             outlineRef.current.visible = true;
         };
+        // In 2D-only view the plan's own roof tool owns the input (`floorplan-tool.tsx`); this tool,
+        // mounted behind the hidden canvas from an earlier visit, still hears the plan's grid events,
+        // so it must not also draft or commit (every roof would be made twice).
+        const planOwnsInput = () => visibleScene(useEditor.getState()) === '2d';
         const onGridMove = (event) => {
-            if (!cursorRef.current)
+            if (!cursorRef.current || planOwnsInput())
                 return;
             if (footprintSource !== 'draw') {
                 const [snappedX, snappedZ] = resolveDraftPoint(event);
                 let target = null;
                 if (footprintSource === 'room') {
-                    target = resolveRoomRoofFootprint(currentLevelId, sceneApi.nodes(), [snappedX, snappedZ], {
-                        rectangularOnly: true,
-                    });
+                    const room = pickRoofRoom(currentLevelId, sceneApi.nodes(), [snappedX, snappedZ]);
+                    target = room.target;
+                    useRoofFootprintSource.getState().setRoomPick(room.pick);
                     updateFootprintPreview(target);
                 }
                 cursorRef.current.position.set(snappedX, target
@@ -658,20 +630,26 @@ export const RoofTool = () => {
                 const draftPreview = useFloorplanDraftPreview.getState();
                 draftPreview.setRoofDraftStart([corner1Ref.current[0], corner1Ref.current[2]]);
                 draftPreview.setRoofDraftEnd([gridX, gridZ]);
+                syncDraftRidge(corner1Ref.current, cursorPosition);
                 updateOutline(corner1Ref.current, cursorPosition);
             }
+            lastCursor = cursorPosition;
         };
         const onGridClick = (event) => {
-            if (!currentLevelId)
+            if (!currentLevelId || planOwnsInput())
                 return;
             if (footprintSource !== 'draw') {
                 if (footprintSource !== 'room')
                     return;
                 const [snappedX, snappedZ] = resolveDraftPoint(event);
-                const target = resolveRoomRoofFootprint(currentLevelId, sceneApi.nodes(), [snappedX, snappedZ], { rectangularOnly: true });
+                const { target, pick } = pickRoofRoom(currentLevelId, sceneApi.nodes(), [
+                    snappedX,
+                    snappedZ,
+                ]);
+                useRoofFootprintSource.getState().setRoomPick(pick);
                 if (!target)
                     return;
-                const roofId = commitRoofFootprint(sceneApi, currentLevelId, target, quarterTurnRef.current);
+                const roofId = commitRoofFootprint(sceneApi, currentLevelId, target, useRoofRidgeMode.getState().mode);
                 if (roofId)
                     selectNode(roofId);
                 return;
@@ -679,7 +657,7 @@ export const RoofTool = () => {
             const [gridX, gridZ] = resolveDraftPoint(event);
             const y = event.localPosition[1];
             if (corner1Ref.current) {
-                const roofId = commitRoofPlacement(sceneApi, currentLevelId, corner1Ref.current, [gridX, y, gridZ], selectedIdsRef.current, quarterTurnRef.current, useRoofPlacementMode.getState().mode);
+                const roofId = commitRoofPlacement(sceneApi, currentLevelId, corner1Ref.current, [gridX, y, gridZ], selectedIdsRef.current, useRoofRidgeMode.getState().mode, useRoofPlacementMode.getState().mode);
                 if (!roofId)
                     return;
                 selectNode(roofId);
@@ -703,21 +681,32 @@ export const RoofTool = () => {
                 }));
             }
         };
+        const dropCorner = () => {
+            corner1Ref.current = null;
+            outlineRef.current.visible = false;
+            setPreview((prev) => ({ ...prev, corner1: null }));
+        };
+        // A corner opened before the view went 2D-only would end the next rectangle drawn back in
+        // split view. The plan's tool clears the shared draft as it takes over.
+        const unsubscribeView = useEditor.subscribe((state) => {
+            if (corner1Ref.current && visibleScene(state) === '2d')
+                dropCorner();
+        });
         const onCancel = () => {
             if (corner1Ref.current) {
                 markToolCancelConsumed();
-                corner1Ref.current = null;
+                dropCorner();
                 const draftPreview = useFloorplanDraftPreview.getState();
                 draftPreview.setRoofDraftStart(null);
                 draftPreview.setRoofDraftEnd(null);
-                outlineRef.current.visible = false;
-                setPreview((prev) => ({ ...prev, corner1: null }));
             }
             clearSurfacePlanSnapFeedback();
             previewTargetIdRef.current = null;
             setPreviewSelectedIds([]);
         };
         const onKeyDown = (event) => {
+            if (planOwnsInput())
+                return;
             if (event.target instanceof HTMLInputElement ||
                 event.target instanceof HTMLTextAreaElement ||
                 (event.target instanceof HTMLElement && event.target.isContentEditable)) {
@@ -743,12 +732,14 @@ export const RoofTool = () => {
                 return;
             }
             event.preventDefault();
-            const nextQuarterTurn = !quarterTurnRef.current;
-            quarterTurnRef.current = nextQuarterTurn;
-            setQuarterTurn(nextQuarterTurn);
-            useFloorplanDraftPreview.getState().setRoofDraftQuarterTurn(nextQuarterTurn);
+            useRoofRidgeMode.getState().toggle();
             triggerSFX('sfx:item-rotate');
         };
+        // The HUD chip flips the mode too; either way the 2D draft follows.
+        const unsubscribeRidgeMode = useRoofRidgeMode.subscribe(() => {
+            if (corner1Ref.current && lastCursor)
+                syncDraftRidge(corner1Ref.current, lastCursor);
+        });
         emitter.on('grid:move', onGridMove);
         emitter.on('grid:click', onGridClick);
         emitter.on('tool:cancel', onCancel);
@@ -788,11 +779,14 @@ export const RoofTool = () => {
             emitter.off('wall:leave', onWallLeave);
             unsubscribeConicalRoofWallClicks();
             window.removeEventListener('keydown', onKeyDown);
+            unsubscribeRidgeMode();
+            unsubscribeView();
             clearSurfacePlanSnapFeedback();
             previewTargetIdRef.current = null;
             setPreviewedConicalWallId(null);
             setInvalidStandardWallHover(false);
             setPreviewSelectedIds([]);
+            useRoofFootprintSource.getState().setRoomPick(null);
             corner1Ref.current = null;
             const draftPreview = useFloorplanDraftPreview.getState();
             draftPreview.setRoofDraftStart(null);
@@ -869,7 +863,8 @@ export const RoofTool = () => {
                 arc.center.x,
                 currentLevelId
                     ? resolveRoofWallTopWorldElevation(currentLevelId, wall, nodes)
-                    : getWallBaseElevationForNodes(wall, nodes) + getWallEffectiveHeightForNodes(wall, nodes),
+                    : getWallBaseElevationForNodes(wall, nodes) +
+                        getWallEffectiveHeightForNodes(wall, nodes, 0),
                 arc.center.y,
             ],
         };
@@ -899,33 +894,19 @@ export const RoofTool = () => {
             !resolvedPreviewDimensions ||
             (roofType === 'conical' && footprintSource !== 'draw'))
             return null;
-        const placement = resolveRoofDraftPlacement(resolvedPreviewDimensions.length, resolvedPreviewDimensions.width, quarterTurn, 0, roofType);
-        return buildRoofGhostGeometry(placement.width, placement.depth, ghostWallHeight, previewPitch, roofType);
-    }, [
-        footprintSource,
-        ghostWallHeight,
-        invalidStandardWallHover,
-        previewPitch,
-        quarterTurn,
-        resolvedPreviewDimensions,
-        roofType,
-    ]);
-    const roofGhostEdges = useMemo(() => {
-        if (invalidStandardWallHover ||
-            !resolvedPreviewDimensions ||
-            (roofType === 'conical' && footprintSource !== 'draw'))
-            return null;
-        const placement = resolveRoofDraftPlacement(resolvedPreviewDimensions.length, resolvedPreviewDimensions.width, quarterTurn, 0, roofType);
-        return buildRoofGhostEdges(placement.width, placement.depth, ghostWallHeight, previewPitch, roofType);
+        const placement = resolveRoofDraftPlacement(resolvedPreviewDimensions.length, resolvedPreviewDimensions.width, ridgeMode, 0, roofType);
+        return buildRoofGhostGeometry(placement.width, placement.depth, ghostWallHeight, previewPitch, roofType, roofDefaults);
     }, [
         footprintSource,
         ghostWallHeight,
         invalidStandardWallHover,
         previewPitch,
-        quarterTurn,
+        ridgeMode,
         resolvedPreviewDimensions,
         roofType,
+        roofDefaults,
     ]);
+    const roofGhostEdges = useMemo(() => (roofGhostGeometry ? new THREE.EdgesGeometry(roofGhostGeometry, 10) : null), [roofGhostGeometry]);
     useEffect(() => {
         if (invalidStandardWallHover)
             outlineRef.current.visible = false;
@@ -954,7 +935,10 @@ export const RoofTool = () => {
                 ], rotation: [
                     0,
                     (footprintSource !== 'draw' ? (footprintTarget?.rotation ?? 0) : 0) +
-                        (roofType === 'conical' ? 0 : quarterTurn ? Math.PI / 2 : 0),
+                        (roofType !== 'conical' &&
+                            ridgeQuarterTurn(resolvedPreviewDimensions.length, resolvedPreviewDimensions.width, ridgeMode)
+                            ? Math.PI / 2
+                            : 0),
                     0,
                 ], children: [roofGhostGeometry && (_jsx("mesh", { geometry: roofGhostGeometry, layers: EDITOR_LAYER, renderOrder: 1, children: _jsx("meshBasicMaterial", { color: ghostColor, depthTest: false, depthWrite: false, opacity: 0.16, side: DoubleSide, transparent: true }) })), roofGhostEdges && (_jsx("lineSegments", { geometry: roofGhostEdges, layers: EDITOR_LAYER, renderOrder: 2, children: _jsx("lineBasicMaterial", { color: ghostColor, depthTest: false, depthWrite: false, opacity: 0.5, transparent: true }) }))] }))] }));
 };