@pascal-app/viewer 0.8.0 → 0.9.2

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

@@ -1,6 +1,5 @@
-import { resolveLevelId, sceneRegistry, spatialGridManager, syncAutoStairOpenings, useScene, } from '@pascal-app/core';
+import { getEffectiveNode, getFloorStackedPosition, sceneRegistry, useScene, } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
-import { useEffect, useRef } from 'react';
 import * as THREE from 'three';
 import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
 const pendingStairUpdates = new Set();
@@ -17,26 +16,6 @@ export const StairSystem = () => {
     const dirtyNodes = useScene((state) => state.dirtyNodes);
     const clearDirty = useScene((state) => state.clearDirty);
     const rootNodeIds = useScene((state) => state.rootNodeIds);
-    const syncingAutoOpeningsRef = useRef(false);
-    useEffect(() => {
-        const applyUpdates = (updates) => {
-            if (updates.length === 0)
-                return;
-            syncingAutoOpeningsRef.current = true;
-            useScene.getState().updateNodes(updates);
-            queueMicrotask(() => {
-                syncingAutoOpeningsRef.current = false;
-            });
-        };
-        applyUpdates(syncAutoStairOpenings(useScene.getState().nodes));
-        return useScene.subscribe((state, prevState) => {
-            if (syncingAutoOpeningsRef.current)
-                return;
-            if (state.nodes === prevState.nodes)
-                return;
-            applyUpdates(syncAutoStairOpenings(state.nodes));
-        });
-    }, []);
     useFrame(() => {
         if (rootNodeIds.length === 0) {
             pendingStairUpdates.clear();
@@ -58,8 +37,13 @@ export const StairSystem = () => {
                 if (mesh) {
                     const isVisible = mesh.parent?.visible !== false;
                     if (isVisible && segmentsProcessed < MAX_SEGMENTS_PER_FRAME) {
-                        // Geometry will be updated; chained position is applied in the parent sync pass below
-                        updateStairSegmentGeometry(node, mesh);
+                        // Geometry will be updated; chained position is applied in the parent sync pass below.
+                        // Merge live overrides so width / length / height drags update the
+                        // mesh in real time — the resize arrows publish to
+                        // `useLiveNodeOverrides` and only commit to scene on pointer-up, so
+                        // without this the geometry would rebuild from the pre-drag values.
+                        const effectiveSegment = getEffectiveNode(node);
+                        updateStairSegmentGeometry(effectiveSegment, mesh);
                         if (node.parentId)
                             parentsNeedingSegmentSync.add(node.parentId);
                         segmentsProcessed++;
@@ -68,11 +52,9 @@ export const StairSystem = () => {
                         return; // Over budget — keep dirty, process next frame
                     }
                     else if (mesh.geometry.type === 'BoxGeometry') {
-                        // Replace BoxGeometry placeholder with empty geometry
+                        // Replace BoxGeometry placeholder with a non-drawing degenerate one.
                         mesh.geometry.dispose();
-                        const placeholder = new THREE.BufferGeometry();
-                        placeholder.setAttribute('position', new THREE.Float32BufferAttribute([], 3));
-                        mesh.geometry = placeholder;
+                        mesh.geometry = createEmptyGeometry();
                     }
                     clearDirty(id);
                 }
@@ -93,9 +75,17 @@ export const StairSystem = () => {
         });
         // --- Pass 1b: Sync chained transforms to individual segment meshes (edit mode) ---
         for (const stairId of parentsNeedingSegmentSync) {
-            const stairNode = nodes[stairId];
-            if (!stairNode || stairNode.type !== 'stair')
+            const baseStairNode = nodes[stairId];
+            if (baseStairNode?.type !== 'stair')
                 continue;
+            // Merge any in-flight drag override (e.g. parent-stair rotate handle)
+            // so slab-elevation spatial queries match where the segments are
+            // actually being rendered. Without this, dragging the rotate gizmo
+            // looks up slabs at the pre-drag world XZ — if rotation carries a
+            // segment off the original slab footprint, the floor-stack
+            // resolver would otherwise read the pre-drag footprint and drop
+            // the flight or landing below the floor mid-drag.
+            const stairNode = getEffectiveNode(baseStairNode);
             const group = sceneRegistry.nodes.get(stairId);
             if (group) {
                 syncStairGroupElevation(stairNode, group, nodes);
@@ -108,7 +98,7 @@ export const StairSystem = () => {
             if (stairsProcessed >= MAX_STAIRS_PER_FRAME)
                 break;
             const node = nodes[id];
-            if (!node || node.type !== 'stair') {
+            if (node?.type !== 'stair') {
                 pendingStairUpdates.delete(id);
                 continue;
             }
@@ -217,9 +207,14 @@ function updateStairSegmentGeometry(node, mesh) {
  * not by the node's stored position field.
  */
 function syncSegmentMeshTransforms(stairNode, nodes) {
+    // Merge live overrides into each segment so the chain math reflects the
+    // in-flight drag (a width / length change shifts every downstream segment's
+    // anchor). Without this, dragging a width handle would resize the dragged
+    // segment's mesh but leave subsequent segments at their pre-drag positions.
     const segments = (stairNode.children ?? [])
         .map((childId) => nodes[childId])
-        .filter((n) => n?.type === 'stair-segment');
+        .filter((n) => n?.type === 'stair-segment')
+        .map((n) => getEffectiveNode(n));
     if (segments.length === 0)
         return;
     const transforms = computeSegmentTransforms(segments);
@@ -234,35 +229,20 @@ function syncSegmentMeshTransforms(stairNode, nodes) {
     }
 }
 function syncStairGroupElevation(stairNode, group, nodes) {
-    const levelId = resolveLevelId(stairNode, nodes);
-    const slabElevation = getStairSlabElevation(levelId, stairNode, nodes);
-    group.position.y = stairNode.position[1] + slabElevation;
-}
-function getStairSlabElevation(levelId, stairNode, nodes) {
-    const segments = (stairNode.children ?? [])
-        .map((childId) => nodes[childId])
-        .filter((n) => n?.type === 'stair-segment');
-    if (segments.length === 0)
-        return 0;
-    const transforms = computeSegmentTransforms(segments);
-    let maxElevation = Number.NEGATIVE_INFINITY;
-    for (let i = 0; i < segments.length; i++) {
-        const segment = segments[i];
-        const transform = transforms[i];
-        const [centerOffsetX, centerOffsetZ] = rotateXZ(0, segment.length / 2, transform.rotation);
-        const centerInGroupX = transform.position[0] + centerOffsetX;
-        const centerInGroupZ = transform.position[2] + centerOffsetZ;
-        const [centerOffsetWorldX, centerOffsetWorldZ] = rotateXZ(centerInGroupX, centerInGroupZ, stairNode.rotation);
-        const slabElevation = spatialGridManager.getSlabElevationForItem(levelId, [
-            stairNode.position[0] + centerOffsetWorldX,
-            stairNode.position[1] + transform.position[1],
-            stairNode.position[2] + centerOffsetWorldZ,
-        ], [segment.width, Math.max(segment.height, segment.thickness, 0.01), segment.length], [0, stairNode.rotation + transform.rotation, 0]);
-        if (slabElevation > maxElevation) {
-            maxElevation = slabElevation;
+    const effectiveNodes = { ...nodes, [stairNode.id]: stairNode };
+    for (const childId of stairNode.children ?? []) {
+        const segment = nodes[childId];
+        if (segment?.type === 'stair-segment') {
+            effectiveNodes[segment.id] = getEffectiveNode(segment);
         }
     }
-    return maxElevation === Number.NEGATIVE_INFINITY ? 0 : maxElevation;
+    const visualPosition = getFloorStackedPosition({
+        node: stairNode,
+        nodes: effectiveNodes,
+        position: stairNode.position,
+        rotation: stairNode.rotation,
+    });
+    group.position.y = visualPosition[1];
 }
 // ============================================================================
 // MERGED STAIR GEOMETRY
@@ -281,9 +261,14 @@ function updateMergedStairGeometry(stairNode, group, nodes) {
         return;
     }
     const children = stairNode.children ?? [];
+    // Merge live overrides — same reason as `syncSegmentMeshTransforms`: a
+    // width / length / height drag publishes the new value to
+    // `useLiveNodeOverrides`, so the merged geometry has to read through that
+    // overlay or the merged mesh stays at pre-drag values until pointer-up.
     const segments = children
         .map((childId) => nodes[childId])
-        .filter((n) => n?.type === 'stair-segment');
+        .filter((n) => n?.type === 'stair-segment')
+        .map((n) => getEffectiveNode(n));
     if (segments.length === 0) {
         replaceMeshGeometry(mergedMesh, createEmptyGeometry());
         return;
@@ -444,7 +429,14 @@ function rotateXZ(x, z, angle) {
 }
 function createEmptyGeometry() {
     const geometry = new THREE.BufferGeometry();
-    geometry.setAttribute('position', new THREE.Float32BufferAttribute([], 3));
+    // Three zero-vertices (one degenerate, invisible triangle), not an empty
+    // attribute: an empty position (count 0) leaves WebGPU vertex buffer slot 0
+    // unbound and the draw is rejected ("Vertex buffer slot 0 … was not set"),
+    // poisoning the command encoder. The count-0 groups keep nothing drawn.
+    geometry.setAttribute('position', new THREE.Float32BufferAttribute(new Float32Array(9), 3));
+    geometry.setAttribute('normal', new THREE.Float32BufferAttribute(new Float32Array(9), 3));
+    geometry.setAttribute('uv', new THREE.Float32BufferAttribute(new Float32Array(6), 2));
+    geometry.setAttribute('uv2', new THREE.Float32BufferAttribute(new Float32Array(6), 2));
     geometry.addGroup(0, 0, STAIR_TREAD_MATERIAL_INDEX);
     geometry.addGroup(0, 0, STAIR_SIDE_MATERIAL_INDEX);
     return geometry;
@@ -479,7 +471,7 @@ function generateStairRailingGeometry(stairNode, segments, transforms) {
     for (let index = 1; index < segmentRailPaths.length; index++) {
         const previousPath = segmentRailPaths[index - 1];
         const currentPath = segmentRailPaths[index];
-        if (!(previousPath && currentPath && currentPath.connectFromPrevious))
+        if (!(previousPath && currentPath?.connectFromPrevious))
             continue;
         if (previousPath.segment.segmentType === 'landing')
             continue;
@@ -756,7 +748,7 @@ function computeAbsoluteHeight(node) {
     if (!node.parentId)
         return 0;
     const parent = nodes[node.parentId];
-    if (!parent || parent.type !== 'stair')
+    if (parent?.type !== 'stair')
         return 0;
     const stair = parent;
     const segments = (stair.children ?? [])

package/dist/systems/surface-hole-geometry.d.ts

@@ -0,0 +1,3 @@
+import { type Point2D } from '../lib/polygon-union';
+export declare function mergeSurfaceHolePolygons(holes: Point2D[][]): Point2D[][];
+//# sourceMappingURL=surface-hole-geometry.d.ts.map

package/dist/systems/surface-hole-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"surface-hole-geometry.d.ts","sourceRoot":"","sources":["../../src/systems/surface-hole-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAiB,MAAM,sBAAsB,CAAA;AAElE,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,GAAG,OAAO,EAAE,EAAE,CAExE"}

package/dist/systems/surface-hole-geometry.js

@@ -0,0 +1,4 @@
+import { unionPolygons } from '../lib/polygon-union';
+export function mergeSurfaceHolePolygons(holes) {
+    return unionPolygons(holes);
+}

package/dist/systems/wall/opening-cutout-geometry.d.ts

@@ -0,0 +1,31 @@
+import type { DoorNode, WindowNode } from '@pascal-app/core';
+import * as THREE from 'three';
+export type OpeningCutoutNode = DoorNode | WindowNode;
+export type OpeningCutoutRect = {
+    left: number;
+    right: number;
+    bottom: number;
+    top: number;
+};
+export declare function getOpeningCutoutProxyDepth(wallThickness: number): number;
+/**
+ * Pure cutout profile for a shaped door / window opening. `rect` is in
+ * the caller's coordinate frame — the wall CSG pipeline passes wall-local
+ * coords, the roof-wall pipeline an origin-centered rect — so the same
+ * radii / arch math serves both hosts.
+ */
+export declare function buildOpeningCutoutShape(opening: OpeningCutoutNode, rect: OpeningCutoutRect): THREE.Shape;
+export declare function buildOpeningCutoutGeometry(opening: OpeningCutoutNode, rect: OpeningCutoutRect, depth: number, wallThickness: number): THREE.BufferGeometry;
+/**
+ * Whether the cutout profile's bottom edge is a flat chord. Cuts whose
+ * bottom sits coplanar with the host wall base get extended slightly
+ * downward to keep CSG away from coplanar faces — but only a flat chord
+ * may extend; shifting a rounded bottom would distort the profile.
+ */
+export declare function hasFlatOpeningCutoutBottom(opening: OpeningCutoutNode): boolean;
+/**
+ * Extends floor-level flat cutouts below the host wall so CSG never has to
+ * subtract a face exactly coplanar with the wall base.
+ */
+export declare function getOpeningCutoutBottomPadding(opening: OpeningCutoutNode, bottom: number): number;
+//# sourceMappingURL=opening-cutout-geometry.d.ts.map

package/dist/systems/wall/opening-cutout-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opening-cutout-geometry.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/opening-cutout-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,UAAU,CAAA;AAErD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA;AAYD,wBAAgB,0BAA0B,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAExE;AASD;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,iBAAiB,EAC1B,IAAI,EAAE,iBAAiB,GACtB,KAAK,CAAC,KAAK,CAuCb;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,iBAAiB,EAC1B,IAAI,EAAE,iBAAiB,EACvB,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,MAAM,GACpB,KAAK,CAAC,cAAc,CAqBtB;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAW9E;AAED;;;GAGG;AACH,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,iBAAiB,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAEhG"}

package/dist/systems/wall/opening-cutout-geometry.js

@@ -0,0 +1,167 @@
+import * as THREE from 'three';
+// The cutout proxy doubles as the invisible raycast hit target for an opening:
+// centered on the wall and extending past both faces so it wins the scene
+// raycast over the recessed door/window body for front AND back selection +
+// paint. Wall CSG rebuilds opening cuts directly from node data, so this proxy
+// only needs to clear the wall thickness plus a small proud margin. A snug depth
+// keeps the hit target useful without blanketing the room floor in a top-down
+// view (the bug a 1m-deep proxy caused in narrow hallways).
+const OPENING_CUTOUT_PROXY_PROUD_MARGIN = 0.08;
+const OPENING_CUTOUT_BOTTOM_PADDING = 0.02;
+export function getOpeningCutoutProxyDepth(wallThickness) {
+    return Math.max(wallThickness, 0) + OPENING_CUTOUT_PROXY_PROUD_MARGIN;
+}
+/**
+ * Pure cutout profile for a shaped door / window opening. `rect` is in
+ * the caller's coordinate frame — the wall CSG pipeline passes wall-local
+ * coords, the roof-wall pipeline an origin-centered rect — so the same
+ * radii / arch math serves both hosts.
+ */
+export function buildOpeningCutoutShape(opening, rect) {
+    const { left, right, bottom, top } = rect;
+    const width = Math.max(right - left, 1e-6);
+    const height = Math.max(top - bottom, 1e-6);
+    const shape = new THREE.Shape();
+    if (opening.openingShape === 'arch') {
+        const halfWidth = width / 2;
+        const centerX = (left + right) / 2;
+        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;
+}
+export function buildOpeningCutoutGeometry(opening, rect, depth, wallThickness) {
+    const shape = buildOpeningCutoutShape(opening, rect);
+    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);
+    return geometry;
+}
+/**
+ * Whether the cutout profile's bottom edge is a flat chord. Cuts whose
+ * bottom sits coplanar with the host wall base get extended slightly
+ * downward to keep CSG away from coplanar faces — but only a flat chord
+ * may extend; shifting a rounded bottom would distort the profile.
+ */
+export function hasFlatOpeningCutoutBottom(opening) {
+    if (opening.openingShape !== 'rounded' || opening.type !== 'window')
+        return true;
+    if (opening.openingRadiusMode === 'individual') {
+        const [, , bottomRight = 0, bottomLeft = 0] = opening.openingCornerRadii ?? [
+            0.15, 0.15, 0.15, 0.15,
+        ];
+        return bottomRight <= 1e-6 && bottomLeft <= 1e-6;
+    }
+    return Math.max(opening.cornerRadius ?? 0.15, 0) <= 1e-6;
+}
+/**
+ * Extends floor-level flat cutouts below the host wall so CSG never has to
+ * subtract a face exactly coplanar with the wall base.
+ */
+export function getOpeningCutoutBottomPadding(opening, bottom) {
+    return bottom < 0.005 && hasFlatOpeningCutoutBottom(opening) ? OPENING_CUTOUT_BOTTOM_PADDING : 0;
+}
+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/wall/opening-cutout-geometry.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=opening-cutout-geometry.test.d.ts.map

package/dist/systems/wall/opening-cutout-geometry.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opening-cutout-geometry.test.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/opening-cutout-geometry.test.ts"],"names":[],"mappings":""}

package/dist/systems/wall/opening-cutout-geometry.test.js

@@ -0,0 +1,172 @@
+// @ts-expect-error — bun:test is provided by the Bun runtime; viewer does not
+// depend on @types/bun so the import type is unresolved at compile time.
+import { describe, expect, test } from 'bun:test';
+import { DoorNode, WindowNode } from '@pascal-app/core';
+import { buildOpeningCutoutGeometry, buildOpeningCutoutShape, getOpeningCutoutBottomPadding, hasFlatOpeningCutoutBottom, } from './opening-cutout-geometry';
+function containsPoint(points, x, y) {
+    return points.some((point) => Math.abs(point.x - x) < 1e-6 && Math.abs(point.y - y) < 1e-6);
+}
+function getBounds(points) {
+    let minX = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let minY = Number.POSITIVE_INFINITY;
+    let maxY = Number.NEGATIVE_INFINITY;
+    for (const point of points) {
+        minX = Math.min(minX, point.x);
+        maxX = Math.max(maxX, point.x);
+        minY = Math.min(minY, point.y);
+        maxY = Math.max(maxY, point.y);
+    }
+    return { minX, maxX, minY, maxY };
+}
+describe('buildOpeningCutoutShape', () => {
+    test('rectangle profile passes the rect through unchanged', () => {
+        const door = DoorNode.parse({});
+        const rect = { left: 1.2, right: 2.1, bottom: 0, top: 2.1 };
+        const points = buildOpeningCutoutShape(door, rect).getPoints();
+        expect(containsPoint(points, rect.left, rect.bottom)).toBe(true);
+        expect(containsPoint(points, rect.right, rect.bottom)).toBe(true);
+        expect(containsPoint(points, rect.right, rect.top)).toBe(true);
+        expect(containsPoint(points, rect.left, rect.top)).toBe(true);
+        const bounds = getBounds(points);
+        expect(bounds.minX).toBeCloseTo(rect.left, 9);
+        expect(bounds.maxX).toBeCloseTo(rect.right, 9);
+        expect(bounds.minY).toBeCloseTo(rect.bottom, 9);
+        expect(bounds.maxY).toBeCloseTo(rect.top, 9);
+    });
+    test('door rounded profile rounds only the top corners', () => {
+        const door = DoorNode.parse({ openingShape: 'rounded', cornerRadius: 0.2 });
+        const rect = { left: -0.45, right: 0.45, bottom: 0, top: 2.1 };
+        const points = buildOpeningCutoutShape(door, rect).getPoints();
+        expect(containsPoint(points, rect.left, rect.bottom)).toBe(true);
+        expect(containsPoint(points, rect.right, rect.bottom)).toBe(true);
+        expect(containsPoint(points, rect.left, rect.top)).toBe(false);
+        expect(containsPoint(points, rect.right, rect.top)).toBe(false);
+        expect(containsPoint(points, rect.left, rect.top - 0.2)).toBe(true);
+        expect(containsPoint(points, rect.left + 0.2, rect.top)).toBe(true);
+        expect(containsPoint(points, rect.right, rect.top - 0.2)).toBe(true);
+        expect(containsPoint(points, rect.right - 0.2, rect.top)).toBe(true);
+    });
+    test('window rounded profile rounds all four corners', () => {
+        const window = WindowNode.parse({ openingShape: 'rounded', cornerRadius: 0.2 });
+        const rect = { left: -0.75, right: 0.75, bottom: 0.9, top: 2.4 };
+        const points = buildOpeningCutoutShape(window, rect).getPoints();
+        expect(containsPoint(points, rect.left, rect.bottom)).toBe(false);
+        expect(containsPoint(points, rect.right, rect.bottom)).toBe(false);
+        expect(containsPoint(points, rect.left, rect.top)).toBe(false);
+        expect(containsPoint(points, rect.right, rect.top)).toBe(false);
+        expect(containsPoint(points, rect.left + 0.2, rect.bottom)).toBe(true);
+        expect(containsPoint(points, rect.left, rect.bottom + 0.2)).toBe(true);
+        expect(containsPoint(points, rect.right - 0.2, rect.top)).toBe(true);
+        expect(containsPoint(points, rect.right, rect.top - 0.2)).toBe(true);
+        const bounds = getBounds(points);
+        expect(bounds.minX).toBeCloseTo(rect.left, 9);
+        expect(bounds.maxX).toBeCloseTo(rect.right, 9);
+        expect(bounds.minY).toBeCloseTo(rect.bottom, 9);
+        expect(bounds.maxY).toBeCloseTo(rect.top, 9);
+    });
+    test('shared corner radius is clamped to the opening half-extent', () => {
+        const window = WindowNode.parse({ openingShape: 'rounded', cornerRadius: 10 });
+        const rect = { left: -0.75, right: 0.75, bottom: 0.9, top: 2.4 };
+        const points = buildOpeningCutoutShape(window, rect).getPoints();
+        // 1.5 × 1.5 opening → radius clamps to 0.75; arcs meet at edge midpoints.
+        expect(containsPoint(points, rect.left, rect.bottom + 0.75)).toBe(true);
+        expect(containsPoint(points, rect.right, rect.top - 0.75)).toBe(true);
+        const bounds = getBounds(points);
+        expect(bounds.minX).toBeCloseTo(rect.left, 9);
+        expect(bounds.maxX).toBeCloseTo(rect.right, 9);
+    });
+    test('individual radii normalize when their sum exceeds the opening width', () => {
+        const window = WindowNode.parse({
+            openingShape: 'rounded',
+            openingRadiusMode: 'individual',
+            openingCornerRadii: [4, 4, 0, 0],
+        });
+        const rect = { left: -0.5, right: 0.5, bottom: 0, top: 2 };
+        const points = buildOpeningCutoutShape(window, rect).getPoints();
+        // Width 1 with top radii summing to 8 → scaled down to 0.5 each.
+        expect(containsPoint(points, rect.left, rect.top - 0.5)).toBe(true);
+        expect(containsPoint(points, rect.left + 0.5, rect.top)).toBe(true);
+        expect(containsPoint(points, rect.left, rect.bottom)).toBe(true);
+        expect(containsPoint(points, rect.right, rect.bottom)).toBe(true);
+    });
+    test('arch profile springs at top - archHeight and peaks at the rect top', () => {
+        const door = DoorNode.parse({ openingShape: 'arch', archHeight: 0.45 });
+        const rect = { left: -0.45, right: 0.45, bottom: 0, top: 2.1 };
+        const points = buildOpeningCutoutShape(door, rect).getPoints();
+        expect(containsPoint(points, rect.left, rect.bottom)).toBe(true);
+        expect(containsPoint(points, rect.right, rect.bottom)).toBe(true);
+        expect(containsPoint(points, rect.right, rect.top - 0.45)).toBe(true);
+        expect(containsPoint(points, 0, rect.top)).toBe(true);
+        expect(containsPoint(points, rect.left, rect.top)).toBe(false);
+        expect(containsPoint(points, rect.right, rect.top)).toBe(false);
+    });
+    test('profiles are origin-agnostic — offset rects yield translated points', () => {
+        const window = WindowNode.parse({ openingShape: 'rounded', cornerRadius: 0.2 });
+        const centered = buildOpeningCutoutShape(window, {
+            left: -0.75,
+            right: 0.75,
+            bottom: -0.75,
+            top: 0.75,
+        }).getPoints();
+        const offset = buildOpeningCutoutShape(window, {
+            left: 2.25,
+            right: 3.75,
+            bottom: 0.9,
+            top: 2.4,
+        }).getPoints();
+        for (const point of centered) {
+            expect(containsPoint(offset, point.x + 3, point.y + 1.65)).toBe(true);
+        }
+        for (const point of offset) {
+            expect(containsPoint(centered, point.x - 3, point.y - 1.65)).toBe(true);
+        }
+    });
+});
+describe('buildOpeningCutoutGeometry', () => {
+    test('extrudes the rect through the depth, centered on the mid-plane', () => {
+        const door = DoorNode.parse({});
+        const geometry = buildOpeningCutoutGeometry(door, { left: -0.45, right: 0.45, bottom: -1.05, top: 1.05 }, 0.24, 0.1);
+        geometry.computeBoundingBox();
+        // Float32 position buffer → ~1e-7 relative precision.
+        const box = geometry.boundingBox;
+        expect(box.min.x).toBeCloseTo(-0.45, 6);
+        expect(box.max.x).toBeCloseTo(0.45, 6);
+        expect(box.min.y).toBeCloseTo(-1.05, 6);
+        expect(box.max.y).toBeCloseTo(1.05, 6);
+        expect(box.min.z).toBeCloseTo(-0.12, 6);
+        expect(box.max.z).toBeCloseTo(0.12, 6);
+    });
+});
+describe('hasFlatOpeningCutoutBottom', () => {
+    test('flat for rectangles, arches, and door rounded (top-only radii)', () => {
+        expect(hasFlatOpeningCutoutBottom(DoorNode.parse({}))).toBe(true);
+        expect(hasFlatOpeningCutoutBottom(WindowNode.parse({ openingShape: 'arch' }))).toBe(true);
+        expect(hasFlatOpeningCutoutBottom(DoorNode.parse({ openingShape: 'rounded' }))).toBe(true);
+    });
+    test('rounded windows depend on their bottom radii', () => {
+        expect(hasFlatOpeningCutoutBottom(WindowNode.parse({ openingShape: 'rounded' }))).toBe(false);
+        expect(hasFlatOpeningCutoutBottom(WindowNode.parse({ openingShape: 'rounded', cornerRadius: 0 }))).toBe(true);
+        expect(hasFlatOpeningCutoutBottom(WindowNode.parse({
+            openingShape: 'rounded',
+            openingRadiusMode: 'individual',
+            openingCornerRadii: [0.2, 0.2, 0, 0],
+        }))).toBe(true);
+        expect(hasFlatOpeningCutoutBottom(WindowNode.parse({
+            openingShape: 'rounded',
+            openingRadiusMode: 'individual',
+            openingCornerRadii: [0.2, 0.2, 0.2, 0.2],
+        }))).toBe(false);
+    });
+});
+describe('getOpeningCutoutBottomPadding', () => {
+    test('pads floor-level openings with a flat bottom', () => {
+        expect(getOpeningCutoutBottomPadding(DoorNode.parse({}), 0)).toBe(0.02);
+        expect(getOpeningCutoutBottomPadding(DoorNode.parse({ openingShape: 'rounded' }), 0)).toBe(0.02);
+        expect(getOpeningCutoutBottomPadding(WindowNode.parse({ openingShape: 'arch' }), 0)).toBe(0.02);
+    });
+    test('does not pad openings above the floor or rounded window bottoms', () => {
+        expect(getOpeningCutoutBottomPadding(DoorNode.parse({}), 0.9)).toBe(0);
+        expect(getOpeningCutoutBottomPadding(WindowNode.parse({ openingShape: 'rounded' }), 0)).toBe(0);
+    });
+});

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

@@ -1 +1 @@
-{"version":3,"file":"wall-cutout.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-cutout.tsx"],"names":[],"mappings":"AAsCA,eAAO,MAAM,UAAU,YAkHtB,CAAA"}
+{"version":3,"file":"wall-cutout.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-cutout.tsx"],"names":[],"mappings":"AAqDA,eAAO,MAAM,UAAU,YAyKtB,CAAA"}