@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/skylight/panel.js

@@ -1,13 +1,22 @@
 'use client';
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { SKYLIGHT_TYPE_ORDER, SKYLIGHT_TYPE_PRESETS, sceneRegistry, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { SKYLIGHT_TYPE_ORDER, SKYLIGHT_TYPE_PRESETS, sceneRegistry, useLiveNodeOverrides, usePascalI18n, useScene, } from '@pascal-app/core';
 import { ActionButton, ActionGroup, PanelSection, PanelWrapper, SegmentedControl, SliderControl, triggerSFX, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Trash2 } from 'lucide-react';
 import { useCallback } from 'react';
 import { Vector3 } from 'three';
 const cn = (...classes) => classes.filter(Boolean).join(' ');
+/** Preset names in the UI language; core's `SKYLIGHT_TYPE_PRESETS` labels stay English. */
+const SKYLIGHT_TYPE_LABELS = {
+    flat: /* i18n */ { id: 'node.skylight.type.flat', message: 'Flat roof skylight' },
+    'walk-on': /* i18n */ { id: 'node.skylight.type.walkOn', message: 'Walk-on rooflight' },
+    lantern: /* i18n */ { id: 'node.skylight.type.lantern', message: 'Roof lantern' },
+    opening: /* i18n */ { id: 'node.skylight.type.opening', message: 'Opening skylight' },
+    sliding: /* i18n */ { id: 'node.skylight.type.sliding', message: 'Sliding skylight' },
+};
 export default function SkylightPanel() {
+    const i18n = usePascalI18n();
     const selectedId = useViewer((s) => s.selection.selectedIds[0]);
     const setSelection = useViewer((s) => s.setSelection);
     const updateNode = useScene((s) => s.updateNode);
@@ -213,26 +222,47 @@ export default function SkylightPanel() {
             motorHousingSize: preset.motorHousingSize,
         });
     };
-    return (_jsxs(PanelWrapper, { icon: "/icons/roof.webp", onBack: node.roofSegmentId ? handleBack : undefined, onClose: handleClose, title: node.name || 'Skylight', width: 300, children: [_jsxs(PanelSection, { title: "Type", children: [_jsx("div", { className: "grid grid-cols-2 gap-2 px-1 pt-1", children: SKYLIGHT_TYPE_ORDER.map((skylightType) => {
+    return (_jsxs(PanelWrapper, { icon: "/icons/roof.webp", onBack: node.roofSegmentId ? handleBack : undefined, onClose: handleClose, title: node.name || i18n._({ id: 'node.skylight.panel.skylight', message: 'Skylight' }), width: 300, children: [_jsxs(PanelSection, { title: i18n._({ id: 'node.skylight.panel.type', message: 'Type' }), children: [_jsx("div", { className: "grid grid-cols-2 gap-2 px-1 pt-1", children: SKYLIGHT_TYPE_ORDER.map((skylightType) => {
                             const isSelected = activeSkylightType === skylightType;
                             return (_jsx("button", { className: cn('flex min-h-12 items-center gap-2.5 rounded-lg border px-3 py-2.5 text-left text-xs transition-colors', isSelected
                                     ? 'border-orange-400/60 bg-orange-400/10 text-foreground'
-                                    : 'border-border/50 bg-black/4 dark:bg-[#2C2C2E] text-muted-foreground hover:bg-black/8 dark:hover:bg-[#3e3e3e] hover:text-foreground'), onClick: () => handleTypeChange(skylightType), type: "button", children: _jsx("span", { className: "min-w-0 truncate font-medium", children: SKYLIGHT_TYPE_PRESETS[skylightType].label }) }, skylightType));
-                        }) }), _jsx(SliderControl, { label: "Glass Thickness", max: 0.05, min: 0.002, onChange: (v) => previewProp({ glassThickness: v }), onCommit: (v) => commitProp({ glassThickness: v }), precision: 3, restoreOnCommit: false, step: 0.001, unit: "m", value: node.glassThickness ?? 0.01 }), activeSkylightType === 'lantern' && (_jsxs(_Fragment, { children: [_jsx(SliderControl, { label: "Lantern Height", max: 1.0, min: 0.05, onChange: (v) => previewProp({ lanternHeight: v }), onCommit: (v) => commitProp({ lanternHeight: v }), precision: 3, restoreOnCommit: false, step: 0.01, unit: "m", value: node.lanternHeight ?? 0.25 }), _jsx(SliderControl, { label: "Top Scale", max: 0.95, min: 0, onChange: (v) => previewProp({ lanternTopScale: v }), onCommit: (v) => commitProp({ lanternTopScale: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "", value: Math.round((node.lanternTopScale ?? 0.25) * 100) / 100 })] })), activeSkylightType === 'opening' && (_jsxs(_Fragment, { children: [_jsx(SliderControl, { label: "Open", max: 1, min: 0, onChange: (v) => previewProp({ operationState: v }), onCommit: (v) => commitProp({ operationState: v }), precision: 2, restoreOnCommit: false, step: 0.01, unit: "", value: Math.round((node.operationState ?? 0) * 100) / 100 }), _jsx(SliderControl, { label: "Opening Angle", max: 80, min: 0, onChange: (deg) => previewProp({ openingAngle: (deg * Math.PI) / 180 }), onCommit: (deg) => commitProp({ openingAngle: (deg * Math.PI) / 180 }), precision: 0, restoreOnCommit: false, step: 1, unit: "\u00B0", value: Math.round(((node.openingAngle ?? Math.PI / 10) * 180) / Math.PI) }), _jsx(SegmentedControl, { onChange: (v) => commitProp({ openingSide: v }), options: [
-                                    { label: 'Top', value: 'top' },
-                                    { label: 'Bottom', value: 'bottom' },
-                                    { label: 'Left', value: 'left' },
-                                    { label: 'Right', value: 'right' },
+                                    : 'border-border/50 bg-black/4 dark:bg-[#2C2C2E] text-muted-foreground hover:bg-black/8 dark:hover:bg-[#3e3e3e] hover:text-foreground'), onClick: () => handleTypeChange(skylightType), type: "button", children: _jsx("span", { className: "min-w-0 break-words font-medium", children: i18n._(SKYLIGHT_TYPE_LABELS[skylightType]) }) }, skylightType));
+                        }) }), _jsx(SliderControl, { label: i18n._({ id: 'node.skylight.panel.glassThickness', message: 'Glass Thickness' }), max: 0.05, min: 0.002, onChange: (v) => previewProp({ glassThickness: v }), onCommit: (v) => commitProp({ glassThickness: v }), precision: 3, restoreOnCommit: false, step: 0.001, unit: "m", value: node.glassThickness ?? 0.01 }), activeSkylightType === 'lantern' && (_jsxs(_Fragment, { children: [_jsx(SliderControl, { label: i18n._({ id: 'node.skylight.panel.lanternHeight', message: 'Lantern Height' }), max: 1.0, min: 0.05, onChange: (v) => previewProp({ lanternHeight: v }), onCommit: (v) => commitProp({ lanternHeight: v }), precision: 3, restoreOnCommit: false, step: 0.01, unit: "m", value: node.lanternHeight ?? 0.25 }), _jsx(SliderControl, { label: i18n._({ id: 'node.skylight.panel.topScale', message: 'Top Scale' }), max: 0.95, min: 0, onChange: (v) => previewProp({ lanternTopScale: v }), onCommit: (v) => commitProp({ lanternTopScale: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "", value: Math.round((node.lanternTopScale ?? 0.25) * 100) / 100 })] })), activeSkylightType === 'opening' && (_jsxs(_Fragment, { children: [_jsx(SliderControl, { label: i18n._({ id: 'node.skylight.panel.open', message: 'Open' }), max: 1, min: 0, onChange: (v) => previewProp({ operationState: v }), onCommit: (v) => commitProp({ operationState: v }), precision: 2, restoreOnCommit: false, step: 0.01, unit: "", value: Math.round((node.operationState ?? 0) * 100) / 100 }), _jsx(SliderControl, { label: i18n._({ id: 'node.skylight.panel.openingAngle', message: 'Opening Angle' }), max: 80, min: 0, onChange: (deg) => previewProp({ openingAngle: (deg * Math.PI) / 180 }), onCommit: (deg) => commitProp({ openingAngle: (deg * Math.PI) / 180 }), precision: 0, restoreOnCommit: false, step: 1, unit: "\u00B0", value: Math.round(((node.openingAngle ?? Math.PI / 10) * 180) / Math.PI) }), _jsx(SegmentedControl, { onChange: (v) => commitProp({ openingSide: v }), options: [
+                                    { label: i18n._({ id: 'node.skylight.panel.top', message: 'Top' }), value: 'top' },
+                                    {
+                                        label: i18n._({ id: 'node.skylight.panel.bottom', message: 'Bottom' }),
+                                        value: 'bottom',
+                                    },
+                                    {
+                                        label: i18n._({ id: 'node.skylight.panel.left', message: 'Left' }),
+                                        value: 'left',
+                                    },
+                                    {
+                                        label: i18n._({ id: 'node.skylight.panel.right', message: 'Right' }),
+                                        value: 'right',
+                                    },
                                 ], value: (node.openingSide ?? 'top') }), _jsx(SegmentedControl, { onChange: (v) => commitProp({ motorHousing: v === 'yes' }), options: [
-                                    { label: 'Motor', value: 'yes' },
-                                    { label: 'No Motor', value: 'no' },
-                                ], value: (node.motorHousing ?? false) ? 'yes' : 'no' }), (node.motorHousing ?? false) && (_jsx(SliderControl, { label: "Motor Housing", max: 0.2, min: 0.03, onChange: (v) => previewProp({ motorHousingSize: v }), onCommit: (v) => commitProp({ motorHousingSize: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: node.motorHousingSize ?? 0.08 }))] })), activeSkylightType === 'sliding' && (_jsxs(_Fragment, { children: [_jsx(SliderControl, { label: "Open", max: 1, min: 0, onChange: (v) => previewProp({ operationState: v }), onCommit: (v) => commitProp({ operationState: v }), precision: 2, restoreOnCommit: false, step: 0.01, unit: "", value: Math.round((node.operationState ?? 0) * 100) / 100 }), _jsx(SegmentedControl, { onChange: (v) => commitProp({ slideDirection: v }), options: [
-                                    { label: 'Along Z', value: 'z' },
-                                    { label: 'Along X', value: 'x' },
-                                ], value: (node.slideDirection ?? 'z') }), _jsx(SliderControl, { label: "Track Width", max: 0.12, min: 0.02, onChange: (v) => previewProp({ trackWidth: v }), onCommit: (v) => commitProp({ trackWidth: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: node.trackWidth ?? 0.045 })] }))] }), _jsxs(PanelSection, { title: "Dimensions", children: [_jsx(SliderControl, { label: "Width", max: 1000, min: 0.3, onChange: (v) => previewProp({ width: v }), onCommit: (v) => commitProp({ width: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.width }), _jsx(SliderControl, { label: "Height", max: 1000, min: 0.3, onChange: (v) => previewProp({ height: v }), onCommit: (v) => commitProp({ height: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.height })] }), _jsxs(PanelSection, { title: "Frame", children: [_jsx(SliderControl, { label: "Thickness", max: 0.2, min: 0.02, onChange: (v) => previewProp({ frameThickness: v }), onCommit: (v) => commitProp({ frameThickness: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: node.frameThickness ?? 0.05 }), _jsx(SliderControl, { label: "Depth", max: 0.3, min: 0.02, onChange: (v) => previewProp({ frameDepth: v }), onCommit: (v) => commitProp({ frameDepth: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: node.frameDepth ?? 0.08 }), _jsx(SliderControl, { label: "Cutout Offset", max: 0.2, min: 0, onChange: (v) => previewProp({ cutoutOffset: v }), onCommit: (v) => commitProp({ cutoutOffset: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: node.cutoutOffset ?? 0.01 })] }), _jsxs(PanelSection, { title: "Curb", children: [_jsx(SegmentedControl, { onChange: (v) => handleUpdate({ curb: v === 'yes' }), options: [
-                            { label: 'Yes', value: 'yes' },
-                            { label: 'No', value: 'no' },
-                        ], value: (node.curb ?? false) ? 'yes' : 'no' }), (node.curb ?? false) && (_jsx(SliderControl, { label: "Height", max: 0.3, min: 0.02, onChange: (v) => previewProp({ curbHeight: v }), onCommit: (v) => commitProp({ curbHeight: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: node.curbHeight ?? 0.1 }))] }), _jsxs(PanelSection, { title: "Position", children: [_jsx(SliderControl, { label: "X", max: Math.round(worldMaxX * 10) / 10, min: Math.round(worldMinX * 10) / 10, onChange: (newWorldX) => {
+                                    {
+                                        label: i18n._({ id: 'node.skylight.panel.motor', message: 'Motor' }),
+                                        value: 'yes',
+                                    },
+                                    {
+                                        label: i18n._({ id: 'node.skylight.panel.noMotor', message: 'No Motor' }),
+                                        value: 'no',
+                                    },
+                                ], value: (node.motorHousing ?? false) ? 'yes' : 'no' }), (node.motorHousing ?? false) && (_jsx(SliderControl, { label: i18n._({ id: 'node.skylight.panel.motorHousing', message: 'Motor Housing' }), max: 0.2, min: 0.03, onChange: (v) => previewProp({ motorHousingSize: v }), onCommit: (v) => commitProp({ motorHousingSize: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: node.motorHousingSize ?? 0.08 }))] })), activeSkylightType === 'sliding' && (_jsxs(_Fragment, { children: [_jsx(SliderControl, { label: i18n._({ id: 'node.skylight.panel.open', message: 'Open' }), max: 1, min: 0, onChange: (v) => previewProp({ operationState: v }), onCommit: (v) => commitProp({ operationState: v }), precision: 2, restoreOnCommit: false, step: 0.01, unit: "", value: Math.round((node.operationState ?? 0) * 100) / 100 }), _jsx(SegmentedControl, { onChange: (v) => commitProp({ slideDirection: v }), options: [
+                                    {
+                                        label: i18n._({ id: 'node.skylight.panel.alongZ', message: 'Along Z' }),
+                                        value: 'z',
+                                    },
+                                    {
+                                        label: i18n._({ id: 'node.skylight.panel.alongX', message: 'Along X' }),
+                                        value: 'x',
+                                    },
+                                ], value: (node.slideDirection ?? 'z') }), _jsx(SliderControl, { label: i18n._({ id: 'node.skylight.panel.trackWidth', message: 'Track Width' }), max: 0.12, min: 0.02, onChange: (v) => previewProp({ trackWidth: v }), onCommit: (v) => commitProp({ trackWidth: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: node.trackWidth ?? 0.045 })] }))] }), _jsxs(PanelSection, { title: i18n._({ id: 'node.skylight.panel.dimensions', message: 'Dimensions' }), children: [_jsx(SliderControl, { label: i18n._({ id: 'node.skylight.panel.width', message: 'Width' }), max: 1000, min: 0.3, onChange: (v) => previewProp({ width: v }), onCommit: (v) => commitProp({ width: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.width }), _jsx(SliderControl, { label: i18n._({ id: 'node.skylight.panel.height', message: 'Height' }), max: 1000, min: 0.3, onChange: (v) => previewProp({ height: v }), onCommit: (v) => commitProp({ height: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.height })] }), _jsxs(PanelSection, { title: i18n._({ id: 'node.skylight.panel.frame', message: 'Frame' }), children: [_jsx(SliderControl, { label: i18n._({ id: 'node.skylight.panel.thickness', message: 'Thickness' }), max: 0.2, min: 0.02, onChange: (v) => previewProp({ frameThickness: v }), onCommit: (v) => commitProp({ frameThickness: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: node.frameThickness ?? 0.05 }), _jsx(SliderControl, { label: i18n._({ id: 'node.skylight.panel.depth', message: 'Depth' }), max: 0.3, min: 0.02, onChange: (v) => previewProp({ frameDepth: v }), onCommit: (v) => commitProp({ frameDepth: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: node.frameDepth ?? 0.08 }), _jsx(SliderControl, { label: i18n._({ id: 'node.skylight.panel.cutoutOffset', message: 'Cutout Offset' }), max: 0.2, min: 0, onChange: (v) => previewProp({ cutoutOffset: v }), onCommit: (v) => commitProp({ cutoutOffset: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: node.cutoutOffset ?? 0.01 })] }), _jsxs(PanelSection, { title: i18n._({ id: 'node.skylight.panel.curb', message: 'Curb' }), children: [_jsx(SegmentedControl, { onChange: (v) => handleUpdate({ curb: v === 'yes' }), options: [
+                            { label: i18n._({ id: 'node.skylight.panel.yes', message: 'Yes' }), value: 'yes' },
+                            { label: i18n._({ id: 'node.skylight.panel.no', message: 'No' }), value: 'no' },
+                        ], value: (node.curb ?? false) ? 'yes' : 'no' }), (node.curb ?? false) && (_jsx(SliderControl, { label: i18n._({ id: 'node.skylight.panel.height', message: 'Height' }), max: 0.3, min: 0.02, onChange: (v) => previewProp({ curbHeight: v }), onCommit: (v) => commitProp({ curbHeight: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: node.curbHeight ?? 0.1 }))] }), _jsxs(PanelSection, { title: i18n._({ id: 'node.skylight.panel.position', message: 'Position' }), children: [_jsx(SliderControl, { label: "X", max: Math.round(worldMaxX * 10) / 10, min: Math.round(worldMinX * 10) / 10, onChange: (newWorldX) => {
                             if (!segment)
                                 return;
                             const local = worldToSegLocal(newWorldX, worldZ_now, segment);
@@ -242,12 +272,12 @@ export default function SkylightPanel() {
                                 return;
                             const local = worldToSegLocal(worldX_now, newWorldZ, segment);
                             previewProp({ position: [local.localX, 0, local.localZ] });
-                        }, onCommit: (newWorldZ) => commitWorldPosition(worldX_now, newWorldZ), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: worldZ_now }), _jsx(SliderControl, { label: "Rotation", max: 180, min: -180, onChange: (degrees) => {
+                        }, onCommit: (newWorldZ) => commitWorldPosition(worldX_now, newWorldZ), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: worldZ_now }), _jsx(SliderControl, { label: i18n._({ id: 'node.skylight.panel.rotation', message: 'Rotation' }), max: 180, min: -180, onChange: (degrees) => {
                             const newWorldRot = (degrees * Math.PI) / 180;
                             if (!skylightObj)
                                 return;
                             const m = skylightObj.matrixWorld.elements;
                             const ancestorWorldY = Math.atan2(-(m[2] ?? 0), m[0] ?? 1);
                             previewProp({ rotation: newWorldRot - ancestorWorldY });
-                        }, onCommit: (degrees) => commitWorldRotation((degrees * Math.PI) / 180), precision: 0, restoreOnCommit: false, step: 1, unit: "\u00B0", value: Math.round((worldRotation_now * 180) / Math.PI) })] }), _jsx(PanelSection, { title: "Actions", children: _jsx(ActionGroup, { children: _jsx(ActionButton, { className: "hover:bg-red-500/20", icon: _jsx(Trash2, { className: "h-3.5 w-3.5 text-red-600 dark:text-red-400" }), label: "Delete", onClick: handleDelete }) }) })] }));
+                        }, onCommit: (degrees) => commitWorldRotation((degrees * Math.PI) / 180), precision: 0, restoreOnCommit: false, step: 1, unit: "\u00B0", value: Math.round((worldRotation_now * 180) / Math.PI) })] }), _jsx(PanelSection, { title: i18n._({ id: 'node.skylight.panel.actions', message: 'Actions' }), children: _jsx(ActionGroup, { children: _jsx(ActionButton, { className: "hover:bg-red-500/20", icon: _jsx(Trash2, { className: "h-3.5 w-3.5 text-red-600 dark:text-red-400" }), label: i18n._({ id: 'node.skylight.panel.delete', message: 'Delete' }), onClick: handleDelete }) }) })] }));
 }

package/dist/slab/deck-geometry.d.ts

@@ -0,0 +1,28 @@
+import { type DeckFramingPlan, type DeckPiece, type GeometryContext, type PlateSurfacePartition, type PlateTopCell, type SlabNode } from '@pascal-app/core';
+import { type ColorPreset, type RenderShading } from '@pascal-app/viewer';
+import { Group, type Material } from 'three';
+export type DeckLook = {
+    shading: RenderShading;
+    textures: boolean;
+    colorPreset: ColorPreset;
+    sceneTheme?: string;
+};
+export type DeckGeometryOptions = {
+    /** The deck's outline: the slab's renderable polygon. */
+    polygon: Array<[number, number]>;
+    /** The plate's top partition: one set of boards per cell. Null for a drawn slab. */
+    partition: PlateSurfacePartition | null;
+    /** A cell's finish as a material; `null` asks for the slab's own surface finish. */
+    boardMaterial: (cell: PlateTopCell | null) => Material;
+    look: DeckLook;
+};
+/** The deck's frame as the engine draws it: a joist a side rim stands in for is the rim. */
+export declare function deckFramePieces(plan: DeckFramingPlan): DeckPiece[];
+/** The deck's frame plan and boards, as drawn for `node`. */
+export declare function planDeck(node: SlabNode, ctx: GeometryContext | undefined, polygon: Array<[number, number]>): {
+    boards: import("@pascal-app/core").DeckBoardSettings;
+    thickness: number;
+    plan: DeckFramingPlan;
+};
+export declare function buildDeckGeometry(node: SlabNode, ctx: GeometryContext | undefined, options: DeckGeometryOptions): Group;
+//# sourceMappingURL=deck-geometry.d.ts.map

package/dist/slab/deck-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deck-geometry.d.ts","sourceRoot":"","sources":["../../src/slab/deck-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,eAAe,EACpB,KAAK,SAAS,EAKd,KAAK,eAAe,EAMpB,KAAK,qBAAqB,EAC1B,KAAK,YAAY,EAMjB,KAAK,QAAQ,EAId,MAAM,kBAAkB,CAAA;AACzB,OAAO,EACL,KAAK,WAAW,EAEhB,KAAK,aAAa,EAEnB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAIL,KAAK,EACL,KAAK,QAAQ,EAId,MAAM,OAAO,CAAA;AAkBd,MAAM,MAAM,QAAQ,GAAG;IACrB,OAAO,EAAE,aAAa,CAAA;IACtB,QAAQ,EAAE,OAAO,CAAA;IACjB,WAAW,EAAE,WAAW,CAAA;IACxB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,yDAAyD;IACzD,OAAO,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IAChC,oFAAoF;IACpF,SAAS,EAAE,qBAAqB,GAAG,IAAI,CAAA;IACvC,oFAAoF;IACpF,aAAa,EAAE,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,KAAK,QAAQ,CAAA;IACtD,IAAI,EAAE,QAAQ,CAAA;CACf,CAAA;AA6ND,4FAA4F;AAC5F,wBAAgB,eAAe,CAAC,IAAI,EAAE,eAAe,GAAG,SAAS,EAAE,CAQlE;AAED,6DAA6D;AAC7D,wBAAgB,QAAQ,CACtB,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,eAAe,GAAG,SAAS,EAChC,OAAO,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;;;;EA0BjC;AAED,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,eAAe,GAAG,SAAS,EAChC,OAAO,EAAE,mBAAmB,GAC3B,KAAK,CAgEP"}

package/dist/slab/deck-geometry.js

@@ -0,0 +1,320 @@
+import { area, BEAM_MATERIAL_LIBRARY_REFS, deckBoardRun, deckBoardThickness, deckSlabBoards, getLevelElevations, intersection, layoutDeckBoards, planDeckFraming, plateLevelContext, SITE_DATUM_Y, surfaceHeightAt, terrainFieldOf, } from '@pascal-app/core';
+import { createSurfaceRoleMaterial, resolveSlotDefaultMaterial, } from '@pascal-app/viewer';
+import { BufferGeometry, Float32BufferAttribute, FrontSide, Group, Mesh, ShapeUtils, Vector2, } from 'three';
+/**
+ * A deck's floor (`isDeckSlab`: a deck room's floor plate, a generated deck) drawn as a deck is
+ * built, never as a solid slab: its boards (`layoutDeckBoards`), the room's finish on them, each
+ * painted part of the floor its own boards with its own paint role, over its frame
+ * (`planDeckFraming`), the same plan the framing plugin books: ledger, joists, rims, beams and
+ * posts in treated wood, a concrete pier under each post at the ground. The boards' top is the
+ * slab's top, so items, the room label and clicks find the floor where they did. Each material is
+ * one merged mesh, so the deck batches like any slab.
+ */
+const IN = 0.0254;
+/** A post's pier: 12 in square, standing 2 in out of the ground, 10 in into it. */
+const PIER_SIDE = 12 * IN;
+const PIER_ABOVE = 2 * IN;
+const PIER_BELOW = 10 * IN;
+/** The level-local ground under a plan point: the site's terrain, or the datum, wherever the storey stands. */
+function groundUnder(ctx) {
+    const level = ctx?.parent;
+    if (!ctx || level?.type !== 'level' || !level.parentId)
+        return () => 0;
+    const building = ctx.resolve(level.parentId);
+    if (building?.type !== 'building')
+        return () => 0;
+    const site = building.parentId ? ctx.resolve(building.parentId) : undefined;
+    const nodes = { [building.id]: building, [level.id]: level };
+    if (site?.type === 'site')
+        nodes[site.id] = site;
+    for (const childId of building.children) {
+        const child = ctx.resolve(childId);
+        if (child)
+            nodes[child.id] = child;
+    }
+    const elevation = getLevelElevations(nodes).get(level.id);
+    if (!elevation)
+        return () => 0;
+    const baseWorldY = (building.position?.[1] ?? 0) + elevation.baseY;
+    const field = site?.type === 'site' ? terrainFieldOf(site) : null;
+    if (!field)
+        return () => SITE_DATUM_Y - baseWorldY;
+    const angle = building.rotation?.[1] ?? 0;
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    const [px, , pz] = building.position ?? [0, 0, 0];
+    return (x, z) => surfaceHeightAt(field, cos * x + sin * z + px, -sin * x + cos * z + pz) - baseWorldY;
+}
+/** The house walls a deck edge may hang its ledger on: no railing, no hidden wall. */
+function ledgerWalls(ctx) {
+    if (!ctx)
+        return [];
+    return plateLevelContext(ctx.parent, ctx.resolve)
+        .walls.filter((wall) => wall.visible !== false && wall.wallType !== 'railing')
+        .map((wall) => ({
+        start: wall.start,
+        end: wall.end,
+        thickness: wall.thickness ?? 0.1,
+        curved: Math.abs(wall.curveOffset ?? 0) > 1e-6,
+    }));
+}
+/**
+ * Posts already standing on the ground by the deck (a generated porch's, hosted on the ground and
+ * passing through the deck): a beam two of them stand on is theirs to carry.
+ */
+function carriersBy(node, ctx) {
+    const level = ctx?.parent;
+    if (!ctx || !level || !('children' in level))
+        return [];
+    const out = [];
+    for (const id of level.children) {
+        const column = ctx.resolve(id);
+        if (column?.type !== 'column' || column.visible === false || column.supportSlabId === node.id)
+            continue;
+        const support = column.supportSlabId
+            ? ctx.resolve(column.supportSlabId)
+            : undefined;
+        const base = column.position[1] + (support?.type === 'slab' ? support.elevation : 0);
+        if (base < node.elevation - 0.3)
+            out.push([column.position[0], column.position[2]]);
+    }
+    return out;
+}
+/** A material's surface: the treated wood of the frame, the piers' concrete. */
+function frameMaterial(ref, role, look) {
+    return look.textures
+        ? resolveSlotDefaultMaterial(ref, look.shading)
+        : createSurfaceRoleMaterial(role, look.colorPreset, FrontSide, look.sceneTheme);
+}
+const buffers = () => ({ positions: [], normals: [], uvs: [], indices: [] });
+function toGeometry({ positions, normals, uvs, indices }) {
+    const geometry = new BufferGeometry();
+    geometry.setAttribute('position', new Float32BufferAttribute(positions, 3));
+    geometry.setAttribute('normal', new Float32BufferAttribute(normals, 3));
+    geometry.setAttribute('uv', new Float32BufferAttribute(uvs, 2));
+    geometry.setIndex(indices);
+    return geometry;
+}
+/** A box (centre, [run, height, across], yaw), flat-shaded with metre UVs on every face. */
+function pushBox(out, piece) {
+    const [cx, cy, cz] = piece.position;
+    const [hx, hy, hz] = piece.dims.map((value) => value / 2);
+    const cos = Math.cos(piece.yaw);
+    const sin = Math.sin(piece.yaw);
+    // three.js Y rotation: local +x → (cos, 0, −sin), local +z → (sin, 0, cos)
+    const world = (x, y, z) => [
+        cx + x * cos + z * sin,
+        cy + y,
+        cz - x * sin + z * cos,
+    ];
+    const turn = (x, z) => [
+        x * cos + z * sin,
+        0,
+        -x * sin + z * cos,
+    ];
+    // each face: its normal (local), and two edge axes (local) with their half lengths
+    const faces = [
+        { n: [1, 0, 0], a: [0, 0, -1], b: [0, 1, 0] },
+        { n: [-1, 0, 0], a: [0, 0, 1], b: [0, 1, 0] },
+        { n: [0, 1, 0], a: [1, 0, 0], b: [0, 0, -1] },
+        { n: [0, -1, 0], a: [1, 0, 0], b: [0, 0, 1] },
+        { n: [0, 0, 1], a: [1, 0, 0], b: [0, 1, 0] },
+        { n: [0, 0, -1], a: [-1, 0, 0], b: [0, 1, 0] },
+    ];
+    const half = [hx, hy, hz];
+    for (const { n, a, b } of faces) {
+        const base = out.positions.length / 3;
+        const span = (axis) => Math.abs(axis[0]) * half[0] + Math.abs(axis[1]) * half[1] + Math.abs(axis[2]) * half[2];
+        const ha = span(a);
+        const hb = span(b);
+        const normal = n[1] !== 0 ? [0, n[1], 0] : turn(n[0], n[2]);
+        for (const [sa, sb] of [
+            [-1, -1],
+            [1, -1],
+            [1, 1],
+            [-1, 1],
+        ]) {
+            const x = n[0] * half[0] + a[0] * ha * sa + b[0] * hb * sb;
+            const y = n[1] * half[1] + a[1] * ha * sa + b[1] * hb * sb;
+            const z = n[2] * half[2] + a[2] * ha * sa + b[2] * hb * sb;
+            out.positions.push(...world(x, y, z));
+            out.normals.push(...normal);
+            out.uvs.push(ha * (sa + 1), hb * (sb + 1));
+        }
+        out.indices.push(base, base + 1, base + 2, base, base + 2, base + 3);
+    }
+}
+function signedArea2(ring) {
+    let twice = 0;
+    for (let i = 0; i < ring.length; i++) {
+        const [ax, az] = ring[i];
+        const [bx, bz] = ring[(i + 1) % ring.length];
+        twice += ax * bz - bx * az;
+    }
+    return twice;
+}
+/**
+ * One board: its top at `top`, its bottom `thickness` under, its sides; the top's grain along
+ * the board (`along`), shifted by `shift` so neighbouring boards read as boards.
+ */
+function pushBoard(out, board, top, thickness, along, shift) {
+    const outer = signedArea2(board.outer) < 0 ? [...board.outer].reverse() : board.outer;
+    const holes = board.holes.filter((hole) => hole.length >= 3);
+    const contour = outer.map(([x, z]) => new Vector2(x, z));
+    const holeRings = holes.map((hole) => hole.map(([x, z]) => new Vector2(x, z)));
+    const bottom = top - thickness;
+    const grain = (x, z) => [
+        x * along[0] + z * along[1] + shift,
+        -x * along[1] + z * along[0],
+    ];
+    const cap = [...contour, ...holeRings.flat()];
+    const topBase = out.positions.length / 3;
+    for (const p of cap) {
+        out.positions.push(p.x, top, p.y);
+        out.normals.push(0, 1, 0);
+        out.uvs.push(...grain(p.x, p.y));
+    }
+    const bottomBase = out.positions.length / 3;
+    for (const p of cap) {
+        out.positions.push(p.x, bottom, p.y);
+        out.normals.push(0, -1, 0);
+        out.uvs.push(...grain(p.x, p.y));
+    }
+    for (const [a, b, c] of ShapeUtils.triangulateShape(contour, holeRings)) {
+        out.indices.push(topBase + a, topBase + c, topBase + b);
+        out.indices.push(bottomBase + a, bottomBase + b, bottomBase + c);
+    }
+    // the board's edges, outward on the outline; a hole's both ways
+    const side = (a, b, flipped) => {
+        const length = Math.hypot(b.x - a.x, b.y - a.y);
+        if (length < 1e-9)
+            return;
+        const nx = (b.y - a.y) / length;
+        const nz = -(b.x - a.x) / length;
+        const base = out.positions.length / 3;
+        for (const [p, y, u, v] of [
+            [a, bottom, 0, 0],
+            [b, bottom, length, 0],
+            [b, top, length, thickness],
+            [a, top, 0, thickness],
+        ]) {
+            out.positions.push(p.x, y, p.y);
+            out.normals.push(flipped ? -nx : nx, 0, flipped ? -nz : nz);
+            out.uvs.push(u, v);
+        }
+        if (flipped)
+            out.indices.push(base, base + 1, base + 2, base, base + 2, base + 3);
+        else
+            out.indices.push(base, base + 2, base + 1, base, base + 3, base + 2);
+    };
+    for (let i = 0; i < contour.length; i++)
+        side(contour[i], contour[(i + 1) % contour.length], false);
+    for (const ring of holeRings)
+        for (let i = 0; i < ring.length; i++) {
+            side(ring[i], ring[(i + 1) % ring.length], false);
+            side(ring[i], ring[(i + 1) % ring.length], true);
+        }
+}
+/** A board's own shift along its grain, the same every build. */
+const shiftOf = (index) => {
+    const x = Math.sin(index * 12.9898 + 78.233) * 43758.5453;
+    return (x - Math.floor(x)) * 3;
+};
+/** The deck's frame as the engine draws it: a joist a side rim stands in for is the rim. */
+export function deckFramePieces(plan) {
+    return [
+        ...(plan.ledger ? [plan.ledger] : []),
+        ...plan.rims,
+        ...plan.joists.filter((joist) => !joist.atRim),
+        ...plan.beams,
+        ...plan.posts,
+    ];
+}
+/** The deck's frame plan and boards, as drawn for `node`. */
+export function planDeck(node, ctx, polygon) {
+    const boards = deckSlabBoards(node, (id) => {
+        const zone = ctx?.resolve(id);
+        return zone?.type === 'zone' ? zone : undefined;
+    });
+    const thickness = deckBoardThickness(boards);
+    const ground = groundUnder(ctx);
+    let cx = 0;
+    let cz = 0;
+    for (const [x, z] of polygon) {
+        cx += x;
+        cz += z;
+    }
+    const n = Math.max(polygon.length, 1);
+    const plan = planDeckFraming({
+        polygon,
+        top: node.elevation,
+        decking: thickness,
+        walls: ledgerWalls(ctx),
+        boards,
+        gradeY: ground(cx / n, cz / n),
+        gradeAt: ground,
+        carriers: carriersBy(node, ctx),
+    });
+    return { boards, thickness, plan };
+}
+export function buildDeckGeometry(node, ctx, options) {
+    const group = new Group();
+    const { polygon, partition, look } = options;
+    if (polygon.length < 3)
+        return group;
+    const { boards, thickness, plan } = planDeck(node, ctx, polygon);
+    const addMesh = (geometry, material, role) => {
+        if (geometry.getAttribute('position').count === 0) {
+            geometry.dispose();
+            return;
+        }
+        const mesh = new Mesh(geometry, material);
+        mesh.castShadow = true;
+        mesh.receiveShadow = true;
+        if (role) {
+            mesh.userData.slotId = role;
+            mesh.userData.paintRole = role;
+        }
+        group.add(mesh);
+    };
+    // ---- the boards: a set for each painted part of the floor, cut along it ----
+    const axes = plan.axes ?? {
+        origin: polygon[0],
+        u: [1, 0],
+        v: [0, 1],
+    };
+    const joists = plan.stationAxis && plan.axes
+        ? { origin: plan.axes.origin, axis: plan.stationAxis, stations: plan.stations }
+        : undefined;
+    // One set of rows over the whole deck, so a painted part's boards line up with the rest.
+    const top = [{ outer: polygon, holes: node.holes ?? [] }];
+    const laid = layoutDeckBoards(top, axes, boards, joists);
+    const cells = partition
+        ? partition.cells.map((cell) => ({ cell, role: cell.role, outline: cell.polygons }))
+        : [{ cell: null, role: 'surface', outline: top }];
+    const whole = area(top);
+    const { along } = deckBoardRun(axes, boards.direction);
+    for (const { cell, role, outline } of cells) {
+        const out = buffers();
+        const all = cells.length === 1 && Math.abs(area(outline) - whole) < 1e-4;
+        laid.forEach((board, index) => {
+            for (const part of all ? [board] : intersection(board, outline))
+                pushBoard(out, part, node.elevation, thickness, along, shiftOf(index));
+        });
+        addMesh(toGeometry(out), options.boardMaterial(cell), role);
+    }
+    // ---- the frame, and a pier under each post ----
+    const frame = buffers();
+    for (const piece of deckFramePieces(plan))
+        pushBox(frame, piece);
+    addMesh(toGeometry(frame), frameMaterial(BEAM_MATERIAL_LIBRARY_REFS['pressure-treated'], 'wall', look));
+    const piers = buffers();
+    for (const post of plan.posts)
+        pushBox(piers, {
+            position: [post.position[0], post.bottom + (PIER_ABOVE - PIER_BELOW) / 2, post.position[2]],
+            dims: [PIER_SIDE, PIER_ABOVE + PIER_BELOW, PIER_SIDE],
+            yaw: post.yaw,
+        });
+    addMesh(toGeometry(piers), frameMaterial('library:concrete-raw', 'floor', look));
+    return group;
+}