@pascal-app/core 0.6.0 → 0.8.0

package/dist/systems/wall/wall-system.d.ts

@@ -1,12 +0,0 @@
-import * as THREE from 'three';
-import type { AnyNode, WallNode } from '../../schema';
-import { type WallMiterData } from './wall-mitering';
-export declare const WallSystem: () => null;
-/**
- * Generates extruded wall geometry with mitering and cutouts
- *
- * Key insight from demo: polygon is built in WORLD coordinates first,
- * then we transform to wall-local for the 3D mesh.
- */
-export declare function generateExtrudedWall(wallNode: WallNode, childrenNodes: AnyNode[], miterData: WallMiterData, slabElevation?: number): THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>;
-//# sourceMappingURL=wall-system.d.ts.map

package/dist/systems/wall/wall-system.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"wall-system.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-system.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAM9B,OAAO,KAAK,EAAE,OAAO,EAAa,QAAQ,EAAE,MAAM,cAAc,CAAA;AAIhE,OAAO,EAML,KAAK,aAAa,EACnB,MAAM,iBAAiB,CAAA;AAsRxB,eAAO,MAAM,UAAU,YAuDtB,CAAA;AA0DD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,QAAQ,EAClB,aAAa,EAAE,OAAO,EAAE,EACxB,SAAS,EAAE,aAAa,EACxB,aAAa,SAAI,oFA2GlB"}

package/dist/systems/wall/wall-system.js

@@ -1,455 +0,0 @@
-import { useFrame } from '@react-three/fiber';
-import * as THREE from 'three';
-import { Brush, Evaluator, SUBTRACTION } from 'three-bvh-csg';
-import { computeBoundsTree } from 'three-mesh-bvh';
-import { sceneRegistry } from '../../hooks/scene-registry/scene-registry';
-import { spatialGridManager } from '../../hooks/spatial-grid/spatial-grid-manager';
-import { resolveLevelId } from '../../hooks/spatial-grid/spatial-grid-sync';
-import useScene from '../../store/use-scene';
-import { getWallCurveFrameAt, getWallSurfacePolygon, isCurvedWall } from './wall-curve';
-import { DEFAULT_WALL_HEIGHT, getWallPlanFootprint, getWallThickness } from './wall-footprint';
-import { calculateLevelMiters, getAdjacentWallIds, getWallMiterBoundaryPoints, pointToKey, } from './wall-mitering';
-// Reusable CSG evaluator for better performance
-const csgEvaluator = new Evaluator();
-const CURVED_WALL_3D_ENDPOINT_INSET = 0.0015;
-const WALL_FACE_NORMAL_Y_EPSILON = 0.6;
-const WALL_FACE_EDGE_DISTANCE_EPSILON = 0.003;
-function ensureUv2Attribute(geometry) {
-    const uv = geometry.getAttribute('uv');
-    if (!uv)
-        return;
-    geometry.setAttribute('uv2', new THREE.Float32BufferAttribute(Array.from(uv.array), 2));
-}
-function insetCurvedWallBoundaryPointsFor3D(wall, boundaryPoints, miterData) {
-    if (!boundaryPoints || !isCurvedWall(wall)) {
-        return boundaryPoints;
-    }
-    const insetDistance = Math.min(CURVED_WALL_3D_ENDPOINT_INSET, Math.max((wall.thickness ?? 0.1) * 0.01, 0.0005));
-    if (insetDistance <= 0) {
-        return boundaryPoints;
-    }
-    const next = { ...boundaryPoints };
-    const startJunction = miterData.junctions.get(pointToKey({ x: wall.start[0], y: wall.start[1] }));
-    const endJunction = miterData.junctions.get(pointToKey({ x: wall.end[0], y: wall.end[1] }));
-    if (startJunction && startJunction.connectedWalls.length > 1) {
-        const frame = getWallCurveFrameAt(wall, 0);
-        next.startLeft = {
-            x: next.startLeft.x + frame.tangent.x * insetDistance,
-            y: next.startLeft.y + frame.tangent.y * insetDistance,
-        };
-        next.startRight = {
-            x: next.startRight.x + frame.tangent.x * insetDistance,
-            y: next.startRight.y + frame.tangent.y * insetDistance,
-        };
-    }
-    if (endJunction && endJunction.connectedWalls.length > 1) {
-        const frame = getWallCurveFrameAt(wall, 1);
-        next.endLeft = {
-            x: next.endLeft.x - frame.tangent.x * insetDistance,
-            y: next.endLeft.y - frame.tangent.y * insetDistance,
-        };
-        next.endRight = {
-            x: next.endRight.x - frame.tangent.x * insetDistance,
-            y: next.endRight.y - frame.tangent.y * insetDistance,
-        };
-    }
-    return next;
-}
-function addTaggedWallBoundaryEdge(edges, points, startIndex, endIndex, tag) {
-    const start = points[startIndex];
-    const end = points[endIndex];
-    if (!(start && end))
-        return;
-    if (Math.hypot(end.x - start.x, end.z - start.z) < 1e-6)
-        return;
-    edges.push({
-        start: new THREE.Vector2(start.x, start.z),
-        end: new THREE.Vector2(end.x, end.z),
-        tag,
-    });
-}
-function buildTaggedWallBoundaryEdges(wall, localPoints, miterData) {
-    if (localPoints.length < 2)
-        return [];
-    const edges = [];
-    if (isCurvedWall(wall)) {
-        const sidePointCount = Math.floor(localPoints.length / 2);
-        if (sidePointCount < 2)
-            return edges;
-        for (let index = 0; index < sidePointCount - 1; index += 1) {
-            addTaggedWallBoundaryEdge(edges, localPoints, index, index + 1, 'back');
-        }
-        addTaggedWallBoundaryEdge(edges, localPoints, sidePointCount - 1, sidePointCount, 'base');
-        for (let index = sidePointCount; index < localPoints.length - 1; index += 1) {
-            addTaggedWallBoundaryEdge(edges, localPoints, index, index + 1, 'front');
-        }
-        addTaggedWallBoundaryEdge(edges, localPoints, localPoints.length - 1, 0, 'base');
-        return edges;
-    }
-    const startKey = pointToKey({ x: wall.start[0], y: wall.start[1] });
-    const startJunction = miterData.junctionData.get(startKey)?.get(wall.id);
-    const startLeftIndex = startJunction ? localPoints.length - 2 : localPoints.length - 1;
-    const endLeftIndex = startJunction ? localPoints.length - 3 : localPoints.length - 2;
-    addTaggedWallBoundaryEdge(edges, localPoints, 0, 1, 'back');
-    for (let index = 1; index < endLeftIndex; index += 1) {
-        addTaggedWallBoundaryEdge(edges, localPoints, index, index + 1, 'base');
-    }
-    addTaggedWallBoundaryEdge(edges, localPoints, endLeftIndex, startLeftIndex, 'front');
-    for (let index = startLeftIndex; index < localPoints.length - 1; index += 1) {
-        addTaggedWallBoundaryEdge(edges, localPoints, index, index + 1, 'base');
-    }
-    addTaggedWallBoundaryEdge(edges, localPoints, localPoints.length - 1, 0, 'base');
-    return edges;
-}
-function distanceToWallBoundaryEdge(point, edge) {
-    const edgeDx = edge.end.x - edge.start.x;
-    const edgeDz = edge.end.y - edge.start.y;
-    const pointDx = point.x - edge.start.x;
-    const pointDz = point.y - edge.start.y;
-    const edgeLengthSq = edgeDx * edgeDx + edgeDz * edgeDz;
-    if (edgeLengthSq < 1e-12) {
-        return point.distanceTo(edge.start);
-    }
-    const t = THREE.MathUtils.clamp((pointDx * edgeDx + pointDz * edgeDz) / edgeLengthSq, 0, 1);
-    const closestX = edge.start.x + edgeDx * t;
-    const closestZ = edge.start.y + edgeDz * t;
-    return Math.hypot(point.x - closestX, point.y - closestZ);
-}
-function getWallFaceMaterialIndex(wall, face) {
-    const semantic = face === 'front' ? wall.frontSide : wall.backSide;
-    const fallback = face === 'front' ? 1 : 2;
-    if (semantic === 'interior')
-        return 1;
-    if (semantic === 'exterior')
-        return 2;
-    return fallback;
-}
-function assignWallMaterialGroups(geometry, wall, boundaryEdges) {
-    const position = geometry.getAttribute('position');
-    if (!position)
-        return;
-    const index = geometry.getIndex();
-    const triangleCount = index ? Math.floor(index.count / 3) : Math.floor(position.count / 3);
-    if (triangleCount === 0) {
-        geometry.clearGroups();
-        return;
-    }
-    const triangleMaterials = new Array(triangleCount).fill(0);
-    const a = new THREE.Vector3();
-    const b = new THREE.Vector3();
-    const c = new THREE.Vector3();
-    const ab = new THREE.Vector3();
-    const ac = new THREE.Vector3();
-    const normal = new THREE.Vector3();
-    const centroid = new THREE.Vector3();
-    const projectedCentroid = new THREE.Vector2();
-    const maxBoundaryDistance = Math.max(getWallThickness(wall) * 0.02, WALL_FACE_EDGE_DISTANCE_EPSILON);
-    for (let triangleIndex = 0; triangleIndex < triangleCount; triangleIndex += 1) {
-        const baseIndex = triangleIndex * 3;
-        const ia = index ? index.getX(baseIndex) : baseIndex;
-        const ib = index ? index.getX(baseIndex + 1) : baseIndex + 1;
-        const ic = index ? index.getX(baseIndex + 2) : baseIndex + 2;
-        a.fromBufferAttribute(position, ia);
-        b.fromBufferAttribute(position, ib);
-        c.fromBufferAttribute(position, ic);
-        ab.subVectors(b, a);
-        ac.subVectors(c, a);
-        normal.crossVectors(ab, ac);
-        if (normal.lengthSq() < 1e-12) {
-            triangleMaterials[triangleIndex] = 0;
-            continue;
-        }
-        normal.normalize();
-        if (Math.abs(normal.y) >= WALL_FACE_NORMAL_Y_EPSILON) {
-            triangleMaterials[triangleIndex] = 0;
-            continue;
-        }
-        centroid
-            .copy(a)
-            .add(b)
-            .add(c)
-            .multiplyScalar(1 / 3);
-        projectedCentroid.set(centroid.x, centroid.z);
-        let nearestTag = null;
-        let nearestDistance = Number.POSITIVE_INFINITY;
-        for (const edge of boundaryEdges) {
-            const distance = distanceToWallBoundaryEdge(projectedCentroid, edge);
-            if (distance < nearestDistance) {
-                nearestDistance = distance;
-                nearestTag = edge.tag;
-            }
-        }
-        if (!nearestTag || nearestDistance > maxBoundaryDistance) {
-            triangleMaterials[triangleIndex] = 0;
-            continue;
-        }
-        if (nearestTag === 'base') {
-            triangleMaterials[triangleIndex] = 0;
-            continue;
-        }
-        triangleMaterials[triangleIndex] = getWallFaceMaterialIndex(wall, nearestTag);
-    }
-    geometry.clearGroups();
-    let currentMaterial = triangleMaterials[0] ?? 0;
-    let groupStart = 0;
-    for (let triangleIndex = 1; triangleIndex < triangleCount; triangleIndex += 1) {
-        const materialIndex = triangleMaterials[triangleIndex] ?? 0;
-        if (materialIndex === currentMaterial)
-            continue;
-        geometry.addGroup(groupStart * 3, (triangleIndex - groupStart) * 3, currentMaterial);
-        groupStart = triangleIndex;
-        currentMaterial = materialIndex;
-    }
-    geometry.addGroup(groupStart * 3, (triangleCount - groupStart) * 3, currentMaterial);
-}
-// ============================================================================
-// WALL SYSTEM
-// ============================================================================
-let useFrameNb = 0;
-export const WallSystem = () => {
-    const dirtyNodes = useScene((state) => state.dirtyNodes);
-    const clearDirty = useScene((state) => state.clearDirty);
-    useFrame(() => {
-        if (dirtyNodes.size === 0)
-            return;
-        const nodes = useScene.getState().nodes;
-        // Collect dirty walls and their levels
-        const dirtyWallsByLevel = new Map();
-        useFrameNb += 1;
-        dirtyNodes.forEach((id) => {
-            const node = nodes[id];
-            if (!node || node.type !== 'wall')
-                return;
-            const levelId = node.parentId;
-            if (!levelId)
-                return;
-            if (!dirtyWallsByLevel.has(levelId)) {
-                dirtyWallsByLevel.set(levelId, new Set());
-            }
-            dirtyWallsByLevel.get(levelId)?.add(id);
-        });
-        // Process each level that has dirty walls
-        for (const [levelId, dirtyWallIds] of dirtyWallsByLevel) {
-            const levelWalls = getLevelWalls(levelId);
-            const miterData = calculateLevelMiters(levelWalls);
-            // Update dirty walls
-            for (const wallId of dirtyWallIds) {
-                const mesh = sceneRegistry.nodes.get(wallId);
-                if (mesh) {
-                    updateWallGeometry(wallId, miterData);
-                    clearDirty(wallId);
-                }
-                // If mesh not found, keep it dirty for next frame
-            }
-            // Update adjacent walls that share junctions
-            const adjacentWallIds = getAdjacentWallIds(levelWalls, dirtyWallIds);
-            for (const wallId of adjacentWallIds) {
-                if (!dirtyWallIds.has(wallId)) {
-                    const mesh = sceneRegistry.nodes.get(wallId);
-                    if (mesh) {
-                        updateWallGeometry(wallId, miterData);
-                    }
-                }
-            }
-        }
-    }, 4);
-    return null;
-};
-/**
- * Gets all walls that belong to a level
- */
-function getLevelWalls(levelId) {
-    const { nodes } = useScene.getState();
-    const level = nodes[levelId];
-    if (!level || level.type !== 'level')
-        return [];
-    const walls = [];
-    for (const childId of level.children) {
-        const child = nodes[childId];
-        if (child?.type === 'wall') {
-            walls.push(child);
-        }
-    }
-    return walls;
-}
-/**
- * Updates the geometry for a single wall
- */
-function updateWallGeometry(wallId, miterData) {
-    const nodes = useScene.getState().nodes;
-    const node = nodes[wallId];
-    if (!node || node.type !== 'wall')
-        return;
-    const mesh = sceneRegistry.nodes.get(wallId);
-    if (!mesh)
-        return;
-    const levelId = resolveLevelId(node, nodes);
-    const slabElevation = spatialGridManager.getSlabElevationForWall(levelId, node.start, node.end);
-    const childrenIds = node.children || [];
-    const childrenNodes = childrenIds
-        .map((childId) => nodes[childId])
-        .filter((n) => n !== undefined);
-    const newGeo = generateExtrudedWall(node, childrenNodes, miterData, slabElevation);
-    mesh.geometry.dispose();
-    mesh.geometry = newGeo;
-    // Update collision mesh
-    const collisionMesh = mesh.getObjectByName('collision-mesh');
-    if (collisionMesh) {
-        const collisionGeo = generateExtrudedWall(node, [], miterData, slabElevation);
-        collisionMesh.geometry.dispose();
-        collisionMesh.geometry = collisionGeo;
-    }
-    mesh.position.set(node.start[0], slabElevation, node.start[1]);
-    const angle = Math.atan2(node.end[1] - node.start[1], node.end[0] - node.start[0]);
-    mesh.rotation.y = -angle;
-}
-/**
- * Generates extruded wall geometry with mitering and cutouts
- *
- * Key insight from demo: polygon is built in WORLD coordinates first,
- * then we transform to wall-local for the 3D mesh.
- */
-export function generateExtrudedWall(wallNode, childrenNodes, miterData, slabElevation = 0) {
-    const wallStart = { x: wallNode.start[0], y: wallNode.start[1] };
-    const wallEnd = { x: wallNode.end[0], y: wallNode.end[1] };
-    // Positive slab: shift the whole wall up (full height preserved)
-    // Negative slab: extend wall downward so top stays fixed at wallNode.height
-    const wallHeight = wallNode.height ?? DEFAULT_WALL_HEIGHT;
-    const height = slabElevation > 0 ? wallHeight : wallHeight - slabElevation;
-    const thickness = getWallThickness(wallNode);
-    // Wall direction and normal (exactly like demo)
-    const v = { x: wallEnd.x - wallStart.x, y: wallEnd.y - wallStart.y };
-    const L = Math.sqrt(v.x * v.x + v.y * v.y);
-    if (L < 1e-9) {
-        return new THREE.BufferGeometry();
-    }
-    const boundaryPoints = getWallMiterBoundaryPoints(wallNode, miterData);
-    const polyPoints = isCurvedWall(wallNode)
-        ? getWallSurfacePolygon(wallNode, 24, insetCurvedWallBoundaryPointsFor3D(wallNode, boundaryPoints, miterData) ?? undefined)
-        : getWallPlanFootprint(wallNode, miterData);
-    if (polyPoints.length < 3) {
-        return new THREE.BufferGeometry();
-    }
-    // Transform world coordinates to wall-local coordinates
-    // Wall-local: x along wall, z perpendicular (thickness direction)
-    const wallAngle = Math.atan2(v.y, v.x);
-    const cosA = Math.cos(-wallAngle);
-    const sinA = Math.sin(-wallAngle);
-    const worldToLocal = (worldPt) => {
-        const dx = worldPt.x - wallStart.x;
-        const dy = worldPt.y - wallStart.y;
-        return {
-            x: dx * cosA - dy * sinA,
-            z: dx * sinA + dy * cosA,
-        };
-    };
-    // Convert polygon to local coordinates
-    const localPoints = polyPoints.map(worldToLocal);
-    const boundaryEdges = buildTaggedWallBoundaryEdges(wallNode, localPoints, miterData);
-    // Build THREE.js shape
-    // Shape uses (x, y) where we map: shape.x = local.x, shape.y = -local.z
-    // The negation is needed because after rotateX(-PI/2), shape.y becomes -geometry.z
-    const footprint = new THREE.Shape();
-    footprint.moveTo(localPoints[0].x, -localPoints[0].z);
-    for (let i = 1; i < localPoints.length; i++) {
-        footprint.lineTo(localPoints[i].x, -localPoints[i].z);
-    }
-    footprint.closePath();
-    // Extrude along Z by height
-    const geometry = new THREE.ExtrudeGeometry(footprint, {
-        depth: height,
-        bevelEnabled: false,
-    });
-    // Rotate so extrusion direction (Z) becomes height direction (Y)
-    geometry.rotateX(-Math.PI / 2);
-    geometry.computeVertexNormals();
-    assignWallMaterialGroups(geometry, wallNode, boundaryEdges);
-    ensureUv2Attribute(geometry);
-    // Apply CSG subtraction for cutouts (doors/windows)
-    const cutoutBrushes = collectCutoutBrushes(wallNode, childrenNodes, thickness);
-    if (cutoutBrushes.length === 0) {
-        return geometry;
-    }
-    // Create wall brush from geometry
-    // Pre-compute BVH with new API to avoid deprecation warning
-    geometry.computeBoundsTree = computeBoundsTree;
-    geometry.computeBoundsTree({ maxLeafSize: 10 });
-    const wallBrush = new Brush(geometry);
-    wallBrush.updateMatrixWorld();
-    // Subtract each cutout from the wall
-    let resultBrush = wallBrush;
-    for (const cutoutBrush of cutoutBrushes) {
-        cutoutBrush.updateMatrixWorld();
-        const newResult = csgEvaluator.evaluate(resultBrush, cutoutBrush, SUBTRACTION);
-        if (resultBrush !== wallBrush) {
-            resultBrush.geometry.dispose();
-        }
-        resultBrush = newResult;
-    }
-    // Clean up
-    wallBrush.geometry.dispose();
-    for (const brush of cutoutBrushes) {
-        brush.geometry.dispose();
-    }
-    const resultGeometry = resultBrush.geometry;
-    resultGeometry.computeVertexNormals();
-    assignWallMaterialGroups(resultGeometry, wallNode, boundaryEdges);
-    ensureUv2Attribute(resultGeometry);
-    return resultGeometry;
-}
-/**
- * Collects cutout brushes from child items for CSG subtraction
- * The cutout mesh is a plane, so we extrude it into a box that goes through the wall
- */
-function collectCutoutBrushes(wallNode, childrenNodes, wallThickness) {
-    const brushes = [];
-    const wallMesh = sceneRegistry.nodes.get(wallNode.id);
-    if (!wallMesh)
-        return brushes;
-    // Get wall's world matrix inverse to transform cutouts to wall-local space
-    wallMesh.updateMatrixWorld();
-    const wallMatrixInverse = wallMesh.matrixWorld.clone().invert();
-    for (const child of childrenNodes) {
-        if (child.type !== 'item' && child.type !== 'window' && child.type !== 'door')
-            continue;
-        const childMesh = sceneRegistry.nodes.get(child.id);
-        if (!childMesh)
-            continue;
-        const cutoutMesh = childMesh.getObjectByName('cutout');
-        if (!cutoutMesh)
-            continue;
-        // Get the cutout's bounding box in world space
-        cutoutMesh.updateMatrixWorld();
-        const positions = cutoutMesh.geometry?.attributes?.position;
-        if (!positions)
-            continue;
-        // Calculate bounds in wall-local space
-        const v3 = new THREE.Vector3();
-        let minX = Number.POSITIVE_INFINITY, maxX = Number.NEGATIVE_INFINITY;
-        let minY = Number.POSITIVE_INFINITY, maxY = Number.NEGATIVE_INFINITY;
-        for (let i = 0; i < positions.count; i++) {
-            v3.fromBufferAttribute(positions, i);
-            v3.applyMatrix4(cutoutMesh.matrixWorld);
-            v3.applyMatrix4(wallMatrixInverse);
-            minX = Math.min(minX, v3.x);
-            maxX = Math.max(maxX, v3.x);
-            minY = Math.min(minY, v3.y);
-            maxY = Math.max(maxY, v3.y);
-        }
-        if (!Number.isFinite(minX))
-            continue;
-        // Create a box geometry that extends through the wall thickness
-        const width = maxX - minX;
-        const height = maxY - minY;
-        const depth = wallThickness * 2; // Extend beyond wall to ensure clean cut
-        const boxGeo = new THREE.BoxGeometry(width, height, depth);
-        // Position box at the center of the cutout
-        boxGeo.translate(minX + width / 2, minY + height / 2, 0);
-        // Pre-compute BVH with new API to avoid deprecation warning
-        boxGeo.computeBoundsTree = computeBoundsTree;
-        boxGeo.computeBoundsTree({ maxLeafSize: 10 });
-        const brush = new Brush(boxGeo);
-        brushes.push(brush);
-    }
-    return brushes;
-}

package/dist/systems/window/window-system.d.ts

@@ -1,2 +0,0 @@
-export declare const WindowSystem: () => null;
-//# sourceMappingURL=window-system.d.ts.map

package/dist/systems/window/window-system.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"window-system.d.ts","sourceRoot":"","sources":["../../../src/systems/window/window-system.tsx"],"names":[],"mappings":"AAUA,eAAO,MAAM,YAAY,YA2BxB,CAAA"}

package/dist/systems/window/window-system.js

@@ -1,131 +0,0 @@
-import { useFrame } from '@react-three/fiber';
-import * as THREE from 'three';
-import { sceneRegistry } from '../../hooks/scene-registry/scene-registry';
-import { baseMaterial, glassMaterial } from '../../materials';
-import useScene from '../../store/use-scene';
-// Invisible material for root mesh — used as selection hitbox only
-const hitboxMaterial = new THREE.MeshBasicMaterial({ visible: false });
-export const WindowSystem = () => {
-    const dirtyNodes = useScene((state) => state.dirtyNodes);
-    const clearDirty = useScene((state) => state.clearDirty);
-    useFrame(() => {
-        if (dirtyNodes.size === 0)
-            return;
-        const nodes = useScene.getState().nodes;
-        dirtyNodes.forEach((id) => {
-            const node = nodes[id];
-            if (!node || node.type !== 'window')
-                return;
-            const mesh = sceneRegistry.nodes.get(id);
-            if (!mesh)
-                return; // Keep dirty until mesh mounts
-            updateWindowMesh(node, mesh);
-            clearDirty(id);
-            // Rebuild the parent wall so its cutout reflects the updated window geometry
-            if (node.parentId) {
-                useScene.getState().dirtyNodes.add(node.parentId);
-            }
-        });
-    }, 3);
-    return null;
-};
-function addBox(parent, material, w, h, d, x, y, z) {
-    const m = new THREE.Mesh(new THREE.BoxGeometry(w, h, d), material);
-    m.position.set(x, y, z);
-    parent.add(m);
-}
-function updateWindowMesh(node, mesh) {
-    // Root mesh is an invisible hitbox; all visuals live in child meshes
-    mesh.geometry.dispose();
-    mesh.geometry = new THREE.BoxGeometry(node.width, node.height, node.frameDepth);
-    mesh.material = hitboxMaterial;
-    // Sync transform from node (React may lag behind the system by a frame during drag)
-    mesh.position.set(node.position[0], node.position[1], node.position[2]);
-    mesh.rotation.set(node.rotation[0], node.rotation[1], node.rotation[2]);
-    // Dispose and remove all old visual children; preserve 'cutout'
-    for (const child of [...mesh.children]) {
-        if (child.name === 'cutout')
-            continue;
-        if (child instanceof THREE.Mesh)
-            child.geometry.dispose();
-        mesh.remove(child);
-    }
-    const { width, height, frameDepth, frameThickness, columnRatios, rowRatios, columnDividerThickness, rowDividerThickness, sill, sillDepth, sillThickness, } = node;
-    const innerW = width - 2 * frameThickness;
-    const innerH = height - 2 * frameThickness;
-    // ── Frame members ──
-    // Top / bottom — full width
-    addBox(mesh, baseMaterial, width, frameThickness, frameDepth, 0, height / 2 - frameThickness / 2, 0);
-    addBox(mesh, baseMaterial, width, frameThickness, frameDepth, 0, -height / 2 + frameThickness / 2, 0);
-    // Left / right — inner height to avoid corner overlap
-    addBox(mesh, baseMaterial, frameThickness, innerH, frameDepth, -width / 2 + frameThickness / 2, 0, 0);
-    addBox(mesh, baseMaterial, frameThickness, innerH, frameDepth, width / 2 - frameThickness / 2, 0, 0);
-    // ── Pane grid ──
-    const numCols = columnRatios.length;
-    const numRows = rowRatios.length;
-    const usableW = innerW - (numCols - 1) * columnDividerThickness;
-    const usableH = innerH - (numRows - 1) * rowDividerThickness;
-    const colSum = columnRatios.reduce((a, b) => a + b, 0);
-    const rowSum = rowRatios.reduce((a, b) => a + b, 0);
-    const colWidths = columnRatios.map((r) => (r / colSum) * usableW);
-    const rowHeights = rowRatios.map((r) => (r / rowSum) * usableH);
-    // Compute column x-centers starting from left edge of inner area
-    const colXCenters = [];
-    let cx = -innerW / 2;
-    for (let c = 0; c < numCols; c++) {
-        colXCenters.push(cx + colWidths[c] / 2);
-        cx += colWidths[c];
-        if (c < numCols - 1)
-            cx += columnDividerThickness;
-    }
-    // Compute row y-centers starting from top edge of inner area (R1 = top)
-    const rowYCenters = [];
-    let cy = innerH / 2;
-    for (let r = 0; r < numRows; r++) {
-        rowYCenters.push(cy - rowHeights[r] / 2);
-        cy -= rowHeights[r];
-        if (r < numRows - 1)
-            cy -= rowDividerThickness;
-    }
-    // Column dividers — full inner height
-    cx = -innerW / 2;
-    for (let c = 0; c < numCols - 1; c++) {
-        cx += colWidths[c];
-        addBox(mesh, baseMaterial, columnDividerThickness, innerH, frameDepth, cx + columnDividerThickness / 2, 0, 0);
-        cx += columnDividerThickness;
-    }
-    // Row dividers — per column width, so they don't overlap column dividers (top to bottom)
-    cy = innerH / 2;
-    for (let r = 0; r < numRows - 1; r++) {
-        cy -= rowHeights[r];
-        const divY = cy - rowDividerThickness / 2;
-        for (let c = 0; c < numCols; c++) {
-            addBox(mesh, baseMaterial, colWidths[c], rowDividerThickness, frameDepth, colXCenters[c], divY, 0);
-        }
-        cy -= rowDividerThickness;
-    }
-    // Glass panes
-    const glassDepth = Math.max(0.004, frameDepth * 0.08);
-    for (let c = 0; c < numCols; c++) {
-        for (let r = 0; r < numRows; r++) {
-            addBox(mesh, glassMaterial, colWidths[c], rowHeights[r], glassDepth, colXCenters[c], rowYCenters[r], 0);
-        }
-    }
-    // ── Sill ──
-    if (sill) {
-        const sillW = width + sillDepth * 0.4; // slightly wider than frame
-        // Protrudes from the front face of the frame (+Z)
-        const sillZ = frameDepth / 2 + sillDepth / 2;
-        addBox(mesh, baseMaterial, sillW, sillThickness, sillDepth, 0, -height / 2 - sillThickness / 2, sillZ);
-    }
-    // ── Cutout (for wall CSG) — always full window dimensions, 1m deep ──
-    let cutout = mesh.getObjectByName('cutout');
-    if (!cutout) {
-        cutout = new THREE.Mesh();
-        cutout.name = 'cutout';
-        mesh.add(cutout);
-    }
-    cutout.geometry.dispose();
-    cutout.geometry = new THREE.BoxGeometry(node.width, node.height, 1.0);
-    cutout.visible = false;
-}