@pascal-app/viewer 0.6.0 → 0.7.0

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

@@ -1 +1 @@
-{"version":3,"file":"wall-materials.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-materials.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAS,KAAK,QAAQ,EAAE,MAAM,OAAO,CAAA;AAwB5C,MAAM,MAAM,iBAAiB,GAAG,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAA;AAE9D,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,iBAAiB,CAAA;IAC1B,SAAS,EAAE,iBAAiB,CAAA;IAC5B,aAAa,EAAE,iBAAiB,CAAA;IAChC,eAAe,EAAE,iBAAiB,CAAA;IAClC,kBAAkB,EAAE,iBAAiB,CAAA;IACrC,oBAAoB,EAAE,iBAAiB,CAAA;IACvC,YAAY,EAAE,MAAM,CAAA;CACrB;AA4GD,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAS9D;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,GAAG,aAAa,CA2DrE;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,QAAQ,GAAG,iBAAiB,CAE7E"}
+{"version":3,"file":"wall-materials.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-materials.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAS,KAAK,QAAQ,EAAE,MAAM,OAAO,CAAA;AAwB5C,MAAM,MAAM,iBAAiB,GAAG,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAA;AAE9D,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,iBAAiB,CAAA;IAC1B,SAAS,EAAE,iBAAiB,CAAA;IAC5B,aAAa,EAAE,iBAAiB,CAAA;IAChC,eAAe,EAAE,iBAAiB,CAAA;IAClC,kBAAkB,EAAE,iBAAiB,CAAA;IACrC,oBAAoB,EAAE,iBAAiB,CAAA;IACvC,YAAY,EAAE,MAAM,CAAA;CACrB;AA4GD,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAS9D;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,GAAG,aAAa,CA2DrE;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,QAAQ,GAAG,iBAAiB,CAE7E"}

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

@@ -1,8 +1,8 @@
-import { baseMaterial, getEffectiveWallSurfaceMaterial, getMaterialPresetByRef, getWallSurfaceMaterialSignature, resolveMaterial, } from '@pascal-app/core';
+import { getEffectiveWallSurfaceMaterial, getMaterialPresetByRef, getWallSurfaceMaterialSignature, resolveMaterial, } from '@pascal-app/core';
 import { Color } from 'three';
 import { Fn, float, fract, length, mix, positionLocal, smoothstep, step, vec2 } from 'three/tsl';
 import { MeshStandardNodeMaterial } from 'three/webgpu';
-import { createMaterial, createMaterialFromPresetRef } from '../../lib/materials';
+import { baseMaterial, createMaterial, createMaterialFromPresetRef } from '../../lib/materials';
 const DEFAULT_WALL_COLOR = '#f2f0ed';
 const WALL_HIGHLIGHT_PROFILES = {
     delete: {

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

@@ -0,0 +1,11 @@
+import { type AnyNode, type WallMiterData, type WallNode } from '@pascal-app/core';
+import * as THREE from 'three';
+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

@@ -0,0 +1 @@
+{"version":3,"file":"wall-system.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-system.tsx"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAkBZ,KAAK,aAAa,EAClB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAEzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AA6R9B,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,oFA0GlB"}

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

@@ -0,0 +1,592 @@
+import { calculateLevelMiters, DEFAULT_WALL_HEIGHT, getAdjacentWallIds, getWallCurveFrameAt, getWallMiterBoundaryPoints, getWallPlanFootprint, getWallSurfacePolygon, getWallThickness, isCurvedWall, pointToKey, resolveLevelId, sceneRegistry, spatialGridManager, useScene, } from '@pascal-app/core';
+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';
+// 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 computeGeometryBoundsTree(geometry) {
+    ;
+    geometry.computeBoundsTree = computeBoundsTree;
+    geometry.computeBoundsTree({ maxLeafSize: 10 });
+}
+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
+    computeGeometryBoundsTree(geometry);
+    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;
+        if ((child.type === 'door' && child.openingKind === 'opening') ||
+            (child.type === 'door' &&
+                child.openingKind === 'door' &&
+                (child.openingShape === 'arch' || child.openingShape === 'rounded')) ||
+            (child.type === 'window' && child.openingKind === 'opening') ||
+            (child.type === 'window' &&
+                child.openingKind === 'window' &&
+                (child.openingShape === 'arch' || child.openingShape === 'rounded'))) {
+            brushes.push(createShapedOpeningCutoutBrush(child, wallThickness));
+            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
+        computeGeometryBoundsTree(boxGeo);
+        const brush = new Brush(boxGeo);
+        brushes.push(brush);
+    }
+    return brushes;
+}
+function createShapedOpeningCutoutBrush(opening, wallThickness) {
+    const shape = createShapedOpeningCutoutShape(opening);
+    const depth = wallThickness * 2;
+    const bevelSize = opening.openingShape === 'rounded'
+        ? Math.min(Math.max(opening.openingRevealRadius ?? 0.025, 0), Math.max(wallThickness * 0.45, 0.001), Math.max((opening.cornerRadius ?? 0.15) * 0.45, 0.001))
+        : 0;
+    const geometry = new THREE.ExtrudeGeometry(shape, {
+        depth,
+        bevelEnabled: bevelSize > 0,
+        bevelSegments: bevelSize > 0 ? 8 : 0,
+        bevelSize,
+        bevelThickness: bevelSize,
+        curveSegments: 24,
+    });
+    geometry.translate(0, 0, -depth / 2);
+    computeGeometryBoundsTree(geometry);
+    return new Brush(geometry);
+}
+function createShapedOpeningCutoutShape(opening) {
+    const halfWidth = opening.width / 2;
+    const bottom = opening.position[1] - opening.height / 2;
+    const top = opening.position[1] + opening.height / 2;
+    const centerX = opening.position[0];
+    const left = centerX - halfWidth;
+    const right = centerX + halfWidth;
+    const width = Math.max(opening.width, 1e-6);
+    const height = Math.max(opening.height, 1e-6);
+    const shape = new THREE.Shape();
+    if (opening.openingShape === 'arch') {
+        const archHeight = Math.min(Math.max(opening.archHeight ?? width / 2, 0.01), height);
+        const springY = top - archHeight;
+        const segments = 32;
+        shape.moveTo(left, bottom);
+        shape.lineTo(right, bottom);
+        shape.lineTo(right, springY);
+        for (let index = 1; index <= segments; index += 1) {
+            const x = right + (left - right) * (index / segments);
+            const normalizedX = Math.min(Math.abs((x - centerX) / halfWidth), 1);
+            const y = springY + archHeight * Math.sqrt(Math.max(1 - normalizedX * normalizedX, 0));
+            shape.lineTo(x, y);
+        }
+        shape.lineTo(left, bottom);
+        shape.closePath();
+        return shape;
+    }
+    if (opening.openingShape === 'rounded') {
+        const radii = getRoundedOpeningRadii(opening, width, height);
+        applyRoundedOpeningShape(shape, left, right, bottom, top, radii);
+        return shape;
+    }
+    shape.moveTo(left, bottom);
+    shape.lineTo(right, bottom);
+    shape.lineTo(right, top);
+    shape.lineTo(left, top);
+    shape.closePath();
+    return shape;
+}
+function getRoundedOpeningRadii(opening, width, height) {
+    if (opening.type !== 'window') {
+        if (opening.openingRadiusMode === 'individual') {
+            const [topLeft = 0, topRight = 0] = opening.openingTopRadii ?? [0.15, 0.15];
+            return normalizeCornerRadii({
+                topLeft: Math.max(topLeft, 0),
+                topRight: Math.max(topRight, 0),
+                bottomRight: 0,
+                bottomLeft: 0,
+            }, width, height);
+        }
+        const maxRadius = Math.min(width / 2, height);
+        const radius = Math.min(Math.max(opening.cornerRadius ?? 0.15, 0), maxRadius);
+        return { topLeft: radius, topRight: radius, bottomRight: 0, bottomLeft: 0 };
+    }
+    if (opening.openingRadiusMode === 'individual') {
+        const [topLeft = 0, topRight = 0, bottomRight = 0, bottomLeft = 0] = opening.openingCornerRadii ?? [0.15, 0.15, 0.15, 0.15];
+        return normalizeCornerRadii({
+            topLeft: Math.max(topLeft, 0),
+            topRight: Math.max(topRight, 0),
+            bottomRight: Math.max(bottomRight, 0),
+            bottomLeft: Math.max(bottomLeft, 0),
+        }, width, height);
+    }
+    const maxRadius = Math.min(width / 2, height / 2);
+    const radius = Math.min(Math.max(opening.cornerRadius ?? 0.15, 0), maxRadius);
+    return { topLeft: radius, topRight: radius, bottomRight: radius, bottomLeft: radius };
+}
+function normalizeCornerRadii(radii, width, height) {
+    const next = { ...radii };
+    const maxScale = Math.min(1, width / Math.max(next.topLeft + next.topRight, 1e-6), width / Math.max(next.bottomLeft + next.bottomRight, 1e-6), height / Math.max(next.topLeft + next.bottomLeft, 1e-6), height / Math.max(next.topRight + next.bottomRight, 1e-6));
+    if (maxScale < 1) {
+        next.topLeft *= maxScale;
+        next.topRight *= maxScale;
+        next.bottomRight *= maxScale;
+        next.bottomLeft *= maxScale;
+    }
+    return next;
+}
+function applyRoundedOpeningShape(shape, left, right, bottom, top, radii) {
+    const { topLeft, topRight, bottomRight, bottomLeft } = radii;
+    shape.moveTo(left + bottomLeft, bottom);
+    shape.lineTo(right - bottomRight, bottom);
+    if (bottomRight > 1e-6) {
+        shape.absarc(right - bottomRight, bottom + bottomRight, bottomRight, -Math.PI / 2, 0, false);
+    }
+    else {
+        shape.lineTo(right, bottom);
+    }
+    shape.lineTo(right, top - topRight);
+    if (topRight > 1e-6) {
+        shape.absarc(right - topRight, top - topRight, topRight, 0, Math.PI / 2, false);
+    }
+    else {
+        shape.lineTo(right, top);
+    }
+    shape.lineTo(left + topLeft, top);
+    if (topLeft > 1e-6) {
+        shape.absarc(left + topLeft, top - topLeft, topLeft, Math.PI / 2, Math.PI, false);
+    }
+    else {
+        shape.lineTo(left, top);
+    }
+    shape.lineTo(left, bottom + bottomLeft);
+    if (bottomLeft > 1e-6) {
+        shape.absarc(left + bottomLeft, bottom + bottomLeft, bottomLeft, Math.PI, Math.PI * 1.5, false);
+    }
+    else {
+        shape.lineTo(left, bottom);
+    }
+    shape.closePath();
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"window-animation-system.d.ts","sourceRoot":"","sources":["../../../src/systems/window/window-animation-system.tsx"],"names":[],"mappings":"AA0HA,eAAO,MAAM,qBAAqB,YA+CjC,CAAA"}