@pascal-app/viewer 0.9.1 → 1.0.0-beta.1

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

@@ -1,13 +1,37 @@
-import { calculateLevelMiters, DEFAULT_WALL_HEIGHT, getAdjacentWallIds, getEffectiveNode, getWallCurveFrameAt, getWallMiterBoundaryPoints, getWallPlanFootprint, getWallSurfacePolygon, getWallThickness, isCurvedWall, pointToKey, resolveLevelId, sceneRegistry, spatialGridManager, useLiveNodeOverrides, useLiveTransforms, useScene, } from '@pascal-app/core';
+import { calculateLevelMiters, DEFAULT_LEVEL_HEIGHT, getAdjacentWallIds, getEffectiveNode, getWallBandSlotId, getWallCurveFrameAt, getWallFaceBandConfig, getWallFaceBandForHeight, getWallMiterBoundaryPoints, getWallPlaneTop, getWallPlanFootprint, getWallSurfacePolygon, getWallThickness, isCurvedWall, pointToKey, resolveLevelId, resolveWallTop, sceneRegistry, spatialGridManager, terrainSupportLift, useLiveNodeOverrides, useLiveTransforms, useScene, } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
 import * as THREE from 'three';
+import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
 import { Brush, Evaluator, SUBTRACTION } from 'three-bvh-csg';
 import { computeBoundsTree } from 'three-mesh-bvh';
+import { ensureRenderableGeometryAttributes, prepareBrushForCSG } from '../../lib/csg-utils';
+import { buildTerrainPerimeterFillGeometry } from '../../lib/terrain-perimeter-fill';
+import { buildOpeningCutoutGeometry, getOpeningCutoutBottomPadding, } from './opening-cutout-geometry';
 // Reusable CSG evaluator for better performance
 const csgEvaluator = new Evaluator();
+csgEvaluator.attributes = ['position', 'normal', 'uv', 'uv2'];
 const CURVED_WALL_3D_ENDPOINT_INSET = 0.0015;
 const WALL_FACE_NORMAL_Y_EPSILON = 0.6;
 const WALL_FACE_EDGE_DISTANCE_EPSILON = 0.003;
+const WALL_BAND_SPLIT_EPSILON = 1e-5;
+const WALL_BAND_SLOT_MATERIAL_INDEX = {
+    interior: 1,
+    exterior: 2,
+    lowerInterior: 3,
+    middleInterior: 4,
+    upperInterior: 5,
+    topInterior: 6,
+    lowerExterior: 7,
+    middleExterior: 8,
+    upperExterior: 9,
+    topExterior: 10,
+    skirtingInterior: 0,
+    skirtingExterior: 0,
+    crownInterior: 0,
+    crownExterior: 0,
+    chairRailInterior: 0,
+    chairRailExterior: 0,
+};
 function computeGeometryBoundsTree(geometry) {
     ;
     geometry.computeBoundsTree = computeBoundsTree;
@@ -16,12 +40,6 @@ function computeGeometryBoundsTree(geometry) {
 function csgGeometry(brush) {
     return brush.geometry;
 }
-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;
@@ -117,16 +135,17 @@ function distanceToWallBoundaryEdge(point, edge) {
     const closestZ = edge.start.y + edgeDz * t;
     return Math.hypot(point.x - closestX, point.y - closestZ);
 }
-function getWallFaceMaterialIndex(wall, face) {
+function getWallFaceMaterialIndex(wall, face, y, effectiveWallHeight) {
     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;
+    const fallback = face === 'front' ? 'interior' : 'exterior';
+    const side = semantic === 'interior' || semantic === 'exterior' ? semantic : fallback;
+    const bands = getWallFaceBandConfig(wall, effectiveWallHeight);
+    if (!bands.enabled)
+        return WALL_BAND_SLOT_MATERIAL_INDEX[side];
+    const band = getWallFaceBandForHeight(wall, y, effectiveWallHeight);
+    return WALL_BAND_SLOT_MATERIAL_INDEX[getWallBandSlotId(side, band)];
 }
-function assignWallMaterialGroups(geometry, wall, boundaryEdges) {
+function assignWallMaterialGroups(geometry, wall, boundaryEdges, effectiveWallHeight) {
     const position = geometry.getAttribute('position');
     if (!position)
         return;
@@ -189,7 +208,7 @@ function assignWallMaterialGroups(geometry, wall, boundaryEdges) {
             triangleMaterials[triangleIndex] = 0;
             continue;
         }
-        triangleMaterials[triangleIndex] = getWallFaceMaterialIndex(wall, nearestTag);
+        triangleMaterials[triangleIndex] = getWallFaceMaterialIndex(wall, nearestTag, centroid.y, effectiveWallHeight);
     }
     geometry.clearGroups();
     let currentMaterial = triangleMaterials[0] ?? 0;
@@ -204,6 +223,105 @@ function assignWallMaterialGroups(geometry, wall, boundaryEdges) {
     }
     geometry.addGroup(groupStart * 3, (triangleCount - groupStart) * 3, currentMaterial);
 }
+function interpolateSplitVertex(a, b, t) {
+    return {
+        x: a.x + (b.x - a.x) * t,
+        y: a.y + (b.y - a.y) * t,
+        z: a.z + (b.z - a.z) * t,
+    };
+}
+function clipPolygonByY(polygon, planeY, keepBelow) {
+    const out = [];
+    if (polygon.length === 0)
+        return out;
+    const isInside = (vertex) => keepBelow
+        ? vertex.y <= planeY + WALL_BAND_SPLIT_EPSILON
+        : vertex.y >= planeY - WALL_BAND_SPLIT_EPSILON;
+    for (let index = 0; index < polygon.length; index += 1) {
+        const current = polygon[index];
+        const previous = polygon[(index + polygon.length - 1) % polygon.length];
+        const currentInside = isInside(current);
+        const previousInside = isInside(previous);
+        if (currentInside !== previousInside) {
+            const denom = current.y - previous.y;
+            if (Math.abs(denom) > WALL_BAND_SPLIT_EPSILON) {
+                out.push(interpolateSplitVertex(previous, current, (planeY - previous.y) / denom));
+            }
+        }
+        if (currentInside)
+            out.push(current);
+    }
+    return out;
+}
+function triangulateSplitPolygon(polygon, positions) {
+    if (polygon.length < 3)
+        return;
+    const first = polygon[0];
+    for (let index = 1; index < polygon.length - 1; index += 1) {
+        const b = polygon[index];
+        const c = polygon[index + 1];
+        positions.push(first.x, first.y, first.z, b.x, b.y, b.z, c.x, c.y, c.z);
+    }
+}
+function splitGeometryAtHorizontalPlanes(geometry, planes) {
+    const splitPlanes = Array.from(new Set(planes
+        .filter((plane) => Number.isFinite(plane) && plane > WALL_BAND_SPLIT_EPSILON)
+        .map((plane) => Math.round(plane / WALL_BAND_SPLIT_EPSILON) * WALL_BAND_SPLIT_EPSILON))).sort((a, b) => a - b);
+    if (splitPlanes.length === 0)
+        return geometry;
+    const source = geometry.index ? geometry.toNonIndexed() : geometry;
+    const position = source.getAttribute('position');
+    if (!position || position.count === 0)
+        return source;
+    const positions = [];
+    for (let index = 0; index < position.count; index += 3) {
+        let polygons = [
+            [
+                { x: position.getX(index), y: position.getY(index), z: position.getZ(index) },
+                { x: position.getX(index + 1), y: position.getY(index + 1), z: position.getZ(index + 1) },
+                { x: position.getX(index + 2), y: position.getY(index + 2), z: position.getZ(index + 2) },
+            ],
+        ];
+        for (const plane of splitPlanes) {
+            const next = [];
+            for (const polygon of polygons) {
+                const minY = Math.min(...polygon.map((vertex) => vertex.y));
+                const maxY = Math.max(...polygon.map((vertex) => vertex.y));
+                if (plane <= minY + WALL_BAND_SPLIT_EPSILON || plane >= maxY - WALL_BAND_SPLIT_EPSILON) {
+                    next.push(polygon);
+                    continue;
+                }
+                const below = clipPolygonByY(polygon, plane, true);
+                const above = clipPolygonByY(polygon, plane, false);
+                if (below.length >= 3)
+                    next.push(below);
+                if (above.length >= 3)
+                    next.push(above);
+            }
+            polygons = next;
+        }
+        for (const polygon of polygons)
+            triangulateSplitPolygon(polygon, positions);
+    }
+    if (source !== geometry)
+        geometry.dispose();
+    source.dispose();
+    const split = new THREE.BufferGeometry();
+    split.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
+    split.computeVertexNormals();
+    return split;
+}
+function getWallBandSplitPlanes(wall, effectiveWallHeight) {
+    const bands = getWallFaceBandConfig(wall, effectiveWallHeight);
+    if (!bands.enabled)
+        return [];
+    const planes = [bands.lowerTop];
+    if (bands.count >= 3)
+        planes.push(bands.middleTop);
+    if (bands.count >= 4)
+        planes.push(bands.upperTop);
+    return planes.filter((plane) => plane > WALL_BAND_SPLIT_EPSILON && plane < effectiveWallHeight - WALL_BAND_SPLIT_EPSILON);
+}
 // ============================================================================
 // WALL SYSTEM
 // ============================================================================
@@ -258,7 +376,7 @@ export const WallSystem = () => {
         if (hasDirty) {
             dirtyNodes.forEach((id) => {
                 const node = nodes[id];
-                if (!node || node.type !== 'wall')
+                if (node?.type !== 'wall')
                     return;
                 const levelId = node.parentId;
                 if (!levelId)
@@ -387,7 +505,7 @@ function getEffectiveWall(wall) {
 function getLevelWalls(levelId) {
     const { nodes } = useScene.getState();
     const level = nodes[levelId];
-    if (!level || level.type !== 'level')
+    if (level?.type !== 'level')
         return [];
     const walls = [];
     for (const childId of level.children) {
@@ -406,14 +524,21 @@ function getLevelWalls(levelId) {
 function updateWallGeometry(wallId, miterData) {
     const nodes = useScene.getState().nodes;
     const sceneNode = nodes[wallId];
-    if (!sceneNode || sceneNode.type !== 'wall')
+    if (sceneNode?.type !== 'wall')
         return;
     const node = getEffectiveWall(sceneNode);
     const mesh = sceneRegistry.nodes.get(wallId);
     if (!mesh)
         return;
     const levelId = resolveLevelId(node, nodes);
-    const slabElevation = spatialGridManager.getSlabElevationForWall(levelId, node.start, node.end, node.curveOffset ?? 0, node.thickness);
+    // Covering-clamped plane: a flush/thick slab on the level above shortens
+    // the plane-bound walls below it (explicit-height walls ignore the value).
+    const planeTop = getWallPlaneTop(node, levelId, nodes);
+    const slabSupport = spatialGridManager.getSlabSupportForWall(levelId, node.start, node.end, node.curveOffset ?? 0, node.thickness, node.supportSlabId, undefined, node.supportOffset);
+    const slabElevation = slabSupport.elevation;
+    const terrainBottomAt = node.fillToTerrain
+        ? (x, z) => terrainSupportLift(nodes, levelId, x, z)
+        : undefined;
     const childrenIds = node.children || [];
     // Merge live overrides into door / window children so cutouts track an
     // in-flight resize drag (door width arrow, window height arrow, etc.)
@@ -427,22 +552,27 @@ function updateWallGeometry(wallId, miterData) {
             return child;
         // `getEffectiveNode` folds in resize overrides (width/height arrows).
         // Position moves publish to `useLiveTransforms` instead, so fold that
-        // in too — otherwise shaped openings (arch/rounded/`opening`), whose
-        // cutout brush is rebuilt from `node.position`, lag the live move
-        // (rectangular cutouts already track via the live mesh matrixWorld).
+        // in too — opening cutout brushes are rebuilt directly from the
+        // effective node position rather than from the rendered proxy mesh.
         const effective = getEffectiveNode(child);
         const live = useLiveTransforms.getState().get(child.id);
         if (!live?.position)
             return effective;
         return { ...effective, position: live.position };
     });
-    const newGeo = generateExtrudedWall(node, childrenNodes, miterData, slabElevation);
+    const builtGeo = generateExtrudedWall(node, childrenNodes, miterData, slabElevation, slabSupport.baseElevation, slabSupport.baseSegments, planeTop, terrainBottomAt);
+    const wallAngle = Math.atan2(node.end[1] - node.start[1], node.end[0] - node.start[0]);
+    // World transform the render mesh will apply (position + Y-rotation below).
+    // Reproduce it here so the UVs can be projected in WORLD space — see
+    // `applyWorldPlanarWallUVs`.
+    const wallWorldMatrix = new THREE.Matrix4().compose(new THREE.Vector3(node.start[0], slabElevation, node.start[1]), new THREE.Quaternion().setFromAxisAngle(WALL_UV_Y_AXIS, -wallAngle), WALL_UV_UNIT_SCALE);
+    const newGeo = applyWorldPlanarWallUVs(builtGeo, wallWorldMatrix);
     mesh.geometry.dispose();
     mesh.geometry = newGeo;
     // Update collision mesh
     const collisionMesh = mesh.getObjectByName('collision-mesh');
     if (collisionMesh) {
-        const collisionGeo = generateExtrudedWall(node, [], miterData, slabElevation);
+        const collisionGeo = generateExtrudedWall(node, [], miterData, slabElevation, slabSupport.baseElevation, slabSupport.baseSegments, planeTop, terrainBottomAt);
         collisionMesh.geometry.dispose();
         collisionMesh.geometry = collisionGeo;
     }
@@ -450,19 +580,133 @@ function updateWallGeometry(wallId, miterData) {
     const angle = Math.atan2(node.end[1] - node.start[1], node.end[0] - node.start[0]);
     mesh.rotation.y = -angle;
 }
+const WALL_UV_Y_AXIS = new THREE.Vector3(0, 1, 0);
+const WALL_UV_UNIT_SCALE = new THREE.Vector3(1, 1, 1);
+/**
+ * Re-project a wall's UVs in WORLD space (1 UV unit = 1 m) so the finish tiles
+ * continuously across adjacent walls and lines up with the roof gable above —
+ * instead of THREE's `ExtrudeGeometry` UVs, which restart at each wall's own
+ * start/end. Matches `roof-system`'s `pushRoofUv` projection exactly: vertical
+ * faces use `U = ±worldX/Z` (the axis across the face normal) and `V = 1 -
+ * worldY`; the thin top/bottom caps use `(worldX, worldZ)`. De-indexes first so
+ * every triangle projects by its own face normal (no shared-vertex seams at
+ * edges). Applied only to the render mesh; collision/floorplan geometry is
+ * untouched.
+ */
+function applyWorldPlanarWallUVs(geometry, worldMatrix) {
+    const target = geometry.index ? geometry.toNonIndexed() : geometry;
+    if (target !== geometry)
+        geometry.dispose();
+    const position = target.getAttribute('position');
+    if (!position || position.count === 0)
+        return target;
+    const a = new THREE.Vector3();
+    const b = new THREE.Vector3();
+    const c = new THREE.Vector3();
+    const normal = new THREE.Vector3();
+    const edgeAB = new THREE.Vector3();
+    const edgeAC = new THREE.Vector3();
+    const uvs = new Float32Array(position.count * 2);
+    for (let i = 0; i < position.count; i += 3) {
+        a.fromBufferAttribute(position, i).applyMatrix4(worldMatrix);
+        b.fromBufferAttribute(position, i + 1).applyMatrix4(worldMatrix);
+        c.fromBufferAttribute(position, i + 2).applyMatrix4(worldMatrix);
+        edgeAB.subVectors(b, a);
+        edgeAC.subVectors(c, a);
+        normal.crossVectors(edgeAB, edgeAC).normalize();
+        const absX = Math.abs(normal.x);
+        const absY = Math.abs(normal.y);
+        const absZ = Math.abs(normal.z);
+        for (let k = 0; k < 3; k += 1) {
+            const p = k === 0 ? a : k === 1 ? b : c;
+            let u;
+            let v;
+            if (absY >= absX && absY >= absZ) {
+                u = p.x;
+                v = p.z;
+            }
+            else {
+                v = 1 - p.y;
+                u = absX >= absZ ? (normal.x >= 0 ? p.z : -p.z) : normal.z >= 0 ? p.x : -p.x;
+            }
+            uvs[(i + k) * 2] = u;
+            uvs[(i + k) * 2 + 1] = v;
+        }
+    }
+    target.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
+    target.setAttribute('uv2', new THREE.Float32BufferAttribute(uvs.slice(), 2));
+    return target;
+}
 /**
  * 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 WALL_TERRAIN_SAMPLE_STEP = 0.25;
+function densifyClosedWallPerimeter(points) {
+    const dense = [];
+    for (let index = 0; index < points.length; index += 1) {
+        const start = points[index];
+        const end = points[(index + 1) % points.length];
+        const length = Math.hypot(end.x - start.x, end.y - start.y);
+        const segments = Math.max(1, Math.ceil(length / WALL_TERRAIN_SAMPLE_STEP));
+        for (let segment = 0; segment < segments; segment += 1) {
+            const t = segment / segments;
+            dense.push({
+                x: start.x + (end.x - start.x) * t,
+                y: start.y + (end.y - start.y) * t,
+            });
+        }
+    }
+    return dense;
+}
+function buildWallTerrainFillGeometry(perimeter, worldToLocal, wallBaseElevation, terrainBottomAt) {
+    const worldPoints = densifyClosedWallPerimeter(perimeter);
+    if (worldPoints.length < 3)
+        return null;
+    const localPoints = worldPoints.map(worldToLocal);
+    const bottomY = worldPoints.map((point) => {
+        const terrainElevation = terrainBottomAt(point.x, point.y);
+        return terrainElevation == null ? 0 : Math.min(0, terrainElevation - wallBaseElevation);
+    });
+    return buildTerrainPerimeterFillGeometry(localPoints, bottomY, 0);
+}
+function mergeWallTerrainFill(body, fill, wall, boundaryEdges, effectiveWallHeight) {
+    if (!fill)
+        return body;
+    const bodyGeometry = body.index ? body.toNonIndexed() : body;
+    if (bodyGeometry !== body)
+        body.dispose();
+    ensureRenderableGeometryAttributes(bodyGeometry);
+    ensureRenderableGeometryAttributes(fill);
+    const merged = mergeGeometries([bodyGeometry, fill], false);
+    if (!merged) {
+        fill.dispose();
+        return bodyGeometry;
+    }
+    bodyGeometry.dispose();
+    fill.dispose();
+    merged.computeVertexNormals();
+    assignWallMaterialGroups(merged, wall, boundaryEdges, effectiveWallHeight);
+    ensureRenderableGeometryAttributes(merged);
+    return merged;
+}
+export function generateExtrudedWall(wallNode, childrenNodes, miterData, slabElevation = 0, baseElevation = slabElevation, baseSegments = [
+    { start: 0, end: 1, elevation: baseElevation },
+], storeyHeight = DEFAULT_LEVEL_HEIGHT, terrainBottomAt) {
     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 topElevation = resolveWallTop(wallNode, storeyHeight, slabElevation);
+    const effectiveWallHeight = topElevation - slabElevation;
+    const effectiveBaseElevation = Math.min(baseElevation, slabElevation);
+    const localBottom = effectiveBaseElevation - slabElevation;
+    const height = topElevation - effectiveBaseElevation;
+    // A slab at or above the storey plane leaves a plane-bound wall with no
+    // body — bail before ExtrudeGeometry sees a non-positive depth.
+    if (height <= 1e-9) {
+        return new THREE.BufferGeometry();
+    }
     const thickness = getWallThickness(wallNode);
     // Wall direction and normal (exactly like demo)
     const v = { x: wallEnd.x - wallStart.x, y: wallEnd.y - wallStart.y };
@@ -493,6 +737,9 @@ export function generateExtrudedWall(wallNode, childrenNodes, miterData, slabEle
     // Convert polygon to local coordinates
     const localPoints = polyPoints.map(worldToLocal);
     const boundaryEdges = buildTaggedWallBoundaryEdges(wallNode, localPoints, miterData);
+    const terrainFill = terrainBottomAt
+        ? buildWallTerrainFillGeometry(polyPoints, worldToLocal, slabElevation, terrainBottomAt)
+        : null;
     // 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
@@ -509,24 +756,118 @@ export function generateExtrudedWall(wallNode, childrenNodes, miterData, slabEle
     });
     // Rotate so extrusion direction (Z) becomes height direction (Y)
     geometry.rotateX(-Math.PI / 2);
+    if (Math.abs(localBottom) > 1e-9)
+        geometry.translate(0, localBottom, 0);
     geometry.computeVertexNormals();
-    assignWallMaterialGroups(geometry, wallNode, boundaryEdges);
-    ensureUv2Attribute(geometry);
-    // Apply CSG subtraction for cutouts (doors/windows)
-    const cutoutBrushes = collectCutoutBrushes(wallNode, childrenNodes, thickness);
+    assignWallMaterialGroups(geometry, wallNode, boundaryEdges, effectiveWallHeight);
+    ensureRenderableGeometryAttributes(geometry);
+    // Start with the lowest required wall prism, then remove the volume below
+    // each higher-supported run. This keeps the existing mitered footprint and
+    // opening CSG while giving one wall a stepped longitudinal base.
+    const baseProfileCutouts = [];
+    for (const segment of baseSegments) {
+        const segmentElevation = Math.min(segment.elevation, slabElevation);
+        const cutHeight = segmentElevation - effectiveBaseElevation;
+        if (cutHeight <= 1e-6 || segment.end - segment.start <= 1e-7)
+            continue;
+        const segmentStart = THREE.MathUtils.clamp(segment.start, 0, 1);
+        const segmentEnd = THREE.MathUtils.clamp(segment.end, 0, 1);
+        const cutHalfWidth = Math.max(thickness * 2, 0.2);
+        const worldCutoutPoints = [];
+        if (isCurvedWall(wallNode)) {
+            const sampleCount = Math.max(2, Math.ceil((segmentEnd - segmentStart) * 24));
+            const left = [];
+            const right = [];
+            for (let index = 0; index <= sampleCount; index++) {
+                const t = segmentStart + ((segmentEnd - segmentStart) * index) / sampleCount;
+                const frame = getWallCurveFrameAt(wallNode, t);
+                const endpointExtension = index === 0 && segmentStart <= 1e-7
+                    ? -cutHalfWidth
+                    : index === sampleCount && segmentEnd >= 1 - 1e-7
+                        ? cutHalfWidth
+                        : 0;
+                const center = {
+                    x: frame.point.x + frame.tangent.x * endpointExtension,
+                    y: frame.point.y + frame.tangent.y * endpointExtension,
+                };
+                left.push({
+                    x: center.x + frame.normal.x * cutHalfWidth,
+                    y: center.y + frame.normal.y * cutHalfWidth,
+                });
+                right.push({
+                    x: center.x - frame.normal.x * cutHalfWidth,
+                    y: center.y - frame.normal.y * cutHalfWidth,
+                });
+            }
+            worldCutoutPoints.push(...left, ...right.reverse());
+        }
+        else {
+            const tangentX = v.x / L;
+            const tangentY = v.y / L;
+            const normalX = -tangentY;
+            const normalY = tangentX;
+            const startExtension = segmentStart <= 1e-7 ? cutHalfWidth : 0;
+            const endExtension = segmentEnd >= 1 - 1e-7 ? cutHalfWidth : 0;
+            const startPoint = {
+                x: wallStart.x + tangentX * (segmentStart * L - startExtension),
+                y: wallStart.y + tangentY * (segmentStart * L - startExtension),
+            };
+            const endPoint = {
+                x: wallStart.x + tangentX * (segmentEnd * L + endExtension),
+                y: wallStart.y + tangentY * (segmentEnd * L + endExtension),
+            };
+            worldCutoutPoints.push({
+                x: startPoint.x + normalX * cutHalfWidth,
+                y: startPoint.y + normalY * cutHalfWidth,
+            }, { x: endPoint.x + normalX * cutHalfWidth, y: endPoint.y + normalY * cutHalfWidth }, { x: endPoint.x - normalX * cutHalfWidth, y: endPoint.y - normalY * cutHalfWidth }, {
+                x: startPoint.x - normalX * cutHalfWidth,
+                y: startPoint.y - normalY * cutHalfWidth,
+            });
+        }
+        const localCutoutPoints = worldCutoutPoints.map(worldToLocal);
+        if (localCutoutPoints.length < 3)
+            continue;
+        const cutoutShape = new THREE.Shape();
+        cutoutShape.moveTo(localCutoutPoints[0].x, -localCutoutPoints[0].z);
+        for (let index = 1; index < localCutoutPoints.length; index++) {
+            cutoutShape.lineTo(localCutoutPoints[index].x, -localCutoutPoints[index].z);
+        }
+        cutoutShape.closePath();
+        const cutoutBottom = localBottom - 0.01;
+        const cutoutTop = segmentElevation - slabElevation;
+        const cutoutGeometry = new THREE.ExtrudeGeometry(cutoutShape, {
+            depth: cutoutTop - cutoutBottom,
+            bevelEnabled: false,
+        });
+        cutoutGeometry.rotateX(-Math.PI / 2);
+        cutoutGeometry.translate(0, cutoutBottom, 0);
+        computeGeometryBoundsTree(cutoutGeometry);
+        baseProfileCutouts.push(new Brush(cutoutGeometry));
+    }
+    // Apply base-profile and opening cutouts in one CSG pass.
+    const cutoutBrushes = [
+        ...baseProfileCutouts,
+        ...collectCutoutBrushes(wallNode, childrenNodes, thickness),
+    ];
     if (cutoutBrushes.length === 0) {
-        return geometry;
+        const splitGeometry = splitGeometryAtHorizontalPlanes(geometry, getWallBandSplitPlanes(wallNode, effectiveWallHeight));
+        splitGeometry.computeVertexNormals();
+        assignWallMaterialGroups(splitGeometry, wallNode, boundaryEdges, effectiveWallHeight);
+        ensureRenderableGeometryAttributes(splitGeometry);
+        return mergeWallTerrainFill(splitGeometry, terrainFill, wallNode, boundaryEdges, effectiveWallHeight);
     }
     // Create wall brush from geometry
     // Pre-compute BVH with new API to avoid deprecation warning
+    ensureRenderableGeometryAttributes(geometry);
     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();
+        prepareBrushForCSG(cutoutBrush);
         const newResult = csgEvaluator.evaluate(resultBrush, cutoutBrush, SUBTRACTION);
+        prepareBrushForCSG(newResult);
         if (resultBrush !== wallBrush) {
             csgGeometry(resultBrush).dispose();
         }
@@ -538,14 +879,16 @@ export function generateExtrudedWall(wallNode, childrenNodes, miterData, slabEle
         csgGeometry(brush).dispose();
     }
     const resultGeometry = csgGeometry(resultBrush);
-    resultGeometry.computeVertexNormals();
-    assignWallMaterialGroups(resultGeometry, wallNode, boundaryEdges);
-    ensureUv2Attribute(resultGeometry);
-    return resultGeometry;
+    const splitResultGeometry = splitGeometryAtHorizontalPlanes(resultGeometry, getWallBandSplitPlanes(wallNode, effectiveWallHeight));
+    splitResultGeometry.computeVertexNormals();
+    assignWallMaterialGroups(splitResultGeometry, wallNode, boundaryEdges, effectiveWallHeight);
+    ensureRenderableGeometryAttributes(splitResultGeometry);
+    return mergeWallTerrainFill(splitResultGeometry, terrainFill, wallNode, boundaryEdges, effectiveWallHeight);
 }
 /**
- * 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
+ * Collects opening and item cutout brushes for CSG subtraction. Door/window
+ * cuts come directly from node geometry; item proxy meshes are transformed
+ * into wall-local boxes that pass through the wall.
  */
 function collectCutoutBrushes(wallNode, childrenNodes, wallThickness) {
     const brushes = [];
@@ -558,15 +901,8 @@ function collectCutoutBrushes(wallNode, childrenNodes, wallThickness) {
     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));
+        if (child.type === 'door' || child.type === 'window') {
+            brushes.push(createOpeningCutoutBrush(child, wallThickness));
             continue;
         }
         const childMesh = sceneRegistry.nodes.get(child.id);
@@ -609,132 +945,16 @@ function collectCutoutBrushes(wallNode, childrenNodes, wallThickness) {
     }
     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) {
+function createOpeningCutoutBrush(opening, wallThickness) {
     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();
+    const bottomPadding = getOpeningCutoutBottomPadding(opening, bottom);
+    const geometry = buildOpeningCutoutGeometry(opening, {
+        left: opening.position[0] - halfWidth,
+        right: opening.position[0] + halfWidth,
+        bottom: bottom - bottomPadding,
+        top: opening.position[1] + opening.height / 2,
+    }, wallThickness * 2, wallThickness);
+    computeGeometryBoundsTree(geometry);
+    return new Brush(geometry);
 }