@pascal-app/nodes 1.0.5 → 1.0.7

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/roof/tool.d.ts

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

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

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