@pascal-app/nodes 1.0.0 → 1.0.3

package/dist/wall/curtain-wall-geometry.js

@@ -0,0 +1,226 @@
+import { getCurtainWallConfig, getWallCurveFrameAt, getWallCurveLength, getWallThickness, isCurvedWall, } from '@pascal-app/core';
+import { Brush, Evaluator, ensureRenderableGeometryAttributes, INTERSECTION, prepareBrushForCSG, SUBTRACTION, } from '@pascal-app/viewer';
+import { BufferGeometry, ExtrudeGeometry, Shape } from 'three';
+import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+import { buildCurtainOpeningFrame, mapCurtainOpeningGeometryToWall } from './curtain-opening-frame';
+import { buildCurtainWallLayout, curtainGridPositions, } from './curtain-wall-layout';
+import { buildStraightCurtainPieces, buildStraightCurtainPiecesWithCutouts, } from './curtain-wall-piece-geometry';
+function pieceGeometry(wall, piece, length, base) {
+    const angle = Math.atan2(wall.end[1] - wall.start[1], wall.end[0] - wall.start[0]);
+    const cos = Math.cos(angle), sin = Math.sin(angle);
+    const samples = isCurvedWall(wall)
+        ? Math.max(1, Math.ceil(((piece.right - piece.left) / length) * 48))
+        : 1;
+    const points = [];
+    for (const offset of [piece.front, piece.back]) {
+        const side = [];
+        for (let i = 0; i <= samples; i++) {
+            const along = piece.left + ((piece.right - piece.left) * i) / samples;
+            if (!isCurvedWall(wall)) {
+                side.push([along, -offset]);
+                continue;
+            }
+            const frame = getWallCurveFrameAt(wall, along / length);
+            const x = frame.point.x + frame.normal.x * offset - wall.start[0];
+            const z = frame.point.y + frame.normal.y * offset - wall.start[1];
+            side.push([x * cos + z * sin, -(-x * sin + z * cos)]);
+        }
+        points.push(...(offset === piece.front ? side : side.reverse()));
+    }
+    const shape = new Shape();
+    shape.moveTo(...points[0]);
+    for (const point of points.slice(1))
+        shape.lineTo(...point);
+    shape.closePath();
+    const geometry = new ExtrudeGeometry(shape, {
+        depth: piece.top - piece.bottom,
+        bevelEnabled: false,
+    });
+    geometry.rotateX(-Math.PI / 2);
+    geometry.translate(0, base + piece.bottom, 0);
+    ensureRenderableGeometryAttributes(geometry);
+    return geometry;
+}
+export function buildCurtainWallGeometry(wall, envelope, children = [], livePreview = false) {
+    const length = getWallCurveLength(wall);
+    envelope.computeBoundingBox();
+    const bounds = envelope.boundingBox;
+    if (!bounds || bounds.isEmpty() || length <= 1e-6)
+        return envelope;
+    const pieces = buildCurtainWallLayout(length, bounds.max.y - bounds.min.y, getWallThickness(wall), getCurtainWallConfig(wall), children.filter((child) => child.type === 'door' || child.type === 'window'), bounds.min.y);
+    const shapedFrames = children
+        .filter((child) => (child.type === 'window' || child.type === 'door') && child.openingShape !== 'rectangle')
+        .map((opening) => {
+        const geometry = buildCurtainOpeningFrame(opening, getCurtainWallConfig(wall).perimeterWidth, getWallThickness(wall));
+        mapCurtainOpeningGeometryToWall(geometry.frame, wall);
+        mapCurtainOpeningGeometryToWall(geometry.cutter, wall);
+        return geometry;
+    });
+    const hasRectangularOpenings = children.some((child) => (child.type === 'window' || child.type === 'door') && child.openingShape === 'rectangle');
+    const evaluator = new Evaluator();
+    evaluator.attributes = ['position', 'normal', 'uv', 'uv2'];
+    evaluator.useGroups = false;
+    const shell = new Brush(envelope);
+    const position = envelope.getAttribute('position');
+    const near = (a, b) => Math.abs(a - b) < 1e-6;
+    const halfDepth = getWallThickness(wall) / 2;
+    const rectangular = !isCurvedWall(wall) &&
+        Array.from({ length: position.count }, (_, i) => i).every((i) => (near(position.getX(i), 0) || near(position.getX(i), length)) &&
+            (near(position.getY(i), bounds.min.y) || near(position.getY(i), bounds.max.y)) &&
+            (near(position.getZ(i), -halfDepth) || near(position.getZ(i), halfDepth)));
+    if (rectangular) {
+        for (const { frame } of shapedFrames) {
+            const framePosition = frame.getAttribute('position');
+            for (let index = 0; index < framePosition.count; index++) {
+                framePosition.setX(index, Math.max(bounds.min.x, Math.min(bounds.max.x, framePosition.getX(index))));
+                framePosition.setY(index, Math.max(bounds.min.y, Math.min(bounds.max.y, framePosition.getY(index))));
+            }
+            framePosition.needsUpdate = true;
+            frame.computeVertexNormals();
+        }
+    }
+    if (!rectangular)
+        prepareBrushForCSG(shell);
+    const leftEnvelopeXs = [];
+    const rightEnvelopeXs = [];
+    if (!rectangular && !isCurvedWall(wall)) {
+        for (let index = 0; index < position.count; index++) {
+            const x = position.getX(index);
+            (x < length / 2 ? leftEnvelopeXs : rightEnvelopeXs).push(x);
+        }
+    }
+    const safeLeft = leftEnvelopeXs.length ? Math.max(...leftEnvelopeXs) : 0;
+    const safeRight = rightEnvelopeXs.length ? Math.min(...rightEnvelopeXs) : length;
+    const xs = curtainGridPositions(length, getCurtainWallConfig(wall).columns);
+    const ys = curtainGridPositions(bounds.max.y - bounds.min.y, getCurtainWallConfig(wall).rows);
+    const cutRegions = shapedFrames.map(({ cutter }) => {
+        cutter.computeBoundingBox();
+        const box = cutter.boundingBox;
+        // Keep every fragment of a pane in the same partition to avoid new glass seams.
+        const lower = (positions, value) => [...positions].reverse().find((p) => p <= value) ?? positions[0];
+        const upper = (positions, value) => positions.find((p) => p >= value) ?? positions.at(-1);
+        return {
+            left: lower(xs, box.min.x),
+            right: upper(xs, box.max.x),
+            bottom: lower(ys, box.min.y - bounds.min.y),
+            top: upper(ys, box.max.y - bounds.min.y),
+        };
+    });
+    const results = [];
+    const roles = ['frame', 'glass', 'solid'];
+    try {
+        for (const [materialIndex, role] of roles.entries()) {
+            const allRolePieces = pieces.filter((piece) => piece.role === role);
+            const nearCut = (piece) => isCurvedWall(wall) ||
+                (!rectangular && (piece.left < safeLeft - 1e-6 || piece.right > safeRight + 1e-6)) ||
+                cutRegions.some((region) => piece.left < region.right &&
+                    piece.right > region.left &&
+                    piece.bottom < region.top &&
+                    piece.top > region.bottom);
+            const partitionPieces = !rectangular || cutRegions.length > 0;
+            const rolePieces = allRolePieces.filter(nearCut);
+            const untouchedPieces = partitionPieces
+                ? allRolePieces.filter((piece) => !nearCut(piece))
+                : [];
+            const builtPieces = partitionPieces ? rolePieces : allRolePieces;
+            if (!allRolePieces.length && !(role === 'frame' && shapedFrames.length))
+                continue;
+            let merged = null;
+            if (!isCurvedWall(wall) && builtPieces.length) {
+                const straightPieces = builtPieces.map((piece) => ({
+                    ...piece,
+                    left: piece.left === 0 ? Math.min(0, bounds.min.x) : piece.left,
+                    right: piece.right === length ? Math.max(length, bounds.max.x) : piece.right,
+                }));
+                merged =
+                    rectangular && shapedFrames.length
+                        ? buildStraightCurtainPiecesWithCutouts(straightPieces, bounds.min.y, shapedFrames.map(({ cutout }) => cutout))
+                        : buildStraightCurtainPieces(straightPieces, bounds.min.y, livePreview ? false : hasRectangularOpenings || shapedFrames.length > 0);
+            }
+            else if (builtPieces.length) {
+                const sources = rolePieces.map((piece) => pieceGeometry(wall, piece, length, bounds.min.y));
+                merged = mergeGeometries(sources, false);
+                for (const source of sources)
+                    source.dispose();
+            }
+            if (merged && !rectangular) {
+                for (const opening of shapedFrames) {
+                    if (!merged.getAttribute('position').count)
+                        break;
+                    const brush = new Brush(merged);
+                    const cutter = new Brush(opening.cutter);
+                    prepareBrushForCSG(brush);
+                    prepareBrushForCSG(cutter);
+                    const cut = evaluator.evaluate(brush, cutter, SUBTRACTION).geometry;
+                    merged.dispose();
+                    merged = cut.index ? cut.toNonIndexed() : cut;
+                    if (merged !== cut)
+                        cut.dispose();
+                }
+            }
+            if (role === 'frame' && shapedFrames.length) {
+                const frames = shapedFrames.map(({ frame }) => frame);
+                const combined = mergeGeometries(merged ? [merged, ...frames] : frames, false);
+                merged?.dispose();
+                if (!combined)
+                    continue;
+                merged = combined;
+            }
+            if (merged && !rectangular) {
+                const brush = new Brush(merged);
+                prepareBrushForCSG(brush);
+                try {
+                    // The existing wall envelope owns miter joins, support profiles, and all hosted cuts.
+                    const clipped = evaluator.evaluate(brush, shell, INTERSECTION).geometry;
+                    const geometry = clipped.index ? clipped.toNonIndexed() : clipped;
+                    if (geometry !== clipped)
+                        clipped.dispose();
+                    merged.dispose();
+                    merged = geometry;
+                }
+                catch (error) {
+                    merged.dispose();
+                    throw error;
+                }
+            }
+            if (untouchedPieces.length) {
+                const untouched = buildStraightCurtainPieces(untouchedPieces, bounds.min.y, false);
+                if (merged) {
+                    const combined = mergeGeometries([merged, untouched], false);
+                    untouched.dispose();
+                    merged.dispose();
+                    if (!combined)
+                        continue;
+                    merged = combined;
+                }
+                else {
+                    merged = untouched;
+                }
+            }
+            if (!merged)
+                continue;
+            merged.clearGroups();
+            merged.addGroup(0, merged.getAttribute('position').count, materialIndex);
+            results.push(merged);
+        }
+        if (!results.length)
+            return new BufferGeometry();
+        const combined = mergeGeometries(results, false) ?? new BufferGeometry();
+        let start = 0;
+        for (const result of results) {
+            const count = result.getAttribute('position').count;
+            combined.addGroup(start, count, result.groups[0].materialIndex);
+            start += count;
+        }
+        return combined;
+    }
+    finally {
+        for (const opening of shapedFrames) {
+            opening.frame.dispose();
+            opening.cutter.dispose();
+        }
+        envelope.dispose();
+        for (const result of results)
+            result.dispose();
+    }
+}

package/dist/wall/curtain-wall-layout.d.ts

@@ -0,0 +1,16 @@
+import type { CurtainGrid, CurtainPanelType, CurtainWallConfig, DoorNode } from '@pascal-app/core';
+export declare function curtainGridPositions(length: number, grid: CurtainGrid): number[];
+export type CurtainWallPiece = {
+    left: number;
+    right: number;
+    bottom: number;
+    top: number;
+    front: number;
+    back: number;
+    role: 'frame' | 'glass' | 'solid';
+};
+export declare function curtainPanelType(config: CurtainWallConfig, column: number, row: number, rowCount: number): CurtainPanelType;
+export declare function buildCurtainWallLayout(length: number, height: number, depth: number, config: CurtainWallConfig, openings?: readonly (Pick<DoorNode, 'position' | 'width' | 'height' | 'openingShape'> & {
+    type: 'door' | 'window';
+})[], baseElevation?: number): CurtainWallPiece[];
+//# sourceMappingURL=curtain-wall-layout.d.ts.map

package/dist/wall/curtain-wall-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curtain-wall-layout.d.ts","sourceRoot":"","sources":["../../src/wall/curtain-wall-layout.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAElG,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,MAAM,EAAE,CAqBhF;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,CAAA;CAClC,CAAA;AAED,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,iBAAiB,EACzB,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,GACf,gBAAgB,CASlB;AAED,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,iBAAiB,EACzB,QAAQ,GAAE,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,UAAU,GAAG,OAAO,GAAG,QAAQ,GAAG,cAAc,CAAC,GAAG;IACrF,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAA;CACxB,CAAC,EAAO,EACT,aAAa,SAAI,GAChB,gBAAgB,EAAE,CAqMpB"}

package/dist/wall/curtain-wall-layout.js

@@ -0,0 +1,176 @@
+export function curtainGridPositions(length, grid) {
+    if (!Number.isFinite(length) || length <= 0)
+        return [0];
+    const count = grid.layout === 'count' ? grid.count : Math.ceil(length / grid.spacing);
+    const bounded = Math.max(1, Math.min(32, count));
+    if (grid.layout !== 'fixed-spacing' || count > 32) {
+        return Array.from({ length: bounded + 1 }, (_, index) => (length * index) / bounded);
+    }
+    const whole = Math.floor(length / grid.spacing);
+    const remainder = length - whole * grid.spacing;
+    const offset = grid.alignment === 'start' ? 0 : grid.alignment === 'end' ? remainder : remainder / 2;
+    const positions = [0];
+    for (let index = 0; index <= whole; index++) {
+        const value = offset + index * grid.spacing;
+        if (value > 1e-6 && value < length - 1e-6)
+            positions.push(value);
+    }
+    positions.push(length);
+    // A centered remainder can introduce two edge cells.
+    return positions.length <= 33
+        ? positions
+        : Array.from({ length: 33 }, (_, i) => (length * i) / 32);
+}
+export function curtainPanelType(config, column, row, rowCount) {
+    const override = config.panels.find((panel) => panel.column === column && panel.row === row);
+    if (override)
+        return override.type;
+    if ((config.spandrel === 'bottom' && row === 0) ||
+        (config.spandrel === 'top' && row === rowCount - 1))
+        return 'solid';
+    return config.panelType;
+}
+export function buildCurtainWallLayout(length, height, depth, config, openings = [], baseElevation = 0) {
+    if (length <= 1e-6 || height <= 1e-6 || depth <= 0)
+        return [];
+    const xs = curtainGridPositions(length, config.columns);
+    const ys = curtainGridPositions(height, config.rows);
+    const pieces = [];
+    const panelDepth = Math.min(config.glassThickness, depth * 0.45);
+    const panelFront = depth / 2 - Math.min(0.005, depth * 0.05);
+    const panelBack = panelFront - panelDepth;
+    const add = (left, right, bottom, top, front, role, back = -depth / 2) => {
+        if (right - left > 1e-6 && top - bottom > 1e-6 && front - back > 1e-6)
+            pieces.push({ left, right, bottom, top, front, back, role });
+    };
+    const verticalCap = config.framing === 'capped' || config.framing === 'vertical-caps';
+    const horizontalCap = config.framing === 'capped' || config.framing === 'horizontal-caps';
+    if (config.construction === 'stick') {
+        const verticalBounds = xs.map((x, index) => {
+            if (index === 0)
+                return [0, Math.min(config.perimeterWidth, (xs[1] - x) * 0.4)];
+            if (index === xs.length - 1)
+                return [length - Math.min(config.perimeterWidth, (x - xs[index - 1]) * 0.4), length];
+            return [
+                x - Math.min(config.mullionWidth / 2, (x - xs[index - 1]) * 0.4),
+                x + Math.min(config.mullionWidth / 2, (xs[index + 1] - x) * 0.4),
+            ];
+        });
+        const horizontalBounds = ys.map((y, index) => {
+            if (index === 0)
+                return [0, Math.min(config.perimeterWidth, (ys[1] - y) * 0.4)];
+            if (index === ys.length - 1)
+                return [height - Math.min(config.perimeterWidth, (y - ys[index - 1]) * 0.4), height];
+            return [
+                y - Math.min(config.transomWidth / 2, (y - ys[index - 1]) * 0.4),
+                y + Math.min(config.transomWidth / 2, (ys[index + 1] - y) * 0.4),
+            ];
+        });
+        for (const [left, right] of verticalBounds)
+            add(left, right, 0, height, verticalCap ? depth / 2 : panelBack, 'frame');
+        for (const [bottom, top] of horizontalBounds) {
+            for (let column = 0; column < xs.length - 1; column++) {
+                add(verticalBounds[column][1], verticalBounds[column + 1][0], bottom, top, horizontalCap ? depth / 2 : panelBack, 'frame');
+            }
+        }
+        for (let column = 0; column < xs.length - 1; column++) {
+            for (let row = 0; row < ys.length - 1; row++) {
+                const type = curtainPanelType(config, column, row, ys.length - 1);
+                if (type === 'empty')
+                    continue;
+                add(verticalBounds[column][1], verticalBounds[column + 1][0], horizontalBounds[row][1], horizontalBounds[row + 1][0], panelFront, type, panelBack);
+            }
+        }
+    }
+    else {
+        for (let column = 0; column < xs.length - 1; column++) {
+            for (let row = 0; row < ys.length - 1; row++) {
+                const x0 = xs[column], x1 = xs[column + 1], y0 = ys[row], y1 = ys[row + 1];
+                const gap = config.construction === 'unitized'
+                    ? Math.min(config.jointWidth / 2, (x1 - x0) / 10, (y1 - y0) / 10)
+                    : 0;
+                const left = x0 + (column === 0 ? 0 : gap), right = x1 - (column === xs.length - 2 ? 0 : gap);
+                const bottom = y0 + (row === 0 ? 0 : gap), top = y1 - (row === ys.length - 2 ? 0 : gap);
+                const lw = Math.min(column === 0 ? config.perimeterWidth : config.mullionWidth / 2, (right - left) * 0.4);
+                const rw = Math.min(column === xs.length - 2 ? config.perimeterWidth : config.mullionWidth / 2, (right - left) * 0.4);
+                const bw = Math.min(row === 0 ? config.perimeterWidth : config.transomWidth / 2, (top - bottom) * 0.4);
+                const tw = Math.min(row === ys.length - 2 ? config.perimeterWidth : config.transomWidth / 2, (top - bottom) * 0.4);
+                add(left, left + lw, bottom, top, verticalCap ? depth / 2 : panelBack, 'frame');
+                add(right - rw, right, bottom, top, verticalCap ? depth / 2 : panelBack, 'frame');
+                add(left + lw, right - rw, bottom, bottom + bw, horizontalCap ? depth / 2 : panelBack, 'frame');
+                add(left + lw, right - rw, top - tw, top, horizontalCap ? depth / 2 : panelBack, 'frame');
+                const type = curtainPanelType(config, column, row, ys.length - 1);
+                if (type === 'empty')
+                    continue;
+                const joint = Math.min(config.jointWidth / 2, (right - left) * 0.1, (top - bottom) * 0.1);
+                add(left + (verticalCap ? lw : joint), right - (verticalCap ? rw : joint), bottom + (horizontalCap ? bw : joint), top - (horizontalCap ? tw : joint), panelFront, type, panelBack);
+            }
+        }
+    }
+    let fitted = pieces;
+    for (const opening of openings) {
+        if (opening.openingShape !== 'rectangle')
+            continue;
+        const left = opening.position[0] - opening.width / 2;
+        const right = opening.position[0] + opening.width / 2;
+        const bottom = opening.position[1] - opening.height / 2 - baseElevation;
+        const top = bottom + opening.height;
+        if (right <= 0 || left >= length || top <= 0 || bottom >= height)
+            continue;
+        const outerLeft = Math.max(0, left - config.perimeterWidth);
+        const outerRight = Math.min(length, right + config.perimeterWidth);
+        const outerBottom = Math.max(0, bottom - (opening.type === 'window' ? config.perimeterWidth : 0));
+        const outerTop = Math.min(height, top + config.perimeterWidth);
+        // Replace intersecting infill and grid members with a continuous entrance subframe.
+        fitted = fitted.flatMap((piece) => {
+            const x0 = Math.max(piece.left, outerLeft);
+            const x1 = Math.min(piece.right, outerRight);
+            const y0 = Math.max(piece.bottom, outerBottom);
+            const y1 = Math.min(piece.top, outerTop);
+            if (x1 <= x0 || y1 <= y0)
+                return [piece];
+            return [
+                { ...piece, right: x0 },
+                { ...piece, left: x1 },
+                { ...piece, left: x0, right: x1, top: y0 },
+                { ...piece, left: x0, right: x1, bottom: y1 },
+            ].filter((part) => part.right - part.left > 1e-6 && part.top - part.bottom > 1e-6);
+        });
+        const frame = { front: depth / 2, back: -depth / 2, role: 'frame' };
+        fitted.push(...[
+            ...(opening.type === 'window'
+                ? [
+                    {
+                        ...frame,
+                        left: Math.max(0, left),
+                        right: Math.min(length, right),
+                        bottom: outerBottom,
+                        top: Math.min(height, bottom),
+                    },
+                ]
+                : []),
+            {
+                ...frame,
+                left: outerLeft,
+                right: Math.min(length, left),
+                bottom: outerBottom,
+                top: outerTop,
+            },
+            {
+                ...frame,
+                left: Math.max(0, right),
+                right: outerRight,
+                bottom: outerBottom,
+                top: outerTop,
+            },
+            {
+                ...frame,
+                left: Math.max(0, left),
+                right: Math.min(length, right),
+                bottom: Math.max(0, top),
+                top: outerTop,
+            },
+        ].filter((part) => part.right - part.left > 1e-6 && part.top - part.bottom > 1e-6));
+    }
+    return fitted;
+}

package/dist/wall/curtain-wall-materials.d.ts

@@ -0,0 +1,5 @@
+import { type SceneMaterial, type SceneMaterialId, type WallNode } from '@pascal-app/core';
+import { getMaterialsForWall, type RenderShading, type WallMaterialOverride, type WallMaterials } from '@pascal-app/viewer';
+export declare function createCurtainWallMaterials(wall: WallNode, shading: RenderShading, materials?: Record<SceneMaterialId, SceneMaterial>): WallMaterialOverride;
+export declare function getCurtainAwareWallMaterials(wall: WallNode, shading?: RenderShading, textures?: boolean, colorPreset?: Parameters<typeof getMaterialsForWall>[3], sceneTheme?: string, materials?: Record<SceneMaterialId, SceneMaterial>): WallMaterials;
+//# sourceMappingURL=curtain-wall-materials.d.ts.map

package/dist/wall/curtain-wall-materials.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curtain-wall-materials.d.ts","sourceRoot":"","sources":["../../src/wall/curtain-wall-materials.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EACL,mBAAmB,EACnB,KAAK,aAAa,EAElB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EACnB,MAAM,oBAAoB,CAAA;AAI3B,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,QAAQ,EACd,OAAO,EAAE,aAAa,EACtB,SAAS,CAAC,EAAE,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,GACjD,oBAAoB,CA6CtB;AAED,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,QAAQ,EACd,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC,CAAC,CAAU,EAC/D,UAAU,CAAC,EAAE,MAAM,EACnB,SAAS,CAAC,EAAE,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,GACjD,aAAa,CAMf"}

package/dist/wall/curtain-wall-materials.js

@@ -0,0 +1,55 @@
+import { getCurtainWallConfig, } from '@pascal-app/core';
+import { getMaterialsForWall, resolveMaterialRef, } from '@pascal-app/viewer';
+import { MeshLambertNodeMaterial, MeshStandardNodeMaterial } from 'three/webgpu';
+export function createCurtainWallMaterials(wall, shading, materials) {
+    const config = getCurtainWallConfig(wall);
+    return {
+        hash: JSON.stringify({
+            config,
+            slots: ['curtain-frame', 'curtain-glass', 'curtain-solid'].map((slot) => {
+                const ref = wall.slots?.[slot];
+                return [
+                    ref,
+                    ref?.startsWith('scene:') ? materials?.[ref.slice(6)] : null,
+                ];
+            }),
+        }),
+        create: () => {
+            const owned = [];
+            const visible = ['frame', 'glass', 'solid'].map((role) => {
+                const ref = wall.slots?.[`curtain-${role}`];
+                const override = ref ? resolveMaterialRef(ref, materials, shading) : undefined;
+                if (override)
+                    return override;
+                const glass = role === 'glass';
+                const color = glass
+                    ? config.glassColor
+                    : role === 'frame'
+                        ? config.frameColor
+                        : config.solidColor;
+                const properties = {
+                    color,
+                    transparent: glass,
+                    opacity: glass ? config.glassOpacity : 1,
+                    depthWrite: !glass,
+                };
+                const material = shading === 'solid'
+                    ? new MeshLambertNodeMaterial(properties)
+                    : new MeshStandardNodeMaterial({
+                        ...properties,
+                        metalness: role === 'frame' ? 0.65 : 0,
+                        roughness: glass ? config.glassRoughness : 0.4,
+                    });
+                owned.push(material);
+                return material;
+            });
+            return { visible, owned };
+        },
+    };
+}
+export function getCurtainAwareWallMaterials(wall, shading = 'rendered', textures = true, colorPreset = 'clay', sceneTheme, materials) {
+    const override = textures && wall.wallType === 'curtain'
+        ? createCurtainWallMaterials(wall, shading, materials)
+        : undefined;
+    return getMaterialsForWall(wall, shading, textures, colorPreset, sceneTheme, materials, override);
+}

package/dist/wall/curtain-wall-panel.d.ts

@@ -0,0 +1,14 @@
+import { type CurtainWallConfig, type WallNode } from '@pascal-app/core';
+type Props = {
+    node: WallNode;
+    height: number;
+    unit: 'metric' | 'imperial';
+    onUpdate: (patch: Partial<WallNode>) => void;
+    onPreview: (patch: Partial<WallNode>) => void;
+    onCommit: () => void;
+    onCancel: () => void;
+};
+export declare function getCurtainWallUpdate(node: WallNode, patch: Partial<CurtainWallConfig>): Pick<WallNode, 'curtainWall'>;
+export declare function CurtainWallPanel({ node, height, unit, onUpdate, onPreview, onCommit, onCancel, }: Props): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=curtain-wall-panel.d.ts.map

package/dist/wall/curtain-wall-panel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curtain-wall-panel.d.ts","sourceRoot":"","sources":["../../src/wall/curtain-wall-panel.tsx"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,iBAAiB,EAKtB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAczB,KAAK,KAAK,GAAG;IACX,IAAI,EAAE,QAAQ,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,QAAQ,GAAG,UAAU,CAAA;IAC3B,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC,KAAK,IAAI,CAAA;IAC5C,SAAS,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC,KAAK,IAAI,CAAA;IAC7C,QAAQ,EAAE,MAAM,IAAI,CAAA;IACpB,QAAQ,EAAE,MAAM,IAAI,CAAA;CACrB,CAAA;AA6KD,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,OAAO,CAAC,iBAAiB,CAAC,GAChC,IAAI,CAAC,QAAQ,EAAE,aAAa,CAAC,CAI/B;AAED,wBAAgB,gBAAgB,CAAC,EAC/B,IAAI,EACJ,MAAM,EACN,IAAI,EACJ,QAAQ,EACR,SAAS,EACT,QAAQ,EACR,QAAQ,GACT,EAAE,KAAK,+BAscP"}