@pascal-app/nodes 1.0.5 → 1.0.7

package/dist/roof/barrel-panel.js

@@ -1,17 +1,21 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { getActiveRoofHeight, getEffectiveNode, useLiveNodeOverrides, } from '@pascal-app/core';
+import { getActiveRoofHeight, getEffectiveNode, useLiveNodeOverrides, usePascalI18n, } from '@pascal-app/core';
 import { getLinearUnitLabel, linearControlValueToMeters, metersToLinearUnit, PanelSection, SliderControl, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useEffect, useMemo } from 'react';
 import { createRoofGlazingPreview } from './glazing-preview.js';
 export function BarrelRoofPanel({ node: stored }) {
+    const i18n = usePascalI18n();
     useLiveNodeOverrides((state) => state.overrides.get(stored.id));
     const node = getEffectiveNode(stored);
     const unit = useViewer((state) => state.unit);
     const preview = useMemo(() => createRoofGlazingPreview([stored.id]), [stored.id]);
     useEffect(() => () => preview.cancel(), [preview]);
-    return (_jsxs(PanelSection, { title: "Barrel arch", children: [_jsx(SliderControl, { label: "Rise", min: metersToLinearUnit(0.01, unit), max: metersToLinearUnit(node.depth / 2, unit), step: 0.1, precision: 2, unit: getLinearUnitLabel(unit), value: metersToLinearUnit(getActiveRoofHeight(node), unit), onChange: (value) => preview.previewFields({
+    return (_jsxs(PanelSection, { title: i18n._({ id: 'node.roof.barrelPanel.barrelArch', message: 'Barrel arch' }), children: [_jsx(SliderControl, { label: i18n._({ id: 'node.roof.barrelPanel.rise', message: 'Rise' }), min: metersToLinearUnit(0.01, unit), max: metersToLinearUnit(node.depth / 2, unit), step: 0.1, precision: 2, unit: getLinearUnitLabel(unit), value: metersToLinearUnit(getActiveRoofHeight(node), unit), onChange: (value) => preview.previewFields({
                     barrelRise: Math.min(node.depth / 2, linearControlValueToMeters(value, unit, { minMeters: 0.01 })),
-                }), onCommit: preview.finish, onCancel: preview.cancel, restoreOnCommit: false, previewWhileTyping: true }), _jsx(SliderControl, { label: "Arch bays", min: 4, max: 32, step: 1, precision: 0, value: node.barrelSegments ?? 12, onChange: (value) => preview.previewFields({ barrelSegments: Math.round(value) }), onCommit: preview.finish, onCancel: preview.cancel, restoreOnCommit: false, previewWhileTyping: true }), _jsx("p", { className: "px-1 text-xs text-muted-foreground", children: "Flat panes follow a circular arch. Rise is measured from the eaves." })] }));
+                }), onCommit: preview.finish, onCancel: preview.cancel, restoreOnCommit: false, previewWhileTyping: true }), _jsx(SliderControl, { label: i18n._({ id: 'node.roof.barrelPanel.archBays', message: 'Arch bays' }), min: 4, max: 32, step: 1, precision: 0, value: node.barrelSegments ?? 12, onChange: (value) => preview.previewFields({ barrelSegments: Math.round(value) }), onCommit: preview.finish, onCancel: preview.cancel, restoreOnCommit: false, previewWhileTyping: true }), _jsx("p", { className: "px-1 text-xs text-muted-foreground", children: i18n._({
+                    id: 'node.roof.barrelPanel.flatPanesFollowACircularArch',
+                    message: 'Flat panes follow a circular arch. Rise is measured from the eaves.',
+                }) })] }));
 }

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/roof/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,cAAc,EAKpB,MAAM,kBAAkB,CAAA;AAczB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAsFnC;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CA6K1D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/roof/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,cAAc,EAKpB,MAAM,kBAAkB,CAAA;AAsBzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAsFnC;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAwM1D,CAAA"}

package/dist/roof/definition.js

@@ -1,10 +1,13 @@
 import { RoofNode as RoofNodeSchema, } from '@pascal-app/core';
-import { DRAFTING_SURFACE_EXTENSION_KEY, PANEL_MODEL_EXTENSION, } from '@pascal-app/editor';
+import { DRAFTING_SURFACE_EXTENSION_KEY, FLOORPLAN_NODE_EXTENSION_KEY, PANEL_MODEL_EXTENSION, } from '@pascal-app/editor';
 import { buildRoofFloorplan } from './floorplan.js';
+import { roofFloorplanAffectedIds, roofFloorplanSiblingOverrides } from './floorplan-overrides.js';
+import { roofPaint } from './paint.js';
 import { roofPanelModel } from './panel-model.js';
 import { roofParametrics } from './parametrics.js';
-import useRoofFootprintSource from './roof-footprint-source.js';
+import useRoofFootprintSource, { irregularRoomHintVisibility, noRoomHintVisibility, } from './roof-footprint-source.js';
 import useRoofPlacementMode, { conicalRoofToolHintVisibility, standardRoofToolHintVisibility, } from './roof-placement-mode.js';
+import useRoofRidgeMode from './roof-ridge-mode.js';
 import { RoofNode } from './schema.js';
 const MOVE_FRONT_OFFSET = 0.35;
 const MIN_ROOF_FOOTPRINT = 1;
@@ -95,6 +98,9 @@ export const roofDefinition = {
         [DRAFTING_SURFACE_EXTENSION_KEY]: {
             kind: 'roof',
         },
+        [FLOORPLAN_NODE_EXTENSION_KEY]: {
+            tool: () => import('./floorplan-tool.js'),
+        },
     },
     defaults: () => {
         const stub = RoofNodeSchema.parse({ id: 'roof_default', type: 'roof' });
@@ -103,6 +109,7 @@ export const roofDefinition = {
     },
     capabilities: {
         exterior: true,
+        paint: roofPaint,
         reveal: {
             phase: 'roof',
             style: 'assemble',
@@ -201,9 +208,30 @@ export const roofDefinition = {
         },
         {
             key: 'R',
-            label: 'Rotate roof direction 90°',
+            label: 'Ridge direction',
             visible: standardRoofToolHintVisibility,
+            chip: {
+                subscribe: (onChange) => useRoofRidgeMode.subscribe(onChange),
+                value: () => useRoofRidgeMode.getState().mode,
+                cycle: () => useRoofRidgeMode.getState().toggle(),
+                labels: {
+                    long: 'Ridge: Long side',
+                    short: 'Ridge: Short side',
+                },
+                icons: {
+                    long: 'lucide:rectangle-horizontal',
+                    short: 'lucide:rectangle-vertical',
+                },
+                tooltip: 'Ridge direction - click or press R to turn it 90°',
+            },
+        },
+        // Room makes nothing where there is no room to roof: say why, where a click would do nothing.
+        {
+            key: 'Room',
+            label: 'Not a rectangle: draw this roof instead',
+            visible: irregularRoomHintVisibility,
         },
+        { key: 'Room', label: 'Point inside a room, porch or deck', visible: noRoomHintVisibility },
         { key: 'Esc', label: 'Cancel' },
     ],
     toolOptions: [
@@ -232,6 +260,8 @@ export const roofDefinition = {
     parametrics: roofParametrics,
     handles: resolveRoofHandles,
     floorplan: buildRoofFloorplan,
+    floorplanSiblingOverrides: roofFloorplanSiblingOverrides,
+    floorplanAffectedIds: roofFloorplanAffectedIds,
     rendersChildren: false,
     renderer: {
         kind: 'parametric',

package/dist/roof/floorplan-overrides.d.ts

@@ -0,0 +1,22 @@
+import type { AnyNode, AnyNodeId, LiveTransformLike } from '@pascal-app/core';
+/**
+ * A roof's plan is drawn by the roof node from its segments (`ctx.children`) and its level's
+ * other roofs (`ctx.siblings`), which a drag moves through live overrides and transforms, not the
+ * scene. Projecting those into the builder's snapshot keeps the outline, ridges, hips and valleys
+ * on the segment while it is moved, resized or turned, in 2D or 3D.
+ */
+export declare function roofFloorplanSiblingOverrides(args: {
+    nodeId: AnyNodeId;
+    nodes: Record<AnyNodeId, AnyNode>;
+    liveTransforms: Map<string, LiveTransformLike>;
+    liveOverrides: Map<string, Record<string, unknown>>;
+}): Record<AnyNodeId, AnyNode>;
+/**
+ * The roofs whose plan a live roof or segment edit changes: every roof on its level, since a
+ * wing's ridge runs on to the main roof's slope and their valleys are drawn by one of the two.
+ */
+export declare function roofFloorplanAffectedIds(args: {
+    node: AnyNode;
+    nodes: Record<AnyNodeId, AnyNode>;
+}): readonly AnyNodeId[];
+//# sourceMappingURL=floorplan-overrides.d.ts.map

package/dist/roof/floorplan-overrides.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-overrides.d.ts","sourceRoot":"","sources":["../../src/roof/floorplan-overrides.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAK7E;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,IAAI,EAAE;IAClD,MAAM,EAAE,SAAS,CAAA;IACjB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAA;IAC9C,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CACpD,GAAG,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAsB7B;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE;IAC7C,IAAI,EAAE,OAAO,CAAA;IACb,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;CAClC,GAAG,SAAS,SAAS,EAAE,CASvB"}

package/dist/roof/floorplan-overrides.js

@@ -0,0 +1,46 @@
+const isRoofPart = (node) => node?.type === 'roof' || node?.type === 'roof-segment';
+/**
+ * A roof's plan is drawn by the roof node from its segments (`ctx.children`) and its level's
+ * other roofs (`ctx.siblings`), which a drag moves through live overrides and transforms, not the
+ * scene. Projecting those into the builder's snapshot keeps the outline, ridges, hips and valleys
+ * on the segment while it is moved, resized or turned, in 2D or 3D.
+ */
+export function roofFloorplanSiblingOverrides(args) {
+    const { nodes, liveOverrides, liveTransforms } = args;
+    if (liveOverrides.size === 0 && liveTransforms.size === 0)
+        return nodes;
+    let out = null;
+    for (const [id, live] of liveTransforms) {
+        const existing = nodes[id];
+        if (!isRoofPart(existing))
+            continue;
+        out ??= { ...nodes };
+        out[id] = {
+            ...existing,
+            position: live.position,
+            rotation: live.rotation,
+        };
+    }
+    for (const [id, override] of liveOverrides) {
+        const existing = out?.[id] ?? nodes[id];
+        if (!isRoofPart(existing) || Object.keys(override).length === 0)
+            continue;
+        out ??= { ...nodes };
+        out[id] = { ...existing, ...override };
+    }
+    return out ?? nodes;
+}
+/**
+ * The roofs whose plan a live roof or segment edit changes: every roof on its level, since a
+ * wing's ridge runs on to the main roof's slope and their valleys are drawn by one of the two.
+ */
+export function roofFloorplanAffectedIds(args) {
+    const { node, nodes } = args;
+    const roof = node.type === 'roof-segment' && node.parentId ? nodes[node.parentId] : node;
+    if (roof?.type !== 'roof')
+        return [];
+    const level = roof.parentId ? nodes[roof.parentId] : undefined;
+    const onLevel = level?.children ?? [];
+    const roofs = onLevel.filter((id) => id !== roof.id && nodes[id]?.type === 'roof');
+    return [roof.id, ...roofs];
+}

package/dist/roof/floorplan-tool.d.ts

@@ -0,0 +1,9 @@
+import { type FloorplanToolContext } from '@pascal-app/editor';
+/**
+ * The roof tool in 2D-only view. The 3D `RoofTool` lives in the canvas, which never renders while
+ * its pane is hidden, so in 2D-only view this commits instead, from the plan's own grid events: it
+ * snaps the corners, writes them into the plan's draft rectangle (or hovers the room, or for a cone
+ * the curved wall) and writes the roof. Split and 3D views keep the 3D tool as the one owner.
+ */
+export default function RoofFloorplanTool({ activeLevelId, sceneApi, selectNode, }: FloorplanToolContext): null;
+//# sourceMappingURL=floorplan-tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-tool.d.ts","sourceRoot":"","sources":["../../src/roof/floorplan-tool.tsx"],"names":[],"mappings":"AASA,OAAO,EAEL,KAAK,oBAAoB,EAM1B,MAAM,oBAAoB,CAAA;AAoB3B;;;;;GAKG;AACH,MAAM,CAAC,OAAO,UAAU,iBAAiB,CAAC,EACxC,aAAa,EACb,QAAQ,EACR,UAAU,GACX,EAAE,oBAAoB,QAkLtB"}

package/dist/roof/floorplan-tool.js

@@ -0,0 +1,168 @@
+'use client';
+import { emitter, RoofType as RoofTypeSchema, } from '@pascal-app/core';
+import { clearSurfacePlanSnapFeedback, markToolCancelConsumed, triggerSFX, useEditor, useFloorplanDraftPreview, visibleScene, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useEffect } from 'react';
+import { createConicalRoofSectorAboveWall } from './conical-roof.js';
+import { parseRoofFootprintSource, pickConicalRoofWall, pickRoofRoom, roofFootprintPreviewIds, } from './roof-footprint.js';
+import useRoofFootprintSource from './roof-footprint-source.js';
+import useRoofPlacementMode from './roof-placement-mode.js';
+import useRoofRidgeMode, { ridgeQuarterTurn } from './roof-ridge-mode.js';
+import { collectRoofAlignmentAnchors, commitRoofFootprint, commitRoofPlacement, resolveRoofDraftPoint, } from './tool.js';
+/**
+ * The roof tool in 2D-only view. The 3D `RoofTool` lives in the canvas, which never renders while
+ * its pane is hidden, so in 2D-only view this commits instead, from the plan's own grid events: it
+ * snaps the corners, writes them into the plan's draft rectangle (or hovers the room, or for a cone
+ * the curved wall) and writes the roof. Split and 3D views keep the 3D tool as the one owner.
+ */
+export default function RoofFloorplanTool({ activeLevelId, sceneApi, selectNode, }) {
+    const planOwnsInput = useEditor((state) => visibleScene(state) === '2d');
+    const levelId = planOwnsInput ? activeLevelId : null;
+    const roofType = useEditor((state) => {
+        const parsed = RoofTypeSchema.safeParse(state.toolDefaults.roof?.roofType);
+        return parsed.success ? parsed.data : 'gable';
+    });
+    // A new source or roof type starts over, as the 3D tool does: a first corner kept across it
+    // would end the next rectangle with no draft on the plan to show it.
+    const source = useRoofFootprintSource((state) => parseRoofFootprintSource(state.source, roofType));
+    useEffect(() => {
+        if (!levelId)
+            return;
+        let corner1 = null;
+        const draft = useFloorplanDraftPreview.getState;
+        // A rectangle the 3D tool opened before the view changed has no first corner here: drop it, or
+        // the plan's draft and this tool's corner fall out of step (each click starts one, ends the other).
+        const clearDraft = () => {
+            draft().setRoofDraftStart(null);
+            draft().setRoofDraftEnd(null);
+            draft().setRoofDraftQuarterTurn(false);
+        };
+        clearDraft();
+        // Snapped as the 3D tool snaps in split view (onto the walls below too), so the same clicks
+        // make the same roof in either view.
+        let alignmentCandidates = collectRoofAlignmentAnchors(sceneApi.nodes(), levelId, roofType);
+        const planPoint = (event) => resolveRoofDraftPoint(event, levelId, sceneApi.nodes(), roofType, alignmentCandidates);
+        let previewedId = null;
+        const preview = (target) => {
+            if ((target?.id ?? null) === previewedId)
+                return;
+            previewedId = target?.id ?? null;
+            useViewer.getState().setPreviewSelectedIds(target?.ids ?? []);
+        };
+        const conicalWall = (event) => pickConicalRoofWall(levelId, sceneApi.nodes(), [
+            event.localPosition[0],
+            event.localPosition[2],
+        ]);
+        const onMove = (event) => {
+            if (source === 'walls') {
+                const wall = conicalWall(event);
+                preview(wall && { id: wall.id, ids: [wall.id] });
+                return;
+            }
+            if (source === 'room') {
+                const room = pickRoofRoom(levelId, sceneApi.nodes(), planPoint(event));
+                useRoofFootprintSource.getState().setRoomPick(room.pick);
+                preview(room.target && { id: room.target.id, ids: roofFootprintPreviewIds(room.target) });
+                return;
+            }
+            const [x, z] = planPoint(event);
+            if (!corner1)
+                return;
+            draft().setRoofDraftEnd([x, z]);
+            draft().setRoofDraftQuarterTurn(ridgeQuarterTurn(Math.abs(x - corner1[0]), Math.abs(z - corner1[2]), useRoofRidgeMode.getState().mode));
+        };
+        const onClick = (event) => {
+            if (source === 'walls') {
+                const wall = conicalWall(event);
+                if (!wall)
+                    return;
+                preview(null);
+                const segmentId = createConicalRoofSectorAboveWall(wall, sceneApi.nodes(), sceneApi, levelId);
+                if (segmentId)
+                    selectNode(segmentId);
+                return;
+            }
+            if (source === 'room') {
+                const { target, pick } = pickRoofRoom(levelId, sceneApi.nodes(), planPoint(event));
+                useRoofFootprintSource.getState().setRoomPick(pick);
+                if (!target)
+                    return;
+                const roofId = commitRoofFootprint(sceneApi, levelId, target, useRoofRidgeMode.getState().mode);
+                if (roofId)
+                    selectNode(roofId);
+                return;
+            }
+            const [x, z] = planPoint(event);
+            const corner = [x, event.localPosition[1], z];
+            if (!corner1) {
+                corner1 = corner;
+                draft().setRoofDraftStart([x, z]);
+                draft().setRoofDraftEnd([x, z]);
+                triggerSFX('sfx:structure-build-start');
+                return;
+            }
+            const roofId = commitRoofPlacement(sceneApi, levelId, corner1, corner, useViewer.getState().selection.selectedIds, useRoofRidgeMode.getState().mode, useRoofPlacementMode.getState().mode);
+            corner1 = null;
+            clearDraft();
+            alignmentCandidates = collectRoofAlignmentAnchors(sceneApi.nodes(), levelId, roofType);
+            clearSurfacePlanSnapFeedback();
+            if (roofId)
+                selectNode(roofId);
+        };
+        const onCancel = () => {
+            if (!corner1)
+                return;
+            markToolCancelConsumed();
+            corner1 = null;
+            clearDraft();
+        };
+        const onKeyDown = (event) => {
+            const target = event.target;
+            if (target instanceof HTMLInputElement ||
+                target instanceof HTMLTextAreaElement ||
+                (target instanceof HTMLElement && target.isContentEditable))
+                return;
+            if (event.repeat || event.metaKey || event.ctrlKey || event.altKey)
+                return;
+            const key = event.key.toLowerCase();
+            // As in 3D: P cycles a cone's placement surface, R turns a drawn roof's ridge.
+            if (source === 'walls') {
+                if (key !== 'p')
+                    return;
+                event.preventDefault();
+                useRoofPlacementMode.getState().cycleMode();
+                triggerSFX('sfx:grid-snap');
+                return;
+            }
+            if (key !== 'r')
+                return;
+            event.preventDefault();
+            useRoofRidgeMode.getState().toggle();
+            triggerSFX('sfx:item-rotate');
+        };
+        // The HUD chip flips the ridge too; the draft's ridge line follows either way.
+        const unsubscribeRidgeMode = useRoofRidgeMode.subscribe(() => {
+            const start = draft().roofDraftStart;
+            const end = draft().roofDraftEnd;
+            if (!(corner1 && start && end))
+                return;
+            draft().setRoofDraftQuarterTurn(ridgeQuarterTurn(Math.abs(end[0] - start[0]), Math.abs(end[1] - start[1]), useRoofRidgeMode.getState().mode));
+        });
+        emitter.on('grid:move', onMove);
+        emitter.on('grid:click', onClick);
+        emitter.on('tool:cancel', onCancel);
+        window.addEventListener('keydown', onKeyDown);
+        return () => {
+            emitter.off('grid:move', onMove);
+            emitter.off('grid:click', onClick);
+            emitter.off('tool:cancel', onCancel);
+            window.removeEventListener('keydown', onKeyDown);
+            unsubscribeRidgeMode();
+            useRoofFootprintSource.getState().setRoomPick(null);
+            preview(null);
+            clearDraft();
+            clearSurfacePlanSnapFeedback();
+        };
+    }, [levelId, roofType, sceneApi, selectNode, source]);
+    return null;
+}

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/roof/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAGpB,KAAK,QAAQ,EAKd,MAAM,kBAAkB,CAAA;AA2BzB;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAMvD;AA8LD;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CA0MjG"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/roof/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAIpB,KAAK,QAAQ,EAKd,MAAM,kBAAkB,CAAA;AAyCzB;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAMvD;AAqPD;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAmPjG"}

package/dist/roof/floorplan.js

@@ -1,6 +1,7 @@
-import { getGlazedRoofPlanLines, getRoofSegmentVisibleTopBounds, roofPlanOverlapEntryOwns, subtractPolygonsFromPolygon, unionPolygons, } from '@pascal-app/core';
+import { getGlazedRoofPlanLines, getRoofSegmentVisibleTopBounds, getSegmentSlopeFrame, roofPlanOverlapEntryOwns, subtractPolygonsFromPolygon, unionPolygons, } from '@pascal-app/core';
 import { floorplanGeometryMetadata, readFloorplanContext } from '@pascal-app/editor';
 import { getConicalRoofPlanFootprint, getRoofSegmentPlanLinework } from '../roof-segment/floorplan.js';
+import { getRoofSurfaceCreases } from './roof-plan-creases.js';
 /**
  * `roof-segment.pitch` is stored in DEGREES; a roof plan is annotated as the
  * rise over a 12 run. 30.256° → tan 0.5833 × 12 → 7.00 → '7:12'. Rounded to
@@ -78,6 +79,34 @@ function overlapEntry(entry, ctx) {
         depth: entry.segment.depth,
     };
 }
+/**
+ * A planar form's roof planes in segment-local plan coordinates, each as
+ * `[gx, gz, c]` with height `c + gx·lx + gz·lz` above the eave: every slope
+ * rises at the pitch from its eave line. `null` for the forms with curved or
+ * broken slopes, which keep their own linework.
+ */
+function localRoofPlanes(seg) {
+    const hw = Math.max(seg.width, 0.01) / 2;
+    const hd = Math.max(seg.depth, 0.01) / 2;
+    const tan = getSegmentSlopeFrame(seg).tanTheta;
+    const towardPlusZ = [0, -tan, tan * hd];
+    const towardMinusZ = [0, tan, tan * hd];
+    const towardPlusX = [-tan, 0, tan * hw];
+    const towardMinusX = [tan, 0, tan * hw];
+    switch (seg.roofType) {
+        case 'flat':
+            return [[0, 0, 0]];
+        case 'shed':
+            // high eave at lz = −hd, falling to +hd, as the 3D builder slopes it
+            return [towardPlusZ];
+        case 'gable':
+            return [towardPlusZ, towardMinusZ];
+        case 'hip':
+            return [towardPlusZ, towardMinusZ, towardPlusX, towardMinusX];
+        default:
+            return null;
+    }
+}
 /** A segment's footprint + ridge/hip/break/slope linework, in world plan coords. */
 function buildSegPlan(roof, seg, drafting) {
     const cosRoof = Math.cos(-roof.rotation);
@@ -93,18 +122,48 @@ function buildSegPlan(roof, seg, drafting) {
     ];
     const hw = Math.max(seg.width, 0.01) / 2;
     const hd = Math.max(seg.depth, 0.01) / 2;
+    const conical = seg.roofType === 'conical';
+    // The drip edge: core's own visible-top bounds, which add the horizontal
+    // component of `overhang` (plus half the wall thickness and, on the sloped
+    // faces, the shingle projection) to the footprint on each side.
+    const edge = getRoofSegmentVisibleTopBounds(seg);
+    // In the editor a line that ends on the wall line runs on to the eave or
+    // rake, as the 3D's hips, ridges and slope breaks do.
+    const toEdge = (v, half, min, max) => Math.abs(v - half) < 1e-6 ? max : Math.abs(v + half) < 1e-6 ? min : v;
+    const reach = drafting || conical ? null : edge;
+    const mapSeg = (s) => s.map(([lx, lz]) => reach
+        ? tp(toEdge(lx, hw, reach.minX, reach.maxX), toEdge(lz, hd, reach.minZ, reach.maxZ))
+        : tp(lx, lz));
     const lw = getRoofSegmentPlanLinework(seg);
-    const mapSeg = (s) => [
-        tp(s[0][0], s[0][1]),
-        tp(s[1][0], s[1][1]),
-    ];
-    const footprint = seg.roofType === 'conical'
+    const footprint = conical
         ? getConicalRoofPlanFootprint(seg).map(([x, z]) => tp(x, z))
         : [tp(-hw, -hd), tp(hw, -hd), tp(hw, hd), tp(-hw, hd)];
+    const eave = [
+        tp(edge.minX, edge.minZ),
+        tp(edge.maxX, edge.minZ),
+        tp(edge.maxX, edge.maxZ),
+        tp(edge.minX, edge.maxZ),
+    ];
+    const outline = reach ? eave : footprint;
     const ridges = lw.ridges.map(mapSeg);
     const hips = lw.hips.map(mapSeg);
     const breaks = lw.breaks.map(mapSeg);
-    const glazing = getGlazedRoofPlanLines(seg).map(mapSeg);
+    const glazing = getGlazedRoofPlanLines(seg).map(([a, b]) => [tp(a[0], a[1]), tp(b[0], b[1])]);
+    const local = localRoofPlanes(seg);
+    // Heights in the roof's level frame, so the planes of two roofs side by side
+    // compare. The planes run on past the wall line, as the overhang does.
+    const base = roof.position[1] + seg.position[1] + seg.wallHeight;
+    const surface = local
+        ? {
+            roofId: String(roof.id),
+            footprint: outline,
+            planes: local.map(([gx, gz, c0]) => {
+                const a = gx * cos - gz * sin;
+                const b = gx * sin + gz * cos;
+                return { a, b, c: base + c0 - a * segCx - b * segCz };
+            }),
+        }
+        : null;
     if (!drafting) {
         const slopes = lw.slope
             ? [
@@ -115,25 +174,18 @@ function buildSegPlan(roof, seg, drafting) {
                 },
             ]
             : [];
-        return { footprint, eave: footprint, ridges, hips, breaks, glazing, slopes };
+        return { footprint, eave, outline, ridges, hips, breaks, glazing, slopes, surface };
     }
-    // The drip edge: core's own visible-top bounds, which add the horizontal
-    // component of `overhang` (plus half the wall thickness and, on the sloped
-    // faces, the shingle projection) to the footprint on each side.
-    const edge = getRoofSegmentVisibleTopBounds(seg);
     const pitch = seg.roofType === 'barrel' ? '' : roofPitchLabel(seg.pitch);
     return {
         footprint,
-        eave: [
-            tp(edge.minX, edge.minZ),
-            tp(edge.maxX, edge.minZ),
-            tp(edge.maxX, edge.maxZ),
-            tp(edge.minX, edge.maxZ),
-        ],
+        eave,
+        outline,
         ridges,
         hips,
         breaks,
         glazing,
+        surface,
         slopes: slopeArrows(seg).map((arrow) => ({
             tail: tp(arrow.tail[0], arrow.tail[1]),
             head: tp(arrow.head[0], arrow.head[1]),
@@ -234,26 +286,25 @@ export function buildRoofFloorplan(node, ctx) {
         }
     }
     const currentEntries = entries.filter((entry) => entry.roof.id === node.id);
+    const owningCandidates = (entry) => entries.filter((candidate) => {
+        if (candidate.segment.id === entry.segment.id)
+            return false;
+        if (candidate.segment.roofType === 'shed')
+            return false;
+        return roofPlanOverlapEntryOwns(overlapEntry(candidate, ctx), overlapEntry(entry, ctx));
+    });
     const visiblePlans = currentEntries.map((entry) => {
-        const cutters = entries
-            .filter((candidate) => {
-            if (candidate.segment.id === entry.segment.id)
-                return false;
-            if (candidate.segment.roofType === 'shed')
-                return false;
-            return roofPlanOverlapEntryOwns(overlapEntry(candidate, ctx), overlapEntry(entry, ctx));
-        })
-            .map((candidate) => candidate.plan.footprint);
+        const cutters = owningCandidates(entry).map((candidate) => candidate.plan.outline);
         return {
             plan: entry.plan,
             cutters,
-            footprints: subtractPolygonsFromPolygon(entry.plan.footprint, cutters),
+            outlines: subtractPolygonsFromPolygon(entry.plan.outline, cutters),
             eaves: subtractPolygonsFromPolygon(entry.plan.eave, cutters),
             /** True when the drip edge is far enough outside the wall line to draw. */
             hasOverhang: drafting && polygonSpread(entry.plan.eave) - polygonSpread(entry.plan.footprint) > 0.04,
         };
     });
-    const rings = unionPolygons(visiblePlans.flatMap(({ footprints }) => footprints));
+    const rings = unionPolygons(visiblePlans.flatMap(({ outlines }) => outlines));
     if (rings.length === 0)
         return null;
     const eaveRings = unionPolygons(visiblePlans.flatMap(({ eaves, hasOverhang }) => (hasOverhang ? eaves : [])));
@@ -303,7 +354,7 @@ export function buildRoofFloorplan(node, ctx) {
             pointerEvents: 'none',
         });
     }
-    // Merged outline (wall line under the roof).
+    // Merged outline: the eave and rake in the editor, the wall line on a sheet.
     for (const ring of rings) {
         if (ring.length < 3)
             continue;
@@ -317,24 +368,63 @@ export function buildRoofFloorplan(node, ctx) {
             pointerEvents: 'none',
         });
     }
+    // Selected or moved, the wall line each segment stands on: whether the roof sits on the walls'
+    // centre lines (a selected segment draws its own).
+    if (!drafting && palette && ((view?.moving ?? false) || showSelectedChrome)) {
+        for (const { plan } of visiblePlans) {
+            children.push({
+                kind: 'polygon',
+                points: plan.footprint.map(([x, z]) => [x, z]),
+                fill: 'none',
+                stroke: palette.selectedStroke,
+                strokeWidth: 0.035,
+                strokeLinejoin: 'miter',
+                pointerEvents: 'none',
+            });
+        }
+    }
+    // Ridges, hips and valleys of the planar segments, off the surface they make
+    // together with this level's other roofs: a wing's ridge runs on until it
+    // meets the main roof's slope, and a valley runs where the two slopes meet.
+    // The curved and broken forms are not in that surface: where one owns an
+    // overlap it cuts these lines as before.
+    const planarEntries = entries.filter((entry) => entry.plan.surface);
+    const curvedCutters = (entry) => owningCandidates(entry)
+        .filter((candidate) => !candidate.plan.surface)
+        .map((candidate) => candidate.plan.outline);
+    for (const crease of getRoofSurfaceCreases(planarEntries.map((entry) => entry.plan.surface))) {
+        if (crease.roofId !== String(node.id))
+            continue;
+        const [i, k] = crease.between;
+        const cutters = [
+            ...curvedCutters(planarEntries[i]),
+            ...(k === i ? [] : curvedCutters(planarEntries[k])),
+        ];
+        const width = crease.kind === 'ridge' ? ridgeWidth : hipWidth;
+        for (const visible of clipLineByCutters([crease.from, crease.to], cutters))
+            pushLine(visible[0], visible[1], width);
+    }
     for (const { plan, cutters } of visiblePlans) {
         for (const line of plan.glazing) {
             for (const visible of clipLineByCutters(line, cutters))
                 pushLine(visible[0], visible[1], hipWidth);
         }
-        for (const line of plan.breaks) {
-            for (const visible of clipLineByCutters(line, cutters)) {
-                pushLine(visible[0], visible[1], hipWidth);
+        // A planar segment's ridges and hips were drawn off the shared surface above.
+        if (!plan.surface) {
+            for (const line of plan.breaks) {
+                for (const visible of clipLineByCutters(line, cutters)) {
+                    pushLine(visible[0], visible[1], hipWidth);
+                }
             }
-        }
-        for (const line of plan.hips) {
-            for (const visible of clipLineByCutters(line, cutters)) {
-                pushLine(visible[0], visible[1], hipWidth);
+            for (const line of plan.hips) {
+                for (const visible of clipLineByCutters(line, cutters)) {
+                    pushLine(visible[0], visible[1], hipWidth);
+                }
             }
-        }
-        for (const line of plan.ridges) {
-            for (const visible of clipLineByCutters(line, cutters)) {
-                pushLine(visible[0], visible[1], ridgeWidth);
+            for (const line of plan.ridges) {
+                for (const visible of clipLineByCutters(line, cutters)) {
+                    pushLine(visible[0], visible[1], ridgeWidth);
+                }
             }
         }
         // One down-slope arrow per roof plane, each tagged with the pitch in

package/dist/roof/glazing-controls.d.ts

@@ -1,4 +1,5 @@
 import type { CurtainGrid, RoofGlazing } from '@pascal-app/core';
+import { type MessageDescriptor } from '@pascal-app/core';
 import type { createRoofGlazingPreview } from './glazing-preview.js';
 type Preview = ReturnType<typeof createRoofGlazingPreview>;
 type NumberField = 'frameWidth' | 'frameDepth' | 'glassThickness' | 'glassOpacity' | 'glassRoughness';
@@ -27,7 +28,7 @@ export declare function GlazingColor({ field, label, value, mixed, preview, }: {
 }): import("react").JSX.Element;
 export declare const GLAZING_INFILL_OPTIONS: {
     value: RoofGlazing['panelType'];
-    label: string;
+    label: MessageDescriptor;
 }[];
 export {};
 //# sourceMappingURL=glazing-controls.d.ts.map

package/dist/roof/glazing-controls.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"glazing-controls.d.ts","sourceRoot":"","sources":["../../src/roof/glazing-controls.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAYhE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAA;AAEjE,KAAK,OAAO,GAAG,UAAU,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAC1D,KAAK,WAAW,GACZ,YAAY,GACZ,YAAY,GACZ,gBAAgB,GAChB,cAAc,GACd,gBAAgB,CAAA;AAEpB,wBAAgB,aAAa,CAAC,EAC5B,KAAK,EACL,KAAK,EACL,KAAK,EACL,OAAO,EACP,QAAgB,EAChB,KAAa,GACd,EAAE;IACD,KAAK,EAAE,WAAW,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB,+BAiCA;AAED,wBAAgB,mBAAmB,CAAC,EAClC,IAAI,EACJ,KAAK,EACL,WAAW,EACX,IAAI,EACJ,KAAK,EACL,OAAO,GACR,EAAE;IACD,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAA;IACxB,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,WAAW,CAAA;IACjB,KAAK,EAAE,SAAS,WAAW,EAAE,CAAA;IAC7B,OAAO,EAAE,OAAO,CAAA;CACjB,+BA+EA;AAED,wBAAgB,YAAY,CAAC,EAC3B,KAAK,EACL,KAAK,EACL,KAAK,EACL,KAAK,EACL,OAAO,GACR,EAAE;IACD,KAAK,EAAE,YAAY,GAAG,YAAY,CAAA;IAClC,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,OAAO,CAAA;IACd,OAAO,EAAE,OAAO,CAAA;CACjB,+BAwBA;AAED,eAAO,MAAM,sBAAsB,EAAE;IAAE,KAAK,EAAE,WAAW,CAAC,WAAW,CAAC,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAItF,CAAA"}
+{"version":3,"file":"glazing-controls.d.ts","sourceRoot":"","sources":["../../src/roof/glazing-controls.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAChE,OAAO,EAAE,KAAK,iBAAiB,EAAiB,MAAM,kBAAkB,CAAA;AAYxE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAA;AAEjE,KAAK,OAAO,GAAG,UAAU,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAC1D,KAAK,WAAW,GACZ,YAAY,GACZ,YAAY,GACZ,gBAAgB,GAChB,cAAc,GACd,gBAAgB,CAAA;AAEpB,wBAAgB,aAAa,CAAC,EAC5B,KAAK,EACL,KAAK,EACL,KAAK,EACL,OAAO,EACP,QAAgB,EAChB,KAAa,GACd,EAAE;IACD,KAAK,EAAE,WAAW,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB,+BAiCA;AAED,wBAAgB,mBAAmB,CAAC,EAClC,IAAI,EACJ,KAAK,EACL,WAAW,EACX,IAAI,EACJ,KAAK,EACL,OAAO,GACR,EAAE;IACD,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAA;IACxB,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,WAAW,CAAA;IACjB,KAAK,EAAE,SAAS,WAAW,EAAE,CAAA;IAC7B,OAAO,EAAE,OAAO,CAAA;CACjB,+BA2HA;AAED,wBAAgB,YAAY,CAAC,EAC3B,KAAK,EACL,KAAK,EACL,KAAK,EACL,KAAK,EACL,OAAO,GACR,EAAE;IACD,KAAK,EAAE,YAAY,GAAG,YAAY,CAAA;IAClC,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,OAAO,CAAA;IACd,OAAO,EAAE,OAAO,CAAA;CACjB,+BA2BA;AAED,eAAO,MAAM,sBAAsB,EAAE;IACnC,KAAK,EAAE,WAAW,CAAC,WAAW,CAAC,CAAA;IAC/B,KAAK,EAAE,iBAAiB,CAAA;CACzB,EAIA,CAAA"}