@pascal-app/nodes 1.0.0-beta.5 → 1.0.0

package/dist/dormer/panel-window-section.js

@@ -1,59 +0,0 @@
-'use client';
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { PanelSection, SegmentedControl, SliderControl, ToggleControl } from '@pascal-app/editor';
-import { useState } from 'react';
-function maxSharedRadius(width, height) {
-    return Math.max(0, Math.min(width / 2, height / 2));
-}
-/**
- * The Window tab of the dormer inspector: Hung Wall, Opening, Shape
- * (with rounded/arch sub-controls), Frame, Grid, Sill. Owns local UI
- * state for the "All vs Individual" corner-radius view mode — derived
- * from tuple uniformity by default.
- */
-export function DormerWindowSection({ node, previewProp, commitProp, handleUpdate, }) {
-    const [radiusViewMode, setRadiusViewMode] = useState('all');
-    const windowShape = node.windowShape;
-    const windowCornerRadii = [...node.windowCornerRadii];
-    const windowArchHeight = node.windowArchHeight;
-    const maxRadius = Math.max(0.01, maxSharedRadius(node.windowWidth, node.windowHeight));
-    const tupleIsUniform = windowCornerRadii[0] === windowCornerRadii[1] &&
-        windowCornerRadii[1] === windowCornerRadii[2] &&
-        windowCornerRadii[2] === windowCornerRadii[3];
-    const sharedRadius = windowCornerRadii[0];
-    const setCornerRadius = (index, value, commit) => {
-        const next = [...windowCornerRadii];
-        next[index] = value;
-        if (commit)
-            commitProp({ windowCornerRadii: next });
-        else
-            previewProp({ windowCornerRadii: next });
-    };
-    const setAllCornerRadii = (value, commit) => {
-        const next = [value, value, value, value];
-        if (commit)
-            commitProp({ windowCornerRadii: next });
-        else
-            previewProp({ windowCornerRadii: next });
-    };
-    return (_jsxs(_Fragment, { children: [_jsx(PanelSection, { title: "Hung Wall", children: _jsx(SliderControl, { label: "Height", max: 6, min: 0.2, onChange: (v) => previewProp({ wallSkirtHeight: v }), onCommit: (v) => commitProp({ wallSkirtHeight: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(node.wallSkirtHeight * 100) / 100 }) }), _jsxs(PanelSection, { title: "Opening", children: [_jsx(SliderControl, { label: "Width", max: Math.max(0.5, node.width - 0.1), min: 0.2, onChange: (v) => previewProp({ windowWidth: v }), onCommit: (v) => commitProp({ windowWidth: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(node.windowWidth * 100) / 100 }), _jsx(SliderControl, { label: "Height", max: Math.max(0.2, node.wallSkirtHeight - 0.1), min: 0.2, onChange: (v) => previewProp({ windowHeight: v }), onCommit: (v) => commitProp({ windowHeight: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(node.windowHeight * 100) / 100 }), _jsx(SliderControl, { label: "Offset X", max: 1, min: -1, onChange: (v) => previewProp({ windowOffsetX: v }), onCommit: (v) => commitProp({ windowOffsetX: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(node.windowOffsetX * 100) / 100 }), _jsx(SliderControl, { label: "Offset Y", max: 2, min: 0, onChange: (v) => previewProp({ windowOffsetY: v }), onCommit: (v) => commitProp({ windowOffsetY: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(node.windowOffsetY * 100) / 100 })] }), _jsxs(PanelSection, { title: "Shape", children: [_jsx(SegmentedControl, { onChange: (v) => handleUpdate({
-                            windowShape: v,
-                            ...(v === 'rounded'
-                                ? {
-                                    windowCornerRadii: windowCornerRadii.map((r) => Math.min(r, maxRadius)),
-                                }
-                                : {}),
-                        }), options: [
-                            { value: 'rectangle', label: 'Rect' },
-                            { value: 'rounded', label: 'Rounded' },
-                            { value: 'arch', label: 'Arch' },
-                        ], value: windowShape }), windowShape === 'rounded' && (_jsxs("div", { className: "mt-2 flex flex-col gap-1", children: [_jsx(SegmentedControl, { onChange: (v) => setRadiusViewMode(v), options: [
-                                    { value: 'all', label: 'All' },
-                                    { value: 'individual', label: 'Individual' },
-                                ], value: tupleIsUniform ? radiusViewMode : 'individual' }), tupleIsUniform && radiusViewMode === 'all' ? (_jsx(SliderControl, { label: "Corner Radius", max: maxRadius, min: 0, onChange: (v) => setAllCornerRadii(v, false), onCommit: (v) => setAllCornerRadii(v, true), precision: 2, restoreOnCommit: false, step: 0.01, unit: "m", value: Math.round(sharedRadius * 100) / 100 })) : ([
-                                ['Top Left', 0],
-                                ['Top Right', 1],
-                                ['Bottom Right', 2],
-                                ['Bottom Left', 3],
-                            ].map(([label, index]) => (_jsx(SliderControl, { label: label, max: maxRadius, min: 0, onChange: (v) => setCornerRadius(index, v, false), onCommit: (v) => setCornerRadius(index, v, true), precision: 2, restoreOnCommit: false, step: 0.01, unit: "m", value: Math.round((windowCornerRadii[index] ?? 0) * 100) / 100 }, label))))] })), windowShape === 'arch' && (_jsx(SliderControl, { label: "Arch Height", max: Math.max(0.1, node.windowHeight), min: 0.1, onChange: (v) => previewProp({ windowArchHeight: v }), onCommit: (v) => commitProp({ windowArchHeight: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(windowArchHeight * 100) / 100 }))] }), _jsxs(PanelSection, { title: "Frame", children: [_jsx(SliderControl, { label: "Thickness", max: 0.15, min: 0.01, onChange: (v) => previewProp({ windowFrameThickness: v }), onCommit: (v) => commitProp({ windowFrameThickness: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: Math.round(node.windowFrameThickness * 1000) / 1000 }), _jsx(SliderControl, { label: "Depth", max: 0.15, min: 0.02, onChange: (v) => previewProp({ windowFrameDepth: v }), onCommit: (v) => commitProp({ windowFrameDepth: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: Math.round(node.windowFrameDepth * 1000) / 1000 }), _jsx(SliderControl, { label: "Divider", max: 0.06, min: 0, onChange: (v) => previewProp({ windowDividerThickness: v }), onCommit: (v) => commitProp({ windowDividerThickness: v }), precision: 3, restoreOnCommit: false, step: 0.002, unit: "m", value: Math.round(node.windowDividerThickness * 1000) / 1000 })] }), _jsxs(PanelSection, { title: "Grid", children: [_jsx(SliderControl, { label: "Columns", max: 8, min: 1, onChange: (v) => previewProp({ windowColumns: Math.max(1, Math.min(8, Math.round(v))) }), onCommit: (v) => commitProp({ windowColumns: Math.max(1, Math.min(8, Math.round(v))) }), precision: 0, restoreOnCommit: false, step: 1, value: node.windowColumns }), _jsx(SliderControl, { label: "Rows", max: 8, min: 1, onChange: (v) => previewProp({ windowRows: Math.max(1, Math.min(8, Math.round(v))) }), onCommit: (v) => commitProp({ windowRows: Math.max(1, Math.min(8, Math.round(v))) }), precision: 0, restoreOnCommit: false, step: 1, value: node.windowRows })] }), _jsxs(PanelSection, { title: "Sill", children: [_jsx(ToggleControl, { checked: node.windowSill, label: "Enable Sill", onChange: (checked) => handleUpdate({ windowSill: checked }) }), node.windowSill && (_jsxs("div", { className: "mt-1 flex flex-col gap-1", children: [_jsx(SliderControl, { label: "Depth", max: 0.3, min: 0.02, onChange: (v) => previewProp({ windowSillDepth: v }), onCommit: (v) => commitProp({ windowSillDepth: v }), precision: 3, restoreOnCommit: false, step: 0.01, unit: "m", value: Math.round(node.windowSillDepth * 1000) / 1000 }), _jsx(SliderControl, { label: "Thickness", max: 0.1, min: 0.01, onChange: (v) => previewProp({ windowSillThickness: v }), onCommit: (v) => commitProp({ windowSillThickness: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: Math.round(node.windowSillThickness * 1000) / 1000 })] }))] })] }));
-}

package/dist/dormer/window-assembly.d.ts

@@ -1,22 +0,0 @@
-import type { DormerNode, RoofSegmentNode } from '@pascal-app/core';
-import * as THREE from 'three';
-/**
- * Renders the window opening assembly (frame bars, glass panes, sill)
- * on each exposed gable face of a dormer. Owns its geometry lifecycle
- * (build via `buildDormerWindowGeometries`, dispose on unmount) so the
- * renderer doesn't have to.
- *
- * Mounted inside the dormer's rotation group, in dormer-mesh-local
- * coordinates. The CSG cut on the wall is performed separately inside
- * the viewer's `generateDormerGeometry`; the geometry built here is
- * sized to match that cut.
- */
-declare const DormerWindowAssembly: ({ node, segment, frameMaterial, glassMaterial, dormerToSegment, }: {
-    node: DormerNode;
-    segment: RoofSegmentNode;
-    frameMaterial: THREE.Material;
-    glassMaterial: THREE.Material;
-    dormerToSegment: THREE.Matrix4;
-}) => import("react").JSX.Element;
-export default DormerWindowAssembly;
-//# sourceMappingURL=window-assembly.d.ts.map

package/dist/dormer/window-assembly.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"window-assembly.d.ts","sourceRoot":"","sources":["../../src/dormer/window-assembly.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAEnE,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAK9B;;;;;;;;;;GAUG;AACH,QAAA,MAAM,oBAAoB,GAAI,mEAM3B;IACD,IAAI,EAAE,UAAU,CAAA;IAChB,OAAO,EAAE,eAAe,CAAA;IACxB,aAAa,EAAE,KAAK,CAAC,QAAQ,CAAA;IAC7B,aAAa,EAAE,KAAK,CAAC,QAAQ,CAAA;IAI7B,eAAe,EAAE,KAAK,CAAC,OAAO,CAAA;CAC/B,gCA4KA,CAAA;AAED,eAAe,oBAAoB,CAAA"}

package/dist/dormer/window-assembly.js

@@ -1,111 +0,0 @@
-'use client';
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { useEffect, useMemo } from 'react';
-import * as THREE from 'three';
-import { TrimClippedMesh } from '../shared/use-segment-trim-clip';
-import { getDormerExposedFaces, getDormerSkirtWindowDims } from './csg-geometry';
-import { buildDormerWindowGeometries } from './window-frame';
-/**
- * Renders the window opening assembly (frame bars, glass panes, sill)
- * on each exposed gable face of a dormer. Owns its geometry lifecycle
- * (build via `buildDormerWindowGeometries`, dispose on unmount) so the
- * renderer doesn't have to.
- *
- * Mounted inside the dormer's rotation group, in dormer-mesh-local
- * coordinates. The CSG cut on the wall is performed separately inside
- * the viewer's `generateDormerGeometry`; the geometry built here is
- * sized to match that cut.
- */
-const DormerWindowAssembly = ({ node, segment, frameMaterial, glassMaterial, dormerToSegment, }) => {
-    // biome-ignore lint/correctness/useExhaustiveDependencies: deps deliberately list the build inputs; depending on the whole object would rebuild on unrelated field changes.
-    const skirtWin = useMemo(() => getDormerSkirtWindowDims(node), [
-        node.width,
-        node.windowWidth,
-        node.windowHeight,
-        node.windowOffsetX,
-        node.windowOffsetY,
-        node.wallSkirtHeight,
-    ]);
-    const winW = skirtWin.width;
-    const winH = skirtWin.height;
-    const winShape = node.windowShape;
-    const resolvedRadii = [...node.windowCornerRadii];
-    // biome-ignore lint/correctness/useExhaustiveDependencies: deps deliberately list the build inputs; depending on the whole object would rebuild on unrelated field changes.
-    const winGeo = useMemo(() => buildDormerWindowGeometries(winW, winH, node.windowFrameThickness, node.windowFrameDepth, node.windowColumns, node.windowRows, node.windowDividerThickness, winShape, node.windowArchHeight, resolvedRadii), [
-        winW,
-        winH,
-        node.windowFrameThickness,
-        node.windowFrameDepth,
-        node.windowColumns,
-        node.windowRows,
-        node.windowDividerThickness,
-        winShape,
-        node.windowArchHeight,
-        ...resolvedRadii,
-    ]);
-    useEffect(() => {
-        return () => {
-            const disposed = new Set();
-            for (const bar of winGeo.frameBars) {
-                if (!disposed.has(bar.geo)) {
-                    bar.geo.dispose();
-                    disposed.add(bar.geo);
-                }
-            }
-            for (const pane of winGeo.glassPanes) {
-                if (!disposed.has(pane.geo)) {
-                    pane.geo.dispose();
-                    disposed.add(pane.geo);
-                }
-            }
-        };
-    }, [winGeo]);
-    const sillEnabled = node.windowSill !== false;
-    const sillT = Math.max(0.001, node.windowSillThickness);
-    const sillD = Math.max(0.001, node.windowSillDepth);
-    const sillW = winW + 0.06; // 3 cm overhang each side
-    const sillGeo = useMemo(() => (sillEnabled ? new THREE.BoxGeometry(sillW, sillT, sillD) : null), [sillEnabled, sillW, sillT, sillD]);
-    useEffect(() => () => sillGeo?.dispose(), [sillGeo]);
-    // biome-ignore lint/correctness/useExhaustiveDependencies: deps deliberately list the build inputs; depending on the whole object would rebuild on unrelated field changes.
-    const exposed = useMemo(() => getDormerExposedFaces(node, segment), [
-        segment,
-        node.roofType,
-        node.width,
-        node.depth,
-        node.height,
-        node.roofHeight,
-        node.position[0],
-        node.position[1],
-        node.position[2],
-        // Rotation flips which dormer-local face projects to which Z in
-        // segment frame, so dragging the dormer across the ridge with a
-        // non-zero yaw needs to recompute exposure to know which gable
-        // is now poking above the slope.
-        node.rotation,
-        // The window's vertical placement feeds `getDormerExposedFaces`
-        // (gates on the window CENTER clearing the host slope) — dragging
-        // the window down via inspector or the offset handle must
-        // re-evaluate which gable still exposes the opening.
-        node.windowOffsetY,
-        node.wallSkirtHeight,
-    ]);
-    const gableHalfZ = node.depth / 2;
-    const winX = skirtWin.offsetX;
-    const winY = skirtWin.centerY;
-    // The glazing role material is FrontSide (DoubleSide on a NodeMaterial
-    // poisons the MRT scene pass — see `createSurfaceRoleMaterial`). The
-    // back gable face therefore renders inside a Y-rotated group so its
-    // FrontSide points outward (-Z in segment frame). With the rotation,
-    // the sill always extrudes along the group's local +Z, so its position
-    // no longer needs to flip per-face.
-    const renderFace = (zPos, yRot, keyPrefix) => {
-        // Compose this face group's transform onto the dormer→segment matrix, so
-        // each window part can be clipped by the trim in segment-local space.
-        const faceToSegment = new THREE.Matrix4()
-            .copy(dormerToSegment)
-            .multiply(new THREE.Matrix4().compose(new THREE.Vector3(winX, winY, zPos), new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), yRot), new THREE.Vector3(1, 1, 1)));
-        return (_jsxs("group", { name: `dormer-window-${keyPrefix}`, position: [winX, winY, zPos], "rotation-y": yRot, children: [winGeo.glassPanes.map((pane, i) => (_jsx(TrimClippedMesh, { geometry: pane.geo, material: glassMaterial, name: `dormer-glass-${keyPrefix}-${i}`, parentToSegment: faceToSegment, position: pane.pos, segment: segment }, `${keyPrefix}-glass-${i}`))), winGeo.frameBars.map((bar, i) => (_jsx(TrimClippedMesh, { castShadow: true, geometry: bar.geo, material: frameMaterial, name: `dormer-frame-${keyPrefix}-${i}`, parentToSegment: faceToSegment, position: bar.pos, segment: segment }, `${keyPrefix}-bar-${i}`))), sillGeo && (_jsx(TrimClippedMesh, { castShadow: true, geometry: sillGeo, material: frameMaterial, name: `dormer-sill-${keyPrefix}`, parentToSegment: faceToSegment, position: [0, -winH / 2 - sillT / 2, sillD / 2], receiveShadow: true, segment: segment }))] }));
-    };
-    return (_jsxs(_Fragment, { children: [exposed.front && renderFace(gableHalfZ, 0, 'front'), exposed.back && renderFace(-gableHalfZ, Math.PI, 'back')] }));
-};
-export default DormerWindowAssembly;

package/dist/dormer/window-frame.d.ts

@@ -1,24 +0,0 @@
-import * as THREE from 'three';
-/**
- * Frame + glass geometry for the window opening on a dormer's gable
- * face. The extruded frame profile uses the same shape builders as the
- * CSG cut in the viewer (`generateDormerGeometry`), so the frame sits
- * flush in the wall — keeping the cut and the frame visually in sync.
- *
- * Only the frame bars and glass panes are produced here; the wall
- * opening itself is CSG-subtracted from the dormer body inside the
- * viewer's `generateDormerGeometry`.
- */
-export type DormerWindowShape = 'rectangle' | 'rounded' | 'arch';
-export type WindowGeometries = {
-    frameBars: {
-        geo: THREE.BufferGeometry;
-        pos: [number, number, number];
-    }[];
-    glassPanes: {
-        geo: THREE.BufferGeometry;
-        pos: [number, number, number];
-    }[];
-};
-export declare function buildDormerWindowGeometries(winW: number, winH: number, ft: number, fd: number, cols: number, rows: number, dt: number, shape?: DormerWindowShape, archHeight?: number, cornerRadii?: [number, number, number, number]): WindowGeometries;
-//# sourceMappingURL=window-frame.d.ts.map

package/dist/dormer/window-frame.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"window-frame.d.ts","sourceRoot":"","sources":["../../src/dormer/window-frame.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B;;;;;;;;;GASG;AACH,MAAM,MAAM,iBAAiB,GAAG,WAAW,GAAG,SAAS,GAAG,MAAM,CAAA;AAEhE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,SAAS,EAAE;QAAE,GAAG,EAAE,KAAK,CAAC,cAAc,CAAC;QAAC,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,EAAE,CAAA;IACzE,UAAU,EAAE;QAAE,GAAG,EAAE,KAAK,CAAC,cAAc,CAAC;QAAC,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,EAAE,CAAA;CAC3E,CAAA;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,KAAK,GAAE,iBAA+B,EACtC,UAAU,SAAO,EACjB,WAAW,GAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAA4B,GACvE,gBAAgB,CAgIlB"}

package/dist/dormer/window-frame.js

@@ -1,100 +0,0 @@
-import * as THREE from 'three';
-import { createDormerArchShape, createDormerRoundedShape } from './csg-geometry';
-export function buildDormerWindowGeometries(winW, winH, ft, fd, cols, rows, dt, shape = 'rectangle', archHeight = 0.35, cornerRadii = [0.15, 0.15, 0.15, 0.15]) {
-    const safeFt = Math.max(0.001, ft);
-    const safeDt = Math.max(0.001, dt);
-    const innerW = Math.max(0.01, winW - 2 * safeFt);
-    const innerH = Math.max(0.01, winH - 2 * safeFt);
-    const hw = winW / 2;
-    const hh = winH / 2;
-    const frameBars = [];
-    const glassPanes = [];
-    if (shape === 'arch' || shape === 'rounded') {
-        const insetRadii = cornerRadii.map((r) => Math.max(r - safeFt, 0));
-        const outerShape = shape === 'arch'
-            ? createDormerArchShape(winW, winH, archHeight)
-            : createDormerRoundedShape(winW, winH, cornerRadii);
-        const innerHole = shape === 'arch'
-            ? createDormerArchShape(winW - 2 * safeFt, winH - 2 * safeFt, Math.max(archHeight - safeFt, 0.01))
-            : createDormerRoundedShape(winW - 2 * safeFt, winH - 2 * safeFt, insetRadii);
-        outerShape.holes.push(innerHole);
-        const frameGeo = new THREE.ExtrudeGeometry(outerShape, {
-            depth: fd,
-            bevelEnabled: false,
-            curveSegments: 24,
-        });
-        frameGeo.translate(0, 0, -fd / 2);
-        frameBars.push({ geo: frameGeo, pos: [0, 0, 0] });
-        const colDividerCount = cols - 1;
-        const totalColDividerW = colDividerCount * safeDt;
-        const paneAreaW = Math.max(0.01, innerW - totalColDividerW);
-        const paneW = paneAreaW / cols;
-        for (let c = 1; c < cols; c++) {
-            const x = -innerW / 2 + c * paneW + (c - 0.5) * safeDt;
-            frameBars.push({ geo: new THREE.BoxGeometry(safeDt, innerH, fd), pos: [x, 0, 0] });
-        }
-        const rowDividerCount = rows - 1;
-        const totalRowDividerH = rowDividerCount * safeDt;
-        const paneAreaH = Math.max(0.01, innerH - totalRowDividerH);
-        const paneH = paneAreaH / rows;
-        for (let r = 1; r < rows; r++) {
-            const y = -innerH / 2 + r * paneH + (r - 0.5) * safeDt;
-            frameBars.push({ geo: new THREE.BoxGeometry(innerW, safeDt, fd), pos: [0, y, 0] });
-        }
-        const glassShape = shape === 'arch'
-            ? createDormerArchShape(winW - 2 * safeFt, winH - 2 * safeFt, Math.max(archHeight - safeFt, 0.01))
-            : createDormerRoundedShape(winW - 2 * safeFt, winH - 2 * safeFt, insetRadii);
-        const glassGeo = new THREE.ExtrudeGeometry(glassShape, {
-            depth: 0.008,
-            bevelEnabled: false,
-            curveSegments: 24,
-        });
-        glassGeo.translate(0, 0, -0.004);
-        glassPanes.push({ geo: glassGeo, pos: [0, 0, 0] });
-    }
-    else {
-        frameBars.push({
-            geo: new THREE.BoxGeometry(winW, safeFt, fd),
-            pos: [0, hh - safeFt / 2, 0],
-        });
-        frameBars.push({
-            geo: new THREE.BoxGeometry(winW, safeFt, fd),
-            pos: [0, -hh + safeFt / 2, 0],
-        });
-        frameBars.push({
-            geo: new THREE.BoxGeometry(safeFt, innerH, fd),
-            pos: [-hw + safeFt / 2, 0, 0],
-        });
-        frameBars.push({
-            geo: new THREE.BoxGeometry(safeFt, innerH, fd),
-            pos: [hw - safeFt / 2, 0, 0],
-        });
-        const colDividerCount = cols - 1;
-        const totalColDividerW = colDividerCount * safeDt;
-        const paneAreaW = Math.max(0.01, innerW - totalColDividerW);
-        const paneW = paneAreaW / cols;
-        for (let c = 1; c < cols; c++) {
-            const x = -innerW / 2 + c * paneW + (c - 0.5) * safeDt;
-            frameBars.push({ geo: new THREE.BoxGeometry(safeDt, innerH, fd), pos: [x, 0, 0] });
-        }
-        const rowDividerCount = rows - 1;
-        const totalRowDividerH = rowDividerCount * safeDt;
-        const paneAreaH = Math.max(0.01, innerH - totalRowDividerH);
-        const paneH = paneAreaH / rows;
-        for (let r = 1; r < rows; r++) {
-            const y = -innerH / 2 + r * paneH + (r - 0.5) * safeDt;
-            frameBars.push({ geo: new THREE.BoxGeometry(innerW, safeDt, fd), pos: [0, y, 0] });
-        }
-        const glassW = Math.max(0.01, paneAreaW / cols);
-        const glassH = Math.max(0.01, paneAreaH / rows);
-        const glassGeo = new THREE.BoxGeometry(glassW, glassH, 0.008);
-        for (let c = 0; c < cols; c++) {
-            const cx = -innerW / 2 + paneAreaW / cols / 2 + c * (paneAreaW / cols + safeDt);
-            for (let r = 0; r < rows; r++) {
-                const cy = -innerH / 2 + paneAreaH / rows / 2 + r * (paneAreaH / rows + safeDt);
-                glassPanes.push({ geo: glassGeo, pos: [cx, cy, 0] });
-            }
-        }
-    }
-    return { frameBars, glassPanes };
-}