@pascal-app/nodes 0.1.1

package/dist/wall/treatments.js

@@ -0,0 +1,503 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { getWallCurveFrameAt, getWallThickness, isCurvedWall, WALL_CHAIR_RAIL_DEFAULT, WALL_CROWN_DEFAULT, WALL_SKIRTING_DEFAULT, WALL_SURFACE_SLOT_DEFAULTS, } from '@pascal-app/core';
+import { baseMaterial, createMaterialFromPresetRef, resolveMaterialRef, } from '@pascal-app/viewer';
+import { memo, useEffect, useMemo } from 'react';
+import * as THREE from 'three';
+import { mergeGeometries as mergeBufferGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+const CURVE_SEGMENTS = 24;
+const MIN_SLICE_PROUD = 0.0005;
+const EPS = 1e-6;
+function clamp01(value) {
+    return Math.max(0, Math.min(1, value));
+}
+function eased(value) {
+    const t = clamp01(value);
+    return t * t * (3 - 2 * t);
+}
+const TRIM_PROFILES = {
+    skirting: {
+        flat: {
+            samples: 8,
+            proudAt: (t) => (t < 0.72 ? 0.62 : 0.9),
+        },
+        bevel: {
+            samples: 10,
+            proudAt: (t) => 0.48 + 0.42 * eased(t),
+        },
+        triangle: {
+            samples: 10,
+            proudAt: (t) => 0.32 + 0.68 * (1 - t),
+        },
+        cove: {
+            samples: 12,
+            proudAt: (t) => 0.45 + 0.42 * Math.sin(t * Math.PI * 0.5),
+        },
+        bullnose: {
+            samples: 12,
+            proudAt: (t) => 0.35 + 0.65 * Math.sin(Math.PI * t),
+        },
+        'base-modern': {
+            samples: 10,
+            proudAt: (t) => {
+                if (t < 0.16)
+                    return 0.85;
+                if (t < 0.72)
+                    return 0.58;
+                if (t < 0.9)
+                    return 1;
+                return 0.62;
+            },
+        },
+        'base-colonial': {
+            samples: 14,
+            proudAt: (t) => {
+                if (t < 0.16)
+                    return 0.82;
+                if (t < 0.55)
+                    return 0.52;
+                const capT = (t - 0.55) / 0.45;
+                return 0.58 + 0.4 * Math.sin(capT * Math.PI);
+            },
+        },
+        'base-shoe': {
+            samples: 14,
+            proudAt: (t) => {
+                const quarterRound = Math.sqrt(Math.max(0, 1 - t * t));
+                return 0.28 + 0.72 * quarterRound;
+            },
+        },
+        'base-ogee': {
+            samples: 16,
+            proudAt: (t) => {
+                const ogee = 0.5 - 0.5 * Math.cos(Math.PI * t);
+                const bead = 0.16 * Math.sin(2 * Math.PI * t);
+                return clamp01(0.42 + 0.5 * ogee + bead);
+            },
+        },
+    },
+    crown: {
+        flat: {
+            samples: 8,
+            proudAt: (t) => (t < 0.2 ? 0.52 : t < 0.82 ? 0.78 : 1),
+        },
+        bevel: {
+            samples: 10,
+            proudAt: (t) => 0.45 + 0.55 * eased(t),
+        },
+        triangle: {
+            samples: 10,
+            proudAt: (t) => 0.35 + 0.65 * t,
+        },
+        cove: {
+            samples: 14,
+            proudAt: (t) => 0.46 + 0.45 * Math.sin(t * Math.PI * 0.5),
+        },
+        bullnose: {
+            samples: 14,
+            proudAt: (t) => 0.38 + 0.62 * Math.sin(Math.PI * t * 0.5),
+        },
+        'crown-cove': {
+            samples: 16,
+            proudAt: (t) => {
+                if (t < 0.12)
+                    return 0.48;
+                if (t > 0.9)
+                    return 1;
+                return 0.46 + 0.48 * Math.sin(((t - 0.12) / 0.78) * Math.PI * 0.5);
+            },
+        },
+        'crown-ogee': {
+            samples: 18,
+            proudAt: (t) => {
+                const sCurve = 0.5 - 0.5 * Math.cos(Math.PI * t);
+                const reverse = 0.18 * Math.sin(2 * Math.PI * (t - 0.12));
+                return clamp01(0.42 + 0.55 * sCurve + reverse);
+            },
+        },
+        'crown-craftsman': {
+            samples: 10,
+            proudAt: (t) => {
+                if (t < 0.16)
+                    return 0.48;
+                if (t < 0.4)
+                    return 0.88;
+                if (t < 0.78)
+                    return 0.64;
+                return 1;
+            },
+        },
+        'crown-layered': {
+            samples: 14,
+            proudAt: (t) => {
+                if (t < 0.12)
+                    return 0.46;
+                if (t < 0.28)
+                    return 0.82;
+                if (t < 0.48)
+                    return 0.56;
+                if (t < 0.72)
+                    return 0.9;
+                return 1;
+            },
+        },
+    },
+    chairRail: {
+        flat: {
+            samples: 8,
+            proudAt: (t) => (t < 0.18 || t > 0.82 ? 0.58 : 0.95),
+        },
+        bevel: {
+            samples: 10,
+            proudAt: (t) => 0.45 + 0.45 * Math.sin(Math.PI * t),
+        },
+        triangle: {
+            samples: 10,
+            proudAt: (t) => 0.35 + 0.65 * (1 - Math.abs(2 * t - 1)),
+        },
+        cove: {
+            samples: 12,
+            proudAt: (t) => 0.42 + 0.42 * Math.sin(Math.PI * t),
+        },
+        bullnose: {
+            samples: 14,
+            proudAt: (t) => 0.34 + 0.66 * Math.sin(Math.PI * t),
+        },
+        'rail-rounded': {
+            samples: 14,
+            proudAt: (t) => 0.34 + 0.66 * Math.sin(Math.PI * t),
+        },
+        'rail-ogee': {
+            samples: 16,
+            proudAt: (t) => {
+                const center = Math.sin(Math.PI * t);
+                const twist = 0.14 * Math.sin(2 * Math.PI * t);
+                return clamp01(0.36 + 0.58 * center + twist);
+            },
+        },
+        'rail-picture': {
+            samples: 12,
+            proudAt: (t) => {
+                if (t < 0.18)
+                    return 0.48;
+                if (t < 0.4)
+                    return 0.92;
+                if (t < 0.74)
+                    return 0.58;
+                return 1;
+            },
+        },
+        'rail-stepped': {
+            samples: 10,
+            proudAt: (t) => {
+                if (t < 0.22)
+                    return 0.55;
+                if (t < 0.78)
+                    return 1;
+                return 0.62;
+            },
+        },
+    },
+};
+const TRIM_KIND_CONFIG = {
+    skirting: {
+        defaultConfig: WALL_SKIRTING_DEFAULT,
+        slots: { interior: 'skirtingInterior', exterior: 'skirtingExterior' },
+    },
+    crown: {
+        defaultConfig: WALL_CROWN_DEFAULT,
+        slots: { interior: 'crownInterior', exterior: 'crownExterior' },
+    },
+    chairRail: {
+        defaultConfig: WALL_CHAIR_RAIL_DEFAULT,
+        slots: { interior: 'chairRailInterior', exterior: 'chairRailExterior' },
+    },
+};
+function resolveTrimProfile(kind, trim) {
+    const defaultProfile = TRIM_KIND_CONFIG[kind].defaultConfig.profile;
+    return (TRIM_PROFILES[kind][trim.profile] ??
+        TRIM_PROFILES[kind][defaultProfile] ??
+        TRIM_PROFILES[kind].flat);
+}
+function resolveTreatmentSideSign(node, side) {
+    if (side === 'interior') {
+        if (node.frontSide === 'interior')
+            return 1;
+        if (node.backSide === 'interior')
+            return -1;
+        return 1;
+    }
+    if (node.frontSide === 'exterior')
+        return 1;
+    if (node.backSide === 'exterior')
+        return -1;
+    return -1;
+}
+function wallToLocalTransform(node) {
+    const dx = node.end[0] - node.start[0];
+    const dz = node.end[1] - node.start[1];
+    const angle = Math.atan2(dz, dx);
+    const cosA = Math.cos(-angle);
+    const sinA = Math.sin(-angle);
+    return (worldX, worldZ) => {
+        const px = worldX - node.start[0];
+        const pz = worldZ - node.start[1];
+        return {
+            x: px * cosA - pz * sinA,
+            z: px * sinA + pz * cosA,
+        };
+    };
+}
+function buildSidePolyline(node, side, offset) {
+    const sideSign = resolveTreatmentSideSign(node, side);
+    const toLocal = wallToLocalTransform(node);
+    const sampleCount = isCurvedWall(node) ? CURVE_SEGMENTS : 1;
+    const points = [];
+    for (let index = 0; index <= sampleCount; index += 1) {
+        const frame = getWallCurveFrameAt(node, index / sampleCount);
+        const worldX = frame.point.x + frame.normal.x * offset * sideSign;
+        const worldZ = frame.point.y + frame.normal.y * offset * sideSign;
+        points.push(toLocal(worldX, worldZ));
+    }
+    return points;
+}
+function clipPolyline(points, x0, x1) {
+    if (points.length < 2 || x1 - x0 <= EPS)
+        return [];
+    const out = [];
+    for (let index = 0; index < points.length - 1; index += 1) {
+        const a = points[index];
+        const b = points[index + 1];
+        if (!(a && b))
+            continue;
+        const minX = Math.min(a.x, b.x);
+        const maxX = Math.max(a.x, b.x);
+        if (maxX < x0 - EPS || minX > x1 + EPS)
+            continue;
+        const pushPointAt = (x) => {
+            if (Math.abs(b.x - a.x) <= EPS) {
+                return { x, z: a.z };
+            }
+            const t = (x - a.x) / (b.x - a.x);
+            return {
+                x,
+                z: a.z + (b.z - a.z) * t,
+            };
+        };
+        const start = minX < x0 ? pushPointAt(x0) : a;
+        const end = maxX > x1 ? pushPointAt(x1) : b;
+        if (out.length === 0 ||
+            Math.hypot(out[out.length - 1].x - start.x, out[out.length - 1].z - start.z) > EPS) {
+            out.push(start);
+        }
+        out.push(end);
+    }
+    return out;
+}
+function subtractOpeningRanges(ranges, openings) {
+    let next = ranges.slice();
+    for (const [gap0, gap1] of openings) {
+        const updated = [];
+        for (const [a, b] of next) {
+            const start = Math.max(a, gap0);
+            const end = Math.min(b, gap1);
+            if (end - start <= EPS) {
+                updated.push([a, b]);
+                continue;
+            }
+            if (start - a > EPS)
+                updated.push([a, start]);
+            if (b - end > EPS)
+                updated.push([end, b]);
+        }
+        next = updated;
+    }
+    return next;
+}
+function trimOpeningRanges(node, childrenNodes, yBottom, height) {
+    const yTop = yBottom + height;
+    return childrenNodes
+        .filter((child) => child.type === 'door' || child.type === 'window')
+        .flatMap((child) => {
+        const width = child.width ?? 0;
+        const childHeight = child.height ?? 0;
+        const position = child.position ?? [0, 0, 0];
+        const childBottom = position[1] - childHeight / 2;
+        const childTop = childBottom + childHeight;
+        if (childTop <= yBottom + EPS || childBottom >= yTop - EPS)
+            return [];
+        return [[position[0] - width / 2, position[0] + width / 2]];
+    });
+}
+function buildPlanPolygon(outer, inner) {
+    if (outer.length < 2 || inner.length < 2)
+        return null;
+    const shape = new THREE.Shape();
+    shape.moveTo(outer[0].x, -outer[0].z);
+    for (let index = 1; index < outer.length; index += 1) {
+        shape.lineTo(outer[index].x, -outer[index].z);
+    }
+    for (let index = inner.length - 1; index >= 0; index -= 1) {
+        shape.lineTo(inner[index].x, -inner[index].z);
+    }
+    shape.closePath();
+    return shape;
+}
+function applyWorldScaleUvs(geometry) {
+    const position = geometry.getAttribute('position');
+    if (!position)
+        return;
+    const normal = geometry.getAttribute('normal');
+    const uv = new Float32Array(position.count * 2);
+    for (let index = 0; index < position.count; index += 1) {
+        const x = position.getX(index);
+        const y = position.getY(index);
+        const z = position.getZ(index);
+        const nx = Math.abs(normal?.getX(index) ?? 0);
+        const ny = Math.abs(normal?.getY(index) ?? 0);
+        const nz = Math.abs(normal?.getZ(index) ?? 0);
+        const offset = index * 2;
+        if (ny >= nx && ny >= nz) {
+            uv[offset] = x;
+            uv[offset + 1] = z;
+        }
+        else if (nz >= nx) {
+            uv[offset] = x;
+            uv[offset + 1] = y;
+        }
+        else {
+            uv[offset] = z;
+            uv[offset + 1] = y;
+        }
+    }
+    geometry.setAttribute('uv', new THREE.BufferAttribute(uv, 2));
+}
+function buildTrimSliceGeometry(outer, inner, extrudeHeight, translateY) {
+    const shape = buildPlanPolygon(outer, inner);
+    if (!shape)
+        return null;
+    const geometry = new THREE.ExtrudeGeometry(shape, {
+        depth: extrudeHeight,
+        bevelEnabled: false,
+        steps: 1,
+        curveSegments: 1,
+    });
+    geometry.rotateX(-Math.PI / 2);
+    geometry.translate(0, translateY, 0);
+    geometry.computeVertexNormals();
+    applyWorldScaleUvs(geometry);
+    return geometry;
+}
+function mergeGeometries(geometries) {
+    if (geometries.length === 0)
+        return null;
+    const merged = mergeBufferGeometries(geometries, false);
+    if (merged)
+        return merged;
+    return null;
+}
+function buildTrimGeometry(node, side, trim, kind, childrenNodes) {
+    const wallHeight = node.height ?? 2.5;
+    const height = trim.height;
+    const yBottom = kind === 'crown'
+        ? Math.max(0, wallHeight - height)
+        : kind === 'chairRail'
+            ? Math.max(0, Math.min(wallHeight - height, trim.offsetY ?? WALL_CHAIR_RAIL_DEFAULT.offsetY ?? 0.9))
+            : 0;
+    const thickness = getWallThickness(node);
+    const inner = buildSidePolyline(node, side, thickness / 2);
+    if (inner.length < 2)
+        return null;
+    const openingRanges = trimOpeningRanges(node, childrenNodes, yBottom, height);
+    const fullRanges = [[inner[0].x, inner[inner.length - 1].x]];
+    const runs = subtractOpeningRanges(fullRanges, openingRanges);
+    if (runs.length === 0)
+        return null;
+    const slices = [];
+    const profile = resolveTrimProfile(kind, trim);
+    if (!profile)
+        return null;
+    const sliceHeight = height / profile.samples;
+    for (const [runStart, runEnd] of runs) {
+        const innerRun = clipPolyline(inner, runStart, runEnd);
+        if (innerRun.length < 2)
+            continue;
+        for (let index = 0; index < profile.samples; index += 1) {
+            const t = (index + 0.5) / profile.samples;
+            const proud = Math.max(MIN_SLICE_PROUD, trim.proud * profile.proudAt(t));
+            const outerRun = buildSidePolyline(node, side, thickness / 2 + proud);
+            const outerClipped = clipPolyline(outerRun, runStart, runEnd);
+            if (outerClipped.length < 2)
+                continue;
+            const slice = buildTrimSliceGeometry(outerClipped, innerRun, sliceHeight, yBottom + index * sliceHeight);
+            if (slice)
+                slices.push(slice);
+        }
+    }
+    if (slices.length === 0)
+        return null;
+    const merged = mergeGeometries(slices);
+    for (const slice of slices)
+        slice.dispose();
+    return merged;
+}
+function resolveWallSlotMaterial(node, slotId, shading, sceneMaterials) {
+    const ref = node.slots?.[slotId];
+    if (ref) {
+        return resolveMaterialRef(ref, sceneMaterials, shading) ?? baseMaterial(shading);
+    }
+    return (createMaterialFromPresetRef(WALL_SURFACE_SLOT_DEFAULTS[slotId], shading) ??
+        baseMaterial(shading));
+}
+export function createWallExtraSlotMaterials(node, shading, sceneMaterials) {
+    return {
+        skirtingInterior: resolveWallSlotMaterial(node, 'skirtingInterior', shading, sceneMaterials),
+        skirtingExterior: resolveWallSlotMaterial(node, 'skirtingExterior', shading, sceneMaterials),
+        crownInterior: resolveWallSlotMaterial(node, 'crownInterior', shading, sceneMaterials),
+        crownExterior: resolveWallSlotMaterial(node, 'crownExterior', shading, sceneMaterials),
+        chairRailInterior: resolveWallSlotMaterial(node, 'chairRailInterior', shading, sceneMaterials),
+        chairRailExterior: resolveWallSlotMaterial(node, 'chairRailExterior', shading, sceneMaterials),
+    };
+}
+export const WallTreatments = memo(function WallTreatments({ node, childrenNodes, materials, }) {
+    const fallbackMaterial = materials.skirtingInterior ??
+        materials.skirtingExterior ??
+        materials.crownInterior ??
+        materials.crownExterior ??
+        materials.chairRailInterior ??
+        materials.chairRailExterior;
+    const trimEntries = useMemo(() => {
+        const out = [];
+        const configs = [
+            ['skirting', node.skirting],
+            ['crown', node.crown],
+            ['chairRail', node.chairRail],
+        ];
+        for (const [kind, rawConfig] of configs) {
+            const trim = { ...TRIM_KIND_CONFIG[kind].defaultConfig, ...(rawConfig ?? {}) };
+            if (!trim.enabled)
+                continue;
+            const sides = trim.sides === 'both'
+                ? ['interior', 'exterior']
+                : [trim.sides];
+            for (const side of sides) {
+                const geometry = buildTrimGeometry(node, side, trim, kind, childrenNodes);
+                if (!geometry)
+                    continue;
+                const slotId = TRIM_KIND_CONFIG[kind].slots[side];
+                out.push({
+                    key: `${kind}-${side}`,
+                    slotId,
+                    geometry,
+                    material: materials[slotId] ?? fallbackMaterial,
+                });
+            }
+        }
+        return out;
+    }, [childrenNodes, fallbackMaterial, materials, node]);
+    useEffect(() => () => {
+        for (const entry of trimEntries)
+            entry.geometry.dispose();
+    }, [trimEntries]);
+    return (_jsx(_Fragment, { children: trimEntries.map((entry) => (_jsx("mesh", { castShadow: true, geometry: entry.geometry, material: entry.material, receiveShadow: true, userData: { slotId: entry.slotId } }, entry.key))) }));
+});

package/dist/window/definition.d.ts

@@ -0,0 +1,15 @@
+import type { NodeDefinition } from '@pascal-app/core';
+import { WindowNode } from './schema';
+/**
+ * Window — Phase 5 batch kind. Mirrors door's shape: hosted on walls,
+ * cuts holes in them, animated open/close state for opening windows.
+ *
+ * Stages:
+ *  - A: registered.
+ *  - B: deferred — window geometry ~800 lines; extraction is a focused
+ *    session. `def.renderer` + `def.system` wrap-export legacy.
+ *  - C: `def.floorplan` polygon sits in parent wall's cutout. Legacy
+ *    `openingPolygons` short-circuits window entries when registered.
+ */
+export declare const windowDefinition: NodeDefinition<typeof WindowNode>;
+//# sourceMappingURL=definition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/window/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,cAAc,EAIf,MAAM,kBAAkB,CAAA;AAUzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAwIrC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CA6F9D,CAAA"}