@pascal-app/nodes 0.1.1

package/dist/skylight/frame-csg.js

@@ -0,0 +1,49 @@
+import { Brush, csgEvaluator, csgGeometry, prepareBrushForCSG, SUBTRACTION, } from '@pascal-app/viewer';
+import * as THREE from 'three';
+const visibleDummyMat = new THREE.MeshBasicMaterial();
+export function buildFrameGeometry({ curb, curbHeight, frameDepth, frameThickness, height, width, }) {
+    const w = width;
+    const h = height;
+    const ft = frameThickness;
+    const fd = frameDepth;
+    const hasCurb = curb ?? false;
+    const curbH = hasCurb ? Math.max(0, curbHeight ?? 0.1) : 0;
+    const outerW = w + 2 * ft;
+    const outerH = h + 2 * ft;
+    const totalDepth = fd + curbH;
+    const outerBox = new THREE.BoxGeometry(outerW, totalDepth, outerH);
+    const innerBox = new THREE.BoxGeometry(w, totalDepth + 0.02, h);
+    const setupGeo = (geo) => {
+        const ic = geo.getIndex()?.count ?? 0;
+        geo.clearGroups();
+        if (ic > 0)
+            geo.addGroup(0, ic, 0);
+    };
+    setupGeo(outerBox);
+    setupGeo(innerBox);
+    let frameGeo;
+    try {
+        const outerBrush = new Brush(outerBox, visibleDummyMat);
+        prepareBrushForCSG(outerBrush);
+        const innerBrush = new Brush(innerBox, visibleDummyMat);
+        prepareBrushForCSG(innerBrush);
+        const result = csgEvaluator.evaluate(outerBrush, innerBrush, SUBTRACTION);
+        frameGeo = csgGeometry(result).clone();
+        const ic = frameGeo.getIndex()?.count ?? 0;
+        frameGeo.clearGroups();
+        if (ic > 0)
+            frameGeo.addGroup(0, ic, 0);
+        outerBox.dispose();
+        innerBox.dispose();
+        result.geometry.dispose();
+    }
+    catch (e) {
+        // eslint-disable-next-line no-console
+        console.error('Skylight frame CSG failed:', e);
+        outerBox.dispose();
+        innerBox.dispose();
+        return null;
+    }
+    frameGeo.translate(0, -totalDepth / 2 + curbH, 0);
+    return frameGeo;
+}

package/dist/skylight/geometry.d.ts

@@ -0,0 +1,7 @@
+import * as THREE from 'three';
+import { getAnalyticalNormal, getSurfaceY } from '../shared/roof-surface';
+export { getAnalyticalNormal, getSurfaceY };
+export declare function paneSize(value: number): number;
+export declare function clamp01(value: number): number;
+export declare function buildLanternGlassGeometry(width: number, depth: number, lanternHeight: number, topScale: number): THREE.BufferGeometry;
+//# sourceMappingURL=geometry.d.ts.map

package/dist/skylight/geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/skylight/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAC9B,OAAO,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAEzE,OAAO,EAAE,mBAAmB,EAAE,WAAW,EAAE,CAAA;AAE3C,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,MAAM,GACf,KAAK,CAAC,cAAc,CA4GtB"}

package/dist/skylight/geometry.js

@@ -0,0 +1,114 @@
+import * as THREE from 'three';
+import { getAnalyticalNormal, getSurfaceY } from '../shared/roof-surface';
+export { getAnalyticalNormal, getSurfaceY };
+export function paneSize(value) {
+    return Math.max(0.02, value);
+}
+export function clamp01(value) {
+    return Math.min(1, Math.max(0, value));
+}
+export function buildLanternGlassGeometry(width, depth, lanternHeight, topScale) {
+    const baseHalfW = paneSize(width) / 2;
+    const baseHalfD = paneSize(depth) / 2;
+    const resolvedTopScale = clamp01(topScale);
+    const topHalfW = baseHalfW * resolvedTopScale;
+    const topHalfD = baseHalfD * resolvedTopScale;
+    const topY = Math.max(0.05, lanternHeight);
+    const positions = resolvedTopScale <= 1e-4
+        ? [
+            -baseHalfW,
+            0,
+            baseHalfD,
+            baseHalfW,
+            0,
+            baseHalfD,
+            0,
+            topY,
+            0,
+            baseHalfW,
+            0,
+            baseHalfD,
+            baseHalfW,
+            0,
+            -baseHalfD,
+            0,
+            topY,
+            0,
+            baseHalfW,
+            0,
+            -baseHalfD,
+            -baseHalfW,
+            0,
+            -baseHalfD,
+            0,
+            topY,
+            0,
+            -baseHalfW,
+            0,
+            -baseHalfD,
+            -baseHalfW,
+            0,
+            baseHalfD,
+            0,
+            topY,
+            0,
+        ]
+        : [
+            -baseHalfW,
+            0,
+            baseHalfD,
+            baseHalfW,
+            0,
+            baseHalfD,
+            topHalfW,
+            topY,
+            topHalfD,
+            -topHalfW,
+            topY,
+            topHalfD,
+            baseHalfW,
+            0,
+            baseHalfD,
+            baseHalfW,
+            0,
+            -baseHalfD,
+            topHalfW,
+            topY,
+            -topHalfD,
+            topHalfW,
+            topY,
+            topHalfD,
+            baseHalfW,
+            0,
+            -baseHalfD,
+            -baseHalfW,
+            0,
+            -baseHalfD,
+            -topHalfW,
+            topY,
+            -topHalfD,
+            topHalfW,
+            topY,
+            -topHalfD,
+            -baseHalfW,
+            0,
+            -baseHalfD,
+            -baseHalfW,
+            0,
+            baseHalfD,
+            -topHalfW,
+            topY,
+            topHalfD,
+            -topHalfW,
+            topY,
+            -topHalfD,
+        ];
+    const indices = resolvedTopScale <= 1e-4
+        ? [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
+        : [0, 1, 2, 0, 2, 3, 4, 5, 6, 4, 6, 7, 8, 9, 10, 8, 10, 11, 12, 13, 14, 12, 14, 15];
+    const geometry = new THREE.BufferGeometry();
+    geometry.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
+    geometry.setIndex(indices);
+    geometry.computeVertexNormals();
+    return geometry;
+}

package/dist/skylight/index.d.ts

@@ -0,0 +1,5 @@
+export { skylightDefinition } from './definition';
+export { buildFrameGeometry } from './frame-csg';
+export { buildLanternGlassGeometry } from './geometry';
+export { SkylightNode } from './schema';
+//# sourceMappingURL=index.d.ts.map

package/dist/skylight/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/skylight/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA;AACjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAChD,OAAO,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAA;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA"}

package/dist/skylight/index.js

@@ -0,0 +1,4 @@
+export { skylightDefinition } from './definition';
+export { buildFrameGeometry } from './frame-csg';
+export { buildLanternGlassGeometry } from './geometry';
+export { SkylightNode } from './schema';

package/dist/skylight/interaction.d.ts

@@ -0,0 +1,11 @@
+import { type AnyNodeId, type SkylightNode } from '@pascal-app/core';
+export declare const SKYLIGHT_TOGGLE_ANIMATION_MS = 520;
+type SkylightOpenAnimationOptions = {
+    persist?: boolean;
+};
+export declare function isOperableSkylightType(skylightType: string | undefined): skylightType is "opening" | "sliding";
+export declare function isOperableSkylightNode(node: SkylightNode): boolean;
+export declare function toggleSkylightOpenState(skylightId: AnyNodeId, options?: SkylightOpenAnimationOptions): void;
+export declare function closeSkylightOpenState(skylightId: AnyNodeId, options?: SkylightOpenAnimationOptions): void;
+export {};
+//# sourceMappingURL=interaction.d.ts.map

package/dist/skylight/interaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interaction.d.ts","sourceRoot":"","sources":["../../src/skylight/interaction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EAEd,KAAK,YAAY,EAGlB,MAAM,kBAAkB,CAAA;AAEzB,eAAO,MAAM,4BAA4B,MAAM,CAAA;AAE/C,KAAK,4BAA4B,GAAG;IAClC,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB,CAAA;AAED,wBAAgB,sBAAsB,CAAC,YAAY,EAAE,MAAM,GAAG,SAAS,yCAEtE;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAElE;AA8BD,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,SAAS,EACrB,OAAO,CAAC,EAAE,4BAA4B,QAavC;AAED,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,SAAS,EACrB,OAAO,CAAC,EAAE,4BAA4B,QAOvC"}

package/dist/skylight/interaction.js

@@ -0,0 +1,42 @@
+import { useInteractive, useScene, } from '@pascal-app/core';
+export const SKYLIGHT_TOGGLE_ANIMATION_MS = 520;
+export function isOperableSkylightType(skylightType) {
+    return skylightType === 'opening' || skylightType === 'sliding';
+}
+export function isOperableSkylightNode(node) {
+    return isOperableSkylightType(node.skylightType);
+}
+function getDisplayedSkylightValue(skylightId, nodeValue) {
+    const interactive = useInteractive.getState();
+    const runtimeValue = interactive.skylights[skylightId]?.operationState;
+    if (runtimeValue !== undefined)
+        return runtimeValue;
+    const queuedValue = interactive.skylightAnimations[skylightId]?.from;
+    if (queuedValue !== undefined)
+        return queuedValue;
+    return nodeValue ?? 0;
+}
+function startSkylightOpenAnimation(skylightId, field, from, to, options) {
+    useInteractive.getState().startSkylightAnimation(skylightId, {
+        field,
+        from,
+        to,
+        startedAt: null,
+        durationMs: SKYLIGHT_TOGGLE_ANIMATION_MS,
+        persist: options?.persist ?? true,
+    });
+}
+export function toggleSkylightOpenState(skylightId, options) {
+    const node = useScene.getState().nodes[skylightId];
+    if (node?.type !== 'skylight' || !isOperableSkylightType(node.skylightType))
+        return;
+    const currentOpenAmount = getDisplayedSkylightValue(skylightId, node.operationState);
+    startSkylightOpenAnimation(skylightId, 'operationState', currentOpenAmount, currentOpenAmount >= 0.5 ? 0 : 1, options);
+}
+export function closeSkylightOpenState(skylightId, options) {
+    const node = useScene.getState().nodes[skylightId];
+    if (node?.type !== 'skylight' || !isOperableSkylightType(node.skylightType))
+        return;
+    const currentOpenAmount = getDisplayedSkylightValue(skylightId, node.operationState);
+    startSkylightOpenAnimation(skylightId, 'operationState', currentOpenAmount, 0, options);
+}

package/dist/skylight/move-tool.d.ts

@@ -0,0 +1,5 @@
+import { type SkylightNode } from '@pascal-app/core';
+export default function MoveSkylightTool({ node }: {
+    node: SkylightNode;
+}): import("react").JSX.Element | null;
+//# sourceMappingURL=move-tool.d.ts.map

package/dist/skylight/move-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/skylight/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAML,KAAK,YAAY,EAGlB,MAAM,kBAAkB,CAAA;AAuBzB,MAAM,CAAC,OAAO,UAAU,gBAAgB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,sCAiQxE"}

package/dist/skylight/move-tool.js

@@ -0,0 +1,233 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { emitter, sceneRegistry, useScene, } from '@pascal-app/core';
+import { consumePlacementDragRelease, markToolCancelConsumed, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import * as THREE from 'three';
+import { createRelativeRoofDrag, roofSegmentLocalToBuildingLocal, snapRelativeRoofDragTarget, } from '../shared/relative-roof-drag';
+import { getAnalyticalNormal, surfaceQuatFromNormal } from '../shared/roof-surface';
+import { clearRoofSurfacePlacementGuides, publishRoofSurfaceNodePlacementGuides, snapRoofSurfaceNodeTarget, } from '../shared/roof-surface-placement-guides';
+import SkylightPreview from './preview';
+export default function MoveSkylightTool({ node }) {
+    const exitMoveMode = useCallback(() => {
+        useEditor.getState().setMovingNode(null);
+    }, []);
+    const previewRef = useRef(null);
+    const [previewPos, setPreviewPos] = useState([0, 0, 0]);
+    // Mirror the placement tool's transform stack so the ghost reads the
+    // same in both flows: outer rotation-y aligns the segment's world yaw
+    // (roof + segment), inner quaternion tilts to the segment surface in
+    // segment-local space (analytical, not raycast — raycast normals can
+    // be flipped or in the wrong frame depending on hit-object state).
+    // The skylight's own `rotation` is applied on a deeper group so it
+    // stays editable on top of the surface alignment.
+    const [previewYaw, setPreviewYaw] = useState(0);
+    const [previewSurfaceQuat, setPreviewSurfaceQuat] = useState(null);
+    const [hasHit, setHasHit] = useState(false);
+    useEffect(() => {
+        useScene.temporal.getState().pause();
+        const original = {
+            position: [...node.position],
+            rotation: node.rotation ?? 0,
+            roofSegmentId: node.roofSegmentId,
+            parentId: node.parentId,
+            metadata: node.metadata,
+        };
+        const meta = typeof node.metadata === 'object' && node.metadata !== null
+            ? node.metadata
+            : {};
+        const isNew = !!meta.isNew;
+        useScene.getState().updateNode(node.id, {
+            metadata: { ...meta, isTransient: true },
+        });
+        const skylightObj = sceneRegistry.nodes.get(node.id);
+        if (skylightObj)
+            skylightObj.visible = false;
+        let lastSnapX = 0;
+        let lastSnapZ = 0;
+        let lastTarget = null;
+        let committed = false;
+        const roofDrag = createRelativeRoofDrag(original);
+        const clearTarget = () => {
+            lastTarget = null;
+            setHasHit(false);
+            clearRoofSurfacePlacementGuides();
+        };
+        const resolveSnappedTarget = (event) => {
+            const rawTarget = roofDrag.resolve(event);
+            if (!rawTarget)
+                return null;
+            return snapRoofSurfaceNodeTarget({
+                target: snapRelativeRoofDragTarget(rawTarget, event.nativeEvent?.shiftKey === true),
+                node,
+                bypass: event.nativeEvent?.shiftKey === true,
+            });
+        };
+        // Resolve which segment the cursor is over, then derive the same
+        // preview transform stack the placement tool uses (`skylight/tool.tsx`):
+        // analytical surface normal in segment-local frame → outer yaw =
+        // roof + segment rotation. Falls back to leaving the preview hidden
+        // if the cursor is between segments — the placement tool does the
+        // same via its `if (!hit) return` guard.
+        const updateFromHit = (event) => {
+            const roof = event.node;
+            const target = resolveSnappedTarget(event);
+            if (!target) {
+                clearTarget();
+                return false;
+            }
+            lastTarget = target;
+            const normal = getAnalyticalNormal(target.localX, target.localZ, target.segment);
+            setPreviewSurfaceQuat(surfaceQuatFromNormal(normal, new THREE.Quaternion()));
+            setPreviewYaw((roof.rotation ?? 0) + (target.segment.rotation ?? 0));
+            setPreviewPos(roofSegmentLocalToBuildingLocal(target.segment.id, [
+                target.localX,
+                target.localY,
+                target.localZ,
+            ]));
+            setHasHit(true);
+            publishRoofSurfaceNodePlacementGuides({
+                roof,
+                segment: target.segment,
+                center: [target.localX, target.localY, target.localZ],
+                node,
+            });
+            return true;
+        };
+        const onRoofMove = (event) => {
+            const sx = Math.round(event.position[0] * 20) / 20;
+            const sz = Math.round(event.position[2] * 20) / 20;
+            if (event.nativeEvent?.shiftKey !== true && (sx !== lastSnapX || sz !== lastSnapZ)) {
+                triggerSFX('sfx:grid-snap');
+                lastSnapX = sx;
+                lastSnapZ = sz;
+            }
+            updateFromHit(event);
+            event.stopPropagation();
+        };
+        const onRoofEnter = (event) => {
+            updateFromHit(event);
+            event.stopPropagation();
+        };
+        const onRoofClick = (event) => {
+            if (committed)
+                return;
+            const st = useScene.getState();
+            const target = lastTarget ?? resolveSnappedTarget(event);
+            if (!target)
+                return;
+            committed = true;
+            const targetSegmentId = target.segment.id;
+            const finalRotation = original.rotation;
+            st.updateNode(node.id, {
+                position: original.position,
+                rotation: original.rotation,
+                roofSegmentId: original.roofSegmentId,
+                parentId: original.parentId,
+                metadata: original.metadata,
+            });
+            useScene.temporal.getState().resume();
+            st.updateNode(node.id, {
+                roofSegmentId: targetSegmentId,
+                parentId: targetSegmentId,
+                position: [target.localX, target.localY, target.localZ],
+                rotation: finalRotation,
+                visible: true,
+                metadata: {},
+            });
+            if (original.roofSegmentId && original.roofSegmentId !== targetSegmentId) {
+                const oldSeg = st.nodes[original.roofSegmentId];
+                if (oldSeg) {
+                    st.updateNode(original.roofSegmentId, {
+                        children: (oldSeg.children ?? []).filter((id) => id !== node.id),
+                    });
+                }
+                const newSeg = st.nodes[targetSegmentId];
+                if (newSeg && !(newSeg.children ?? []).includes(node.id)) {
+                    st.updateNode(targetSegmentId, {
+                        children: [...(newSeg.children ?? []), node.id],
+                    });
+                }
+                st.dirtyNodes.add(original.roofSegmentId);
+            }
+            st.dirtyNodes.add(targetSegmentId);
+            st.dirtyNodes.add(node.id);
+            useScene.temporal.getState().pause();
+            const obj = sceneRegistry.nodes.get(node.id);
+            if (obj)
+                obj.visible = true;
+            triggerSFX('sfx:item-place');
+            clearRoofSurfacePlacementGuides();
+            exitMoveMode();
+            event.stopPropagation();
+        };
+        const onCancel = () => {
+            if (isNew) {
+                useScene.temporal.getState().resume();
+                const parentId = original.roofSegmentId;
+                if (parentId) {
+                    const parent = useScene.getState().nodes[parentId];
+                    if (parent) {
+                        useScene.getState().updateNode(parentId, {
+                            children: (parent.children ?? []).filter((id) => id !== node.id),
+                        });
+                    }
+                }
+                useScene.getState().deleteNode(node.id);
+                markToolCancelConsumed();
+                clearRoofSurfacePlacementGuides();
+                exitMoveMode();
+                return;
+            }
+            useScene.getState().updateNode(node.id, {
+                position: original.position,
+                rotation: original.rotation,
+                roofSegmentId: original.roofSegmentId,
+                parentId: original.parentId,
+                metadata: original.metadata,
+            });
+            if (original.roofSegmentId) {
+                useScene.getState().dirtyNodes.add(original.roofSegmentId);
+            }
+            const obj = sceneRegistry.nodes.get(node.id);
+            if (obj)
+                obj.visible = true;
+            useScene.temporal.getState().resume();
+            markToolCancelConsumed();
+            clearRoofSurfacePlacementGuides();
+            exitMoveMode();
+        };
+        const onPlacementDragPointerUp = (event) => {
+            if (!consumePlacementDragRelease(event))
+                return;
+            if (!lastTarget)
+                return;
+            onRoofClick({
+                nativeEvent: event,
+                stopPropagation: () => event.stopPropagation(),
+            });
+        };
+        emitter.on('roof:move', onRoofMove);
+        emitter.on('roof:enter', onRoofEnter);
+        emitter.on('roof:click', onRoofClick);
+        emitter.on('roof:leave', clearTarget);
+        emitter.on('tool:cancel', onCancel);
+        window.addEventListener('pointerup', onPlacementDragPointerUp);
+        return () => {
+            emitter.off('roof:move', onRoofMove);
+            emitter.off('roof:enter', onRoofEnter);
+            emitter.off('roof:click', onRoofClick);
+            emitter.off('roof:leave', clearTarget);
+            emitter.off('tool:cancel', onCancel);
+            window.removeEventListener('pointerup', onPlacementDragPointerUp);
+            const obj = sceneRegistry.nodes.get(node.id);
+            if (obj)
+                obj.visible = true;
+            clearRoofSurfacePlacementGuides();
+            useScene.temporal.getState().resume();
+        };
+    }, [exitMoveMode, node]);
+    if (!previewSurfaceQuat)
+        return null;
+    return (_jsx("group", { position: previewPos, ref: previewRef, visible: hasHit, children: _jsx("group", { "rotation-y": previewYaw, children: _jsx("group", { quaternion: previewSurfaceQuat, children: _jsx("group", { "rotation-y": node.rotation ?? 0, children: _jsx(SkylightPreview, { node: node }) }) }) }) }));
+}

package/dist/skylight/panel.d.ts

@@ -0,0 +1,2 @@
+export default function SkylightPanel(): import("react").JSX.Element | null;
+//# sourceMappingURL=panel.d.ts.map

package/dist/skylight/panel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/skylight/panel.tsx"],"names":[],"mappings":"AAgCA,MAAM,CAAC,OAAO,UAAU,aAAa,uCAuiBpC"}