@pascal-app/core 0.1.13 → 0.3.0

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

@@ -1,254 +1,749 @@
 import { useFrame } from '@react-three/fiber';
 import * as THREE from 'three';
+import { mergeVertices } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+import { ADDITION, Brush, Evaluator, SUBTRACTION } from 'three-bvh-csg';
+import { computeBoundsTree } from 'three-mesh-bvh';
 import { sceneRegistry } from '../../hooks/scene-registry/scene-registry';
 import useScene from '../../store/use-scene';
-// ============================================================================
-// ROOF GEOMETRY CONSTANTS
-// ============================================================================
-const THICKNESS_A = 0.05; // Roof cover thickness (5cm)
-const THICKNESS_B = 0.1; // Structure thickness (10cm)
-const ROOF_COVER_OVERHANG = 0.05; // Extension of cover past structure (5cm)
-const EAVE_OVERHANG = 0.4; // Horizontal eave overhang (40cm)
-const RAKE_OVERHANG = 0.3; // Overhang at gable ends (30cm)
-const WALL_THICKNESS = 0.2; // Gable wall thickness (20cm)
-const BASE_HEIGHT = 0.5; // Base height / knee wall / truss heel (50cm)
+const csgEvaluator = new Evaluator();
+csgEvaluator.useGroups = true;
+csgEvaluator.attributes = ['position', 'normal'];
+// Pooled objects to avoid per-frame allocation in updateMergedRoofGeometry
+const _matrix = new THREE.Matrix4();
+const _position = new THREE.Vector3();
+const _quaternion = new THREE.Quaternion();
+const _scale = new THREE.Vector3(1, 1, 1);
+const _yAxis = new THREE.Vector3(0, 1, 0);
+// Pending merged-roof updates carried across frames (for throttling)
+const pendingRoofUpdates = new Set();
+const MAX_ROOFS_PER_FRAME = 1;
+const MAX_SEGMENTS_PER_FRAME = 3;
 // ============================================================================
 // ROOF SYSTEM
 // ============================================================================
 export const RoofSystem = () => {
     const dirtyNodes = useScene((state) => state.dirtyNodes);
     const clearDirty = useScene((state) => state.clearDirty);
+    const rootNodeIds = useScene((state) => state.rootNodeIds);
     useFrame(() => {
-        if (dirtyNodes.size === 0)
+        // Clear stale pending updates when the scene is unloaded
+        if (rootNodeIds.length === 0) {
+            pendingRoofUpdates.clear();
+            return;
+        }
+        if (dirtyNodes.size === 0 && pendingRoofUpdates.size === 0)
             return;
         const nodes = useScene.getState().nodes;
-        // Process dirty roofs
+        // --- Pass 1: Process dirty roof-segments (throttled) ---
+        let segmentsProcessed = 0;
         dirtyNodes.forEach((id) => {
             const node = nodes[id];
-            if (!node || node.type !== 'roof')
+            if (!node)
                 return;
-            const mesh = sceneRegistry.nodes.get(id);
-            if (mesh) {
-                updateRoofGeometry(node, mesh);
+            if (node.type === 'roof-segment') {
+                const mesh = sceneRegistry.nodes.get(id);
+                if (mesh) {
+                    // Only compute expensive individual CSG when the segment is actually rendered
+                    // (its parent group is visible = the roof is selected for editing)
+                    const isVisible = mesh.parent?.visible !== false;
+                    if (isVisible && segmentsProcessed < MAX_SEGMENTS_PER_FRAME) {
+                        updateRoofSegmentGeometry(node, mesh);
+                        segmentsProcessed++;
+                    }
+                    else if (isVisible) {
+                        return; // Over budget — keep dirty, process next frame
+                    }
+                    else {
+                        // Just sync transform, skip CSG — the merged roof handles visuals.
+                        // But replace the initial BoxGeometry once: it has 6 groups (materialIndex 0-5)
+                        // while roofMaterials only has 4 entries. Three.js raycasts into invisible groups,
+                        // so MeshBVH hits groups[4].materialIndex → undefined.side → crash.
+                        if (mesh.geometry.type === 'BoxGeometry') {
+                            mesh.geometry.dispose();
+                            const placeholder = new THREE.BufferGeometry();
+                            placeholder.setAttribute('position', new THREE.Float32BufferAttribute([], 3));
+                            placeholder.computeBoundsTree = computeBoundsTree;
+                            placeholder.computeBoundsTree({ maxLeafSize: 10 });
+                            mesh.geometry = placeholder;
+                        }
+                        mesh.position.set(node.position[0], node.position[1], node.position[2]);
+                        mesh.rotation.y = node.rotation;
+                    }
+                    clearDirty(id);
+                }
+                // Queue the parent roof for a merged geometry update
+                if (node.parentId) {
+                    pendingRoofUpdates.add(node.parentId);
+                }
+            }
+            else if (node.type === 'roof') {
+                pendingRoofUpdates.add(id);
                 clearDirty(id);
             }
-            // If mesh not found, keep it dirty for next frame
         });
-    });
+        // --- Pass 2: Process pending merged-roof updates (max 1 per frame) ---
+        let roofsProcessed = 0;
+        for (const id of pendingRoofUpdates) {
+            if (roofsProcessed >= MAX_ROOFS_PER_FRAME)
+                break;
+            const node = nodes[id];
+            if (!node || node.type !== 'roof') {
+                pendingRoofUpdates.delete(id);
+                continue;
+            }
+            const group = sceneRegistry.nodes.get(id);
+            if (group) {
+                const mergedMesh = group.getObjectByName('merged-roof');
+                if (mergedMesh?.visible !== false) {
+                    // Only rebuild when visible — RoofEditSystem re-triggers via markDirty on edit mode exit
+                    updateMergedRoofGeometry(node, group, nodes);
+                    roofsProcessed++;
+                }
+            }
+            pendingRoofUpdates.delete(id);
+        }
+    }, 5); // Priority 5: run after all other systems have settled
     return null;
 };
-/**
- * Updates the geometry and transform for a single roof
- */
-function updateRoofGeometry(node, mesh) {
-    const newGeo = generateRoofGeometry(node);
+// ============================================================================
+// GEOMETRY GENERATION
+// ============================================================================
+function updateRoofSegmentGeometry(node, mesh) {
+    const newGeo = generateRoofSegmentGeometry(node);
     mesh.geometry.dispose();
     mesh.geometry = newGeo;
-    // Update position and rotation
+    newGeo.computeBoundsTree = computeBoundsTree;
+    newGeo.computeBoundsTree({ maxLeafSize: 10 });
     mesh.position.set(node.position[0], node.position[1], node.position[2]);
     mesh.rotation.y = node.rotation;
 }
-/**
- * Helper to solve pitch angle analytically given rise, run and thicknesses
- * Solves: run * tan(a) + (ThickA + ThickB)/cos(a) = rise
- */
-function solvePitch(rise, run, thickA, thickB) {
-    const T = thickA + thickB;
-    if (run < 0.01)
-        return 0;
-    const R = Math.sqrt(run * run + rise * rise);
-    if (R <= T) {
-        return Math.atan2(rise, run) * 0.5; // Fallback
+function updateMergedRoofGeometry(roofNode, group, nodes) {
+    const mergedMesh = group.getObjectByName('merged-roof');
+    if (!mergedMesh)
+        return;
+    const children = (roofNode.children ?? [])
+        .map((id) => nodes[id])
+        .filter(Boolean);
+    if (children.length === 0) {
+        mergedMesh.geometry.dispose();
+        // Keep a valid position attribute so Drei's BVH can index safely.
+        mergedMesh.geometry = new THREE.BoxGeometry(0, 0, 0);
+        return;
+    }
+    let totalShinSlab = null;
+    let totalDeckSlab = null;
+    let totalWall = null;
+    let totalInner = null;
+    for (const child of children) {
+        const brushes = getRoofSegmentBrushes(child);
+        if (!brushes)
+            continue;
+        _matrix.compose(_position.set(child.position[0], child.position[1], child.position[2]), _quaternion.setFromAxisAngle(_yAxis, child.rotation), _scale);
+        const applyTransform = (brush) => {
+            brush.geometry.applyMatrix4(_matrix);
+            brush.updateMatrixWorld();
+        };
+        applyTransform(brushes.shinSlab);
+        applyTransform(brushes.deckSlab);
+        applyTransform(brushes.wallBrush);
+        applyTransform(brushes.innerBrush);
+        if (totalShinSlab) {
+            const next = csgEvaluator.evaluate(totalShinSlab, brushes.shinSlab, ADDITION);
+            totalShinSlab.geometry.dispose();
+            brushes.shinSlab.geometry.dispose();
+            totalShinSlab = next;
+        }
+        else {
+            totalShinSlab = brushes.shinSlab;
+        }
+        if (totalDeckSlab) {
+            const next = csgEvaluator.evaluate(totalDeckSlab, brushes.deckSlab, ADDITION);
+            totalDeckSlab.geometry.dispose();
+            brushes.deckSlab.geometry.dispose();
+            totalDeckSlab = next;
+        }
+        else {
+            totalDeckSlab = brushes.deckSlab;
+        }
+        if (totalWall) {
+            const next = csgEvaluator.evaluate(totalWall, brushes.wallBrush, ADDITION);
+            totalWall.geometry.dispose();
+            brushes.wallBrush.geometry.dispose();
+            totalWall = next;
+        }
+        else {
+            totalWall = brushes.wallBrush;
+        }
+        if (totalInner) {
+            const next = csgEvaluator.evaluate(totalInner, brushes.innerBrush, ADDITION);
+            totalInner.geometry.dispose();
+            brushes.innerBrush.geometry.dispose();
+            totalInner = next;
+        }
+        else {
+            totalInner = brushes.innerBrush;
+        }
+    }
+    if (totalShinSlab && totalDeckSlab && totalWall && totalInner) {
+        try {
+            const finalShinTrimmed = csgEvaluator.evaluate(totalShinSlab, totalInner, SUBTRACTION);
+            const finalDeckTrimmed = csgEvaluator.evaluate(totalDeckSlab, totalInner, SUBTRACTION);
+            const finalWallTrimmed = csgEvaluator.evaluate(totalWall, totalInner, SUBTRACTION);
+            const shinDeck = csgEvaluator.evaluate(finalShinTrimmed, finalDeckTrimmed, ADDITION);
+            const combined = csgEvaluator.evaluate(shinDeck, finalWallTrimmed, ADDITION);
+            const resultGeo = combined.geometry;
+            const resultMaterials = Array.isArray(combined.material)
+                ? combined.material
+                : [combined.material];
+            const matToIndex = new Map([
+                [dummyMats[0], 0],
+                [dummyMats[1], 1],
+                [dummyMats[2], 2],
+                [dummyMats[3], 3],
+            ]);
+            for (const g of resultGeo.groups) {
+                g.materialIndex = mapRoofGroupMaterialIndex(g.materialIndex, resultMaterials, matToIndex);
+            }
+            resultGeo.computeVertexNormals();
+            mergedMesh.geometry.dispose();
+            mergedMesh.geometry = resultGeo;
+            finalShinTrimmed.geometry.dispose();
+            finalDeckTrimmed.geometry.dispose();
+            finalWallTrimmed.geometry.dispose();
+            shinDeck.geometry.dispose();
+        }
+        catch (e) {
+            console.error('Merged roof CSG failed:', e);
+        }
+        totalShinSlab.geometry.dispose();
+        totalDeckSlab.geometry.dispose();
+        totalWall.geometry.dispose();
+        totalInner.geometry.dispose();
     }
-    const phi = Math.atan2(rise, run);
-    const shift = Math.asin(T / R);
-    return phi - shift;
 }
+const dummyMats = [
+    new THREE.MeshBasicMaterial(),
+    new THREE.MeshBasicMaterial(),
+    new THREE.MeshBasicMaterial(),
+    new THREE.MeshBasicMaterial(),
+];
+const ROOF_MATERIAL_SLOT_COUNT = 4;
+function mapRoofGroupMaterialIndex(groupMaterialIndex, csgMaterials, matToIndex) {
+    if (groupMaterialIndex === undefined)
+        return 0;
+    const sourceMaterial = csgMaterials[groupMaterialIndex];
+    const mappedIndex = sourceMaterial ? matToIndex.get(sourceMaterial) : undefined;
+    return mappedIndex ?? 0;
+}
+function normalizeRoofMaterialIndex(materialIndex) {
+    if (materialIndex === undefined || !Number.isFinite(materialIndex))
+        return 0;
+    const normalized = Math.trunc(materialIndex);
+    if (normalized < 0 || normalized >= ROOF_MATERIAL_SLOT_COUNT)
+        return 0;
+    return normalized;
+}
+const SHINGLE_SURFACE_EPSILON = 0.02;
+const RAKE_FACE_NORMAL_EPSILON = 0.3;
+const RAKE_FACE_ALIGNMENT_EPSILON = 0.35;
 /**
- * Helper to create a Three.js Shape from polygon points
+ * Generate complete hollow-shell geometry for a roof segment.
+ * Ports the prototype's CSG approach using three-bvh-csg.
  */
-function createShape(points) {
-    const shape = new THREE.Shape();
-    if (points.length === 0)
-        return shape;
-    const firstPoint = points[0];
-    if (!firstPoint)
-        return shape;
-    shape.moveTo(firstPoint.x, firstPoint.y);
-    for (let i = 1; i < points.length; i++) {
-        const point = points[i];
-        if (point) {
-            shape.lineTo(point.x, point.y);
-        }
-    }
-    shape.closePath();
-    return shape;
+export function getRoofSegmentBrushes(node) {
+    const { roofType, width, depth, wallHeight, roofHeight, wallThickness, deckThickness, overhang, shingleThickness, } = node;
+    const activeRh = roofType === 'flat' ? 0 : roofHeight;
+    let run = Math.min(width, depth) / 2;
+    let rise = activeRh;
+    if (roofType === 'shed') {
+        run = depth;
+    }
+    if (roofType === 'gable') {
+        run = depth / 2;
+    }
+    if (roofType === 'gambrel') {
+        run = depth / 4;
+        rise = activeRh * 0.6;
+    }
+    if (roofType === 'mansard') {
+        run = Math.min(width, depth) * 0.15;
+        rise = activeRh * 0.7;
+    }
+    if (roofType === 'dutch') {
+        run = Math.min(width, depth) * 0.25;
+        rise = activeRh * 0.5;
+    }
+    const tanTheta = run > 0 ? rise / run : 0;
+    const cosTheta = Math.cos(Math.atan2(rise, run)) || 1;
+    const sinTheta = Math.sin(Math.atan2(rise, run)) || 0;
+    const verticalRt = activeRh > 0 ? deckThickness / cosTheta : deckThickness;
+    const baseI = Math.min(width, depth) * 0.25;
+    const getVol = (wExt, vOffset, baseY, matIndex, isVoid) => {
+        const wV = Math.max(0.01, width + 2 * wExt);
+        const dV = Math.max(0.01, depth + 2 * wExt);
+        const autoDrop = wExt * tanTheta;
+        const whV = wallHeight - autoDrop + vOffset;
+        let rhV = activeRh;
+        if (activeRh > 0) {
+            rhV = activeRh + autoDrop;
+            if (roofType === 'shed')
+                rhV = activeRh + 2 * autoDrop;
+        }
+        const safeBaseY = Math.min(baseY, whV - 0.05);
+        let structuralI = baseI;
+        if (isVoid) {
+            structuralI += deckThickness;
+        }
+        const faces = getModuleFaces(roofType, wV, dV, whV, rhV, safeBaseY, { dutchI: structuralI }, width, depth, tanTheta);
+        return createGeometryFromFaces(faces, matIndex);
+    };
+    const wallGeo = getVol(wallThickness / 2, 0, 0, 0, false);
+    const innerGeo = getVol(-wallThickness / 2, 0, -5, 2, false);
+    const horizontalOverhang = overhang * cosTheta;
+    const deckExt = wallThickness / 2 + horizontalOverhang;
+    const deckTopGeo = getVol(deckExt, verticalRt, 0, 1, false);
+    const deckBotGeo = getVol(deckExt, 0, -5, 0, true);
+    const stSin = shingleThickness * sinTheta;
+    const stCos = shingleThickness * cosTheta;
+    const shinBotW = Math.max(0.01, width + 2 * deckExt);
+    const shinBotD = Math.max(0.01, depth + 2 * deckExt);
+    const deckDrop = deckExt * tanTheta;
+    const shinBotWh = wallHeight - deckDrop + verticalRt;
+    let shinBotRh = activeRh;
+    if (activeRh > 0) {
+        shinBotRh = activeRh + deckDrop;
+        if (roofType === 'shed')
+            shinBotRh = activeRh + 2 * deckDrop;
+    }
+    let shinTopW = shinBotW;
+    let shinTopD = shinBotD;
+    let transZ = 0;
+    if (['hip', 'mansard', 'dutch'].includes(roofType)) {
+        shinTopW += 2 * stSin;
+        shinTopD += 2 * stSin;
+    }
+    else if (['gable', 'gambrel'].includes(roofType)) {
+        shinTopD += 2 * stSin;
+    }
+    else if (roofType === 'shed') {
+        shinTopD += stSin;
+        transZ = stSin / 2;
+    }
+    const shinTopWh = shinBotWh + stCos;
+    let shinTopRh = shinBotRh;
+    if (activeRh > 0) {
+        shinTopRh = shinBotRh + stSin * tanTheta;
+    }
+    const availableR = (Math.min(shinBotW, shinBotD) / 2) * 0.95;
+    const maxDrop = tanTheta > 0.001 ? availableR / tanTheta : 2.0;
+    const dropTop = Math.min(1.0, maxDrop * 0.4);
+    const dropBot = Math.min(2.0, maxDrop * 0.8);
+    const topBaseY = shinBotWh - dropTop;
+    const botBaseY = shinBotWh - dropBot;
+    const getInsets = (wh, bY, isVoid, brushW, brushD) => {
+        let inset = (wh - bY) * tanTheta;
+        const maxSafeInset = Math.min(brushW, brushD) / 2 - 0.005;
+        if (inset > maxSafeInset) {
+            inset = maxSafeInset;
+        }
+        let iF = 0, iB = 0, iL = 0, iR = 0;
+        if (['hip', 'mansard', 'dutch'].includes(roofType)) {
+            iF = inset;
+            iB = inset;
+            iL = inset;
+            iR = inset;
+        }
+        else if (['gable', 'gambrel'].includes(roofType)) {
+            iF = inset;
+            iB = inset;
+        }
+        else if (roofType === 'shed') {
+            iF = inset;
+        }
+        let structuralI = baseI;
+        if (isVoid) {
+            structuralI += shingleThickness;
+        }
+        return { iF, iB, iL, iR, dutchI: structuralI };
+    };
+    const insetsBot = getInsets(shinBotWh, botBaseY, true, shinBotW, shinBotD);
+    const insetsTop = getInsets(shinTopWh, topBaseY, false, shinTopW, shinTopD);
+    const botFaces = getModuleFaces(roofType, shinBotW, shinBotD, shinBotWh, shinBotRh, botBaseY, insetsBot, width, depth, tanTheta);
+    const topFaces = getModuleFaces(roofType, shinTopW, shinTopD, shinTopWh, shinTopRh, topBaseY, insetsTop, width, depth, tanTheta);
+    const shinBotGeo = createGeometryFromFaces(botFaces, 1);
+    const shinTopGeo = createGeometryFromFaces(topFaces, (normal) => normal.y > SHINGLE_SURFACE_EPSILON ? 3 : 1);
+    if (transZ !== 0) {
+        shinTopGeo.translate(0, 0, transZ);
+    }
+    const toBrush = (geo) => {
+        if (!geo?.attributes.position || geo.attributes.position.count === 0)
+            return null;
+        if (!geo.index)
+            return null;
+        geo.computeBoundsTree = computeBoundsTree;
+        geo.computeBoundsTree({ maxLeafSize: 10 });
+        const brush = new Brush(geo, dummyMats);
+        brush.updateMatrixWorld();
+        return brush;
+    };
+    const eps = 0.002;
+    const wallBrush = toBrush(wallGeo);
+    const innerBrush = toBrush(innerGeo);
+    if (innerBrush) {
+        const wV = Math.max(0.01, width - wallThickness);
+        const dV = Math.max(0.01, depth - wallThickness);
+        innerBrush.scale.set(1 + eps / wV, 1, 1 + eps / dV);
+        innerBrush.updateMatrixWorld();
+    }
+    const deckTopBrush = toBrush(deckTopGeo);
+    const deckBotBrush = toBrush(deckBotGeo);
+    if (deckBotBrush) {
+        const wV = Math.max(0.01, width + 2 * deckExt);
+        const dV = Math.max(0.01, depth + 2 * deckExt);
+        deckBotBrush.scale.set(1 + eps / wV, 1, 1 + eps / dV);
+        deckBotBrush.updateMatrixWorld();
+    }
+    const shinTopBrush = toBrush(shinTopGeo);
+    const shinBotBrush = toBrush(shinBotGeo);
+    if (shinBotBrush) {
+        const wV = shinBotW;
+        const dV = shinBotD;
+        shinBotBrush.scale.set(1 + eps / wV, 1, 1 + eps / dV);
+        shinBotBrush.updateMatrixWorld();
+    }
+    wallGeo.dispose();
+    innerGeo.dispose();
+    deckTopGeo.dispose();
+    deckBotGeo.dispose();
+    shinTopGeo.dispose();
+    shinBotGeo.dispose();
+    if (deckTopBrush && deckBotBrush && wallBrush && innerBrush && shinTopBrush && shinBotBrush) {
+        try {
+            const deckSlab = csgEvaluator.evaluate(deckTopBrush, deckBotBrush, SUBTRACTION);
+            const shinSlab = csgEvaluator.evaluate(shinTopBrush, shinBotBrush, SUBTRACTION);
+            deckTopBrush.geometry.dispose();
+            deckBotBrush.geometry.dispose();
+            shinTopBrush.geometry.dispose();
+            shinBotBrush.geometry.dispose();
+            return { deckSlab, shinSlab, wallBrush, innerBrush };
+        }
+        catch (e) {
+            console.error('CSG prep failed:', e);
+        }
+    }
+    if (deckTopBrush)
+        deckTopBrush.geometry.dispose();
+    if (deckBotBrush)
+        deckBotBrush.geometry.dispose();
+    if (shinTopBrush)
+        shinTopBrush.geometry.dispose();
+    if (shinBotBrush)
+        shinBotBrush.geometry.dispose();
+    if (wallBrush)
+        wallBrush.geometry.dispose();
+    if (innerBrush)
+        innerBrush.geometry.dispose();
+    return null;
+}
+export function generateRoofSegmentGeometry(node) {
+    const brushes = getRoofSegmentBrushes(node);
+    if (!brushes) {
+        // Fallback: simple box
+        return new THREE.BoxGeometry(node.width, node.wallHeight, node.depth);
+    }
+    const { deckSlab, shinSlab, wallBrush, innerBrush } = brushes;
+    let resultGeo = new THREE.BufferGeometry();
+    try {
+        const hollowWall = csgEvaluator.evaluate(wallBrush, innerBrush, SUBTRACTION);
+        const shinDeck = csgEvaluator.evaluate(shinSlab, deckSlab, ADDITION);
+        const combined = csgEvaluator.evaluate(shinDeck, hollowWall, ADDITION);
+        resultGeo = combined.geometry;
+        const resultMaterials = Array.isArray(combined.material)
+            ? combined.material
+            : [combined.material];
+        const matToIndex = new Map([
+            [dummyMats[0], 0],
+            [dummyMats[1], 1],
+            [dummyMats[2], 2],
+            [dummyMats[3], 3],
+        ]);
+        for (const group of resultGeo.groups) {
+            group.materialIndex = mapRoofGroupMaterialIndex(group.materialIndex, resultMaterials, matToIndex);
+        }
+        remapRoofShellFaces(resultGeo, node);
+        hollowWall.geometry.dispose();
+        shinDeck.geometry.dispose();
+    }
+    catch (e) {
+        console.error('Roof CSG failed:', e);
+        resultGeo = wallBrush.geometry.clone();
+    }
+    deckSlab.geometry.dispose();
+    shinSlab.geometry.dispose();
+    wallBrush.geometry.dispose();
+    innerBrush.geometry.dispose();
+    resultGeo.computeVertexNormals();
+    return resultGeo;
+}
+function remapRoofShellFaces(geometry, node) {
+    const position = geometry.getAttribute('position');
+    const index = geometry.getIndex();
+    if (!(position && index) || index.count === 0 || geometry.groups.length === 0)
+        return;
+    geometry.computeBoundingBox();
+    const triangleCount = index.count / 3;
+    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 centroid = new THREE.Vector3();
+    const normal = new THREE.Vector3();
+    for (const group of geometry.groups) {
+        const startTriangle = Math.floor(group.start / 3);
+        const endTriangle = Math.min(triangleCount, Math.floor((group.start + group.count) / 3));
+        for (let triangleIndex = startTriangle; triangleIndex < endTriangle; triangleIndex++) {
+            const indexOffset = triangleIndex * 3;
+            let materialIndex = normalizeRoofMaterialIndex(group.materialIndex);
+            if (materialIndex === 1 || materialIndex === 3) {
+                const ia = index.getX(indexOffset);
+                const ib = index.getX(indexOffset + 1);
+                const ic = index.getX(indexOffset + 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).normalize();
+                centroid
+                    .copy(a)
+                    .add(b)
+                    .add(c)
+                    .multiplyScalar(1 / 3);
+                if (normal.y > SHINGLE_SURFACE_EPSILON) {
+                    materialIndex = 3;
+                }
+                else if (isRakeFace(node, geometry, centroid, normal)) {
+                    materialIndex = 0;
+                }
+                else {
+                    materialIndex = 1;
+                }
+            }
+            triangleMaterials[triangleIndex] = materialIndex;
+        }
+    }
+    geometry.clearGroups();
+    let currentMaterial = triangleMaterials[0] ?? 0;
+    let groupStart = 0;
+    for (let triangleIndex = 1; triangleIndex < triangleCount; triangleIndex++) {
+        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);
+}
+function isRakeFace(node, geometry, centroid, normal) {
+    const rakeAxis = getRakeAxis(node);
+    const bounds = geometry.boundingBox;
+    if (!(rakeAxis && bounds))
+        return false;
+    if (Math.abs(normal.y) > RAKE_FACE_NORMAL_EPSILON)
+        return false;
+    const axisNormal = rakeAxis === 'x' ? Math.abs(normal.x) : Math.abs(normal.z);
+    if (axisNormal < RAKE_FACE_ALIGNMENT_EPSILON)
+        return false;
+    const halfExtent = rakeAxis === 'x'
+        ? Math.max(Math.abs(bounds.min.x), Math.abs(bounds.max.x))
+        : Math.max(Math.abs(bounds.min.z), Math.abs(bounds.max.z));
+    const axisCoord = rakeAxis === 'x' ? Math.abs(centroid.x) : Math.abs(centroid.z);
+    const planeTolerance = Math.max(node.overhang + node.wallThickness + node.deckThickness + node.shingleThickness, 0.25);
+    if (halfExtent - axisCoord > planeTolerance)
+        return false;
+    return true;
+}
+function getRakeAxis(node) {
+    if (node.roofType === 'gable' || node.roofType === 'gambrel')
+        return 'x';
+    if (node.roofType === 'dutch')
+        return node.width >= node.depth ? 'x' : 'z';
+    return null;
 }
 /**
- * Generate profile for one side of the roof (left or right)
+ * Generates faces for a roof module volume.
+ * Supports: hip, gable, shed, gambrel, dutch, mansard, flat.
  */
-function getSideProfile(dir, width, roofHeight) {
-    const halfWall = WALL_THICKNESS / 2;
-    const rise = Math.max(0, roofHeight - BASE_HEIGHT);
-    const run = width - halfWall;
-    const angle = solvePitch(rise, run, THICKNESS_A, THICKNESS_B);
-    const tanA = Math.tan(angle);
-    const cosA = Math.cos(angle);
-    const sinA = Math.sin(angle);
-    const ridgeUnderY = BASE_HEIGHT + run * tanA;
-    const ridgeInterfaceY = ridgeUnderY + THICKNESS_B / cosA;
-    const ridgeTopY = ridgeInterfaceY + THICKNESS_A / cosA;
-    const wallOuterTopY = BASE_HEIGHT - WALL_THICKNESS * tanA;
-    const overhangDx = EAVE_OVERHANG * cosA;
-    const eaveTopZ = width + halfWall + overhangDx;
-    const eaveTopY = ridgeTopY - eaveTopZ * tanA;
-    const coverExtDx = ROOF_COVER_OVERHANG * cosA;
-    const coverExtDy = ROOF_COVER_OVERHANG * sinA;
-    const eaveTopExtZ = eaveTopZ + coverExtDx;
-    const eaveTopExtY = eaveTopY - coverExtDy;
-    const eaveInterfaceExtZ = eaveTopExtZ - THICKNESS_A * sinA;
-    const eaveInterfaceExtY = eaveTopExtY - THICKNESS_A * cosA;
-    const eaveInterfaceZ = eaveTopZ;
-    const eaveBottomZ = eaveTopZ;
-    const eaveBottomY = ridgeUnderY - eaveTopZ * tanA;
-    // Layer A (Cover)
-    const pointsA = [
-        { x: 0, y: ridgeTopY },
-        { x: dir * eaveTopExtZ, y: eaveTopExtY },
-        { x: dir * eaveInterfaceExtZ, y: eaveInterfaceExtY },
-        { x: 0, y: ridgeInterfaceY },
-    ];
-    // Layer B (Structure)
-    const pointsB = [
-        { x: 0, y: ridgeInterfaceY },
-        { x: dir * eaveInterfaceZ, y: ridgeInterfaceY - eaveTopZ * tanA },
-        { x: dir * eaveBottomZ, y: eaveBottomY },
-        { x: 0, y: ridgeUnderY },
-    ];
-    // Side Wall
-    const zInner = width - halfWall;
-    const zOuter = width + halfWall;
-    const pointsSide = [
-        { x: dir * zInner, y: 0 },
-        { x: dir * zOuter, y: 0 },
-        { x: dir * zOuter, y: Math.max(0, wallOuterTopY) },
-        { x: dir * zInner, y: BASE_HEIGHT },
-    ];
-    // Gable Top (C1)
-    const pointsC1 = [
-        { x: 0, y: BASE_HEIGHT },
-        { x: dir * zInner, y: BASE_HEIGHT },
-        { x: dir * zInner, y: BASE_HEIGHT },
-        { x: 0, y: ridgeUnderY },
-    ];
-    // Gable Base (C2)
-    const pointsC2 = [
-        { x: 0, y: 0 },
-        { x: dir * zInner, y: 0 },
-        { x: dir * zInner, y: BASE_HEIGHT },
-        { x: 0, y: BASE_HEIGHT },
-    ];
-    return { pointsA, pointsB, pointsSide, pointsC1, pointsC2 };
+function getModuleFaces(type, w, d, wh, rh, baseY, insets, baseW, baseD, tanTheta) {
+    const v = (x, y, z) => new THREE.Vector3(x, y, z);
+    const { iF = 0, iB = 0, iL = 0, iR = 0 } = insets;
+    const b1 = v(-w / 2 + iL, baseY, d / 2 - iF);
+    const b2 = v(w / 2 - iR, baseY, d / 2 - iF);
+    const b3 = v(w / 2 - iR, baseY, -d / 2 + iB);
+    const b4 = v(-w / 2 + iL, baseY, -d / 2 + iB);
+    const bottom = [b4, b3, b2, b1];
+    const e1 = v(-w / 2, wh, d / 2);
+    const e2 = v(w / 2, wh, d / 2);
+    const e3 = v(w / 2, wh, -d / 2);
+    const e4 = v(-w / 2, wh, -d / 2);
+    const faces = [];
+    faces.push([b1, b2, e2, e1], [b2, b3, e3, e2], [b3, b4, e4, e3], [b4, b1, e1, e4], bottom);
+    const h = wh + Math.max(0.001, rh);
+    if (type === 'flat' || rh === 0) {
+        faces.push([e1, e2, e3, e4]);
+    }
+    else if (type === 'gable') {
+        const r1 = v(-w / 2, h, 0);
+        const r2 = v(w / 2, h, 0);
+        faces.push([e4, e1, r1], [e2, e3, r2], [e1, e2, r2, r1], [e3, e4, r1, r2]);
+    }
+    else if (type === 'hip') {
+        if (Math.abs(w - d) < 0.01) {
+            const r = v(0, h, 0);
+            faces.push([e4, e1, r], [e1, e2, r], [e2, e3, r], [e3, e4, r]);
+        }
+        else if (w >= d) {
+            const r1 = v(-w / 2 + d / 2, h, 0);
+            const r2 = v(w / 2 - d / 2, h, 0);
+            faces.push([e4, e1, r1], [e2, e3, r2], [e1, e2, r2, r1], [e3, e4, r1, r2]);
+        }
+        else {
+            const r1 = v(0, h, d / 2 - w / 2);
+            const r2 = v(0, h, -d / 2 + w / 2);
+            faces.push([e1, e2, r1], [e3, e4, r2], [e2, e3, r2, r1], [e4, e1, r1, r2]);
+        }
+    }
+    else if (type === 'shed') {
+        const t1 = v(-w / 2, h, -d / 2);
+        const t2 = v(w / 2, h, -d / 2);
+        faces.push([e1, e2, t2, t1], [e2, e3, t2], [e3, e4, t1, t2], [e4, e1, t1]);
+    }
+    else if (type === 'gambrel') {
+        const mz = (baseD / 2) * 0.5;
+        const dist = d / 2 - mz;
+        const mh = wh + dist * (tanTheta || 0);
+        const m1 = v(-w / 2, mh, mz);
+        const m2 = v(w / 2, mh, mz);
+        const m3 = v(w / 2, mh, -mz);
+        const m4 = v(-w / 2, mh, -mz);
+        const r1 = v(-w / 2, h, 0);
+        const r2 = v(w / 2, h, 0);
+        faces.push([e4, e1, m1, r1, m4], [e2, e3, m3, r2, m2], [e1, e2, m2, m1], [m1, m2, r2, r1], [e3, e4, m4, m3], [m3, m4, r1, r2]);
+    }
+    else if (type === 'mansard') {
+        const i = Math.min(baseW, baseD) * 0.15;
+        const mh = wh + i * (tanTheta || 0);
+        const m1 = v(-w / 2 + i, mh, d / 2 - i);
+        const m2 = v(w / 2 - i, mh, d / 2 - i);
+        const m3 = v(w / 2 - i, mh, -d / 2 + i);
+        const m4 = v(-w / 2 + i, mh, -d / 2 + i);
+        const t1 = v(-w / 2 + i * 2, h, d / 2 - i * 2);
+        const t2 = v(w / 2 - i * 2, h, d / 2 - i * 2);
+        const t3 = v(w / 2 - i * 2, h, -d / 2 + i * 2);
+        const t4 = v(-w / 2 + i * 2, h, -d / 2 + i * 2);
+        if (w - i * 4 <= 0.01 || d - i * 4 <= 0.01) {
+            if (w >= d) {
+                const r1 = v(-w / 2 + d / 2, h, 0);
+                const r2 = v(w / 2 - d / 2, h, 0);
+                faces.push([e4, e1, r1], [e2, e3, r2], [e1, e2, r2, r1], [e3, e4, r1, r2]);
+            }
+            else {
+                const r1 = v(0, h, d / 2 - w / 2);
+                const r2 = v(0, h, -d / 2 + w / 2);
+                faces.push([e1, e2, r1], [e3, e4, r2], [e2, e3, r2, r1], [e4, e1, r1, r2]);
+            }
+        }
+        else {
+            faces.push([t1, t2, t3, t4], [e1, e2, m2, m1], [e2, e3, m3, m2], [e3, e4, m4, m3], [e4, e1, m1, m4], [m1, m2, t2, t1], [m2, m3, t3, t2], [m3, m4, t4, t3], [m4, m1, t1, t4]);
+        }
+    }
+    else if (type === 'dutch') {
+        const i = insets.dutchI !== undefined ? insets.dutchI : Math.min(baseW, baseD) * 0.25;
+        const mh = wh + i * (tanTheta || 0);
+        if (w >= d) {
+            const m1 = v(-w / 2 + i, mh, d / 2 - i);
+            const m2 = v(w / 2 - i, mh, d / 2 - i);
+            const m3 = v(w / 2 - i, mh, -d / 2 + i);
+            const m4 = v(-w / 2 + i, mh, -d / 2 + i);
+            const r1 = v(-w / 2 + i, h, 0);
+            const r2 = v(w / 2 - i, h, 0);
+            faces.push([e1, e2, m2, m1], [e2, e3, m3, m2], [e3, e4, m4, m3], [e4, e1, m1, m4], [m4, m1, r1], [m2, m3, r2], [m1, m2, r2, r1], [m3, m4, r1, r2]);
+        }
+        else {
+            const m1 = v(-w / 2 + i, mh, d / 2 - i);
+            const m2 = v(w / 2 - i, mh, d / 2 - i);
+            const m3 = v(w / 2 - i, mh, -d / 2 + i);
+            const m4 = v(-w / 2 + i, mh, -d / 2 + i);
+            const r1 = v(0, h, d / 2 - i);
+            const r2 = v(0, h, -d / 2 + i);
+            faces.push([e1, e2, m2, m1], [e2, e3, m3, m2], [e3, e4, m4, m3], [e4, e1, m1, m4], [m1, m2, r1], [m3, m4, r2], [m2, m3, r2, r1], [m4, m1, r1, r2]);
+        }
+    }
+    return faces;
 }
 /**
- * Generates detailed gable roof geometry with layers, walls, and overhangs
+ * Converts an array of face polygons into a BufferGeometry.
+ * Each face is triangulated via fan triangulation.
  */
-export function generateRoofGeometry(roofNode) {
-    const { length, height, leftWidth, rightWidth } = roofNode;
-    const ridgeLength = length;
-    // Get profiles for both sides
-    const leftP = getSideProfile(1, leftWidth, height);
-    const rightP = getSideProfile(-1, rightWidth, height);
-    // Create shapes from profiles
-    const shapes = {
-        ALeft: createShape(leftP.pointsA),
-        ARight: createShape(rightP.pointsA),
-        BLeft: createShape(leftP.pointsB),
-        BRight: createShape(rightP.pointsB),
-        SideLeft: createShape(leftP.pointsSide),
-        SideRight: createShape(rightP.pointsSide),
-        C1Left: createShape(leftP.pointsC1),
-        C1Right: createShape(rightP.pointsC1),
-        C2Left: createShape(leftP.pointsC2),
-        C2Right: createShape(rightP.pointsC2),
-    };
-    // Calculate extrusion lengths and offsets
-    const lengths = {
-        A: ridgeLength + 2 * RAKE_OVERHANG + 2 * ROOF_COVER_OVERHANG + WALL_THICKNESS,
-        B: ridgeLength + 2 * RAKE_OVERHANG + WALL_THICKNESS,
-        Side: ridgeLength + WALL_THICKNESS,
-        Gable: WALL_THICKNESS,
-    };
-    const offsets = {
-        A: -RAKE_OVERHANG - ROOF_COVER_OVERHANG - WALL_THICKNESS / 2,
-        B: -RAKE_OVERHANG - WALL_THICKNESS / 2,
-        Side: -WALL_THICKNESS / 2,
-        GableFront: -WALL_THICKNESS / 2,
-        GableBack: ridgeLength - WALL_THICKNESS / 2,
-    };
-    // Helper to create and position extruded geometry
-    const createPart = (shape, depth, xOffset) => {
-        const geo = new THREE.ExtrudeGeometry(shape, { depth, bevelEnabled: false });
-        // Rotate to align: extrusion goes along X axis
-        geo.rotateY(Math.PI / 2);
-        geo.translate(xOffset, 0, 0);
-        return geo;
-    };
-    // Create all parts
-    const geometries = [];
-    // Layer A (Cover) - both sides
-    geometries.push(createPart(shapes.ALeft, lengths.A, offsets.A));
-    geometries.push(createPart(shapes.ARight, lengths.A, offsets.A));
-    // Layer B (Structure) - both sides
-    geometries.push(createPart(shapes.BLeft, lengths.B, offsets.B));
-    geometries.push(createPart(shapes.BRight, lengths.B, offsets.B));
-    // Side Walls - both sides
-    geometries.push(createPart(shapes.SideLeft, lengths.Side, offsets.Side));
-    geometries.push(createPart(shapes.SideRight, lengths.Side, offsets.Side));
-    // Gable Walls (Front)
-    geometries.push(createPart(shapes.C1Left, lengths.Gable, offsets.GableFront));
-    geometries.push(createPart(shapes.C1Right, lengths.Gable, offsets.GableFront));
-    geometries.push(createPart(shapes.C2Left, lengths.Gable, offsets.GableFront));
-    geometries.push(createPart(shapes.C2Right, lengths.Gable, offsets.GableFront));
-    // Gable Walls (Back)
-    geometries.push(createPart(shapes.C1Left, lengths.Gable, offsets.GableBack));
-    geometries.push(createPart(shapes.C1Right, lengths.Gable, offsets.GableBack));
-    geometries.push(createPart(shapes.C2Left, lengths.Gable, offsets.GableBack));
-    geometries.push(createPart(shapes.C2Right, lengths.Gable, offsets.GableBack));
-    // Merge all geometries
-    const mergedGeometry = new THREE.BufferGeometry();
+function createGeometryFromFaces(faces, matRule = null) {
     const positions = [];
     const normals = [];
-    const uvs = [];
-    for (const geo of geometries) {
-        const posAttr = geo.getAttribute('position');
-        const normAttr = geo.getAttribute('normal');
-        const uvAttr = geo.getAttribute('uv');
-        if (posAttr) {
-            for (let i = 0; i < posAttr.count; i++) {
-                positions.push(posAttr.getX(i), posAttr.getY(i), posAttr.getZ(i));
-            }
+    const indices = [];
+    const groups = [];
+    let vertexCount = 0;
+    for (const face of faces) {
+        if (face.length < 3)
+            continue;
+        const p0 = face[0];
+        const p1 = face[1];
+        const p2 = face[2];
+        const vA = new THREE.Vector3().subVectors(p1, p0);
+        const vB = new THREE.Vector3().subVectors(p2, p0);
+        const normal = new THREE.Vector3().crossVectors(vA, vB).normalize();
+        let assignedMatIndex = 0;
+        if (typeof matRule === 'function') {
+            assignedMatIndex = matRule(normal);
         }
-        if (normAttr) {
-            for (let i = 0; i < normAttr.count; i++) {
-                normals.push(normAttr.getX(i), normAttr.getY(i), normAttr.getZ(i));
-            }
+        else if (matRule !== null && matRule !== undefined) {
+            assignedMatIndex = matRule;
         }
-        if (uvAttr) {
-            for (let i = 0; i < uvAttr.count; i++) {
-                uvs.push(uvAttr.getX(i), uvAttr.getY(i));
-            }
+        else {
+            const isVertical = Math.abs(normal.y) < 0.01;
+            assignedMatIndex = isVertical ? 0 : 1;
+        }
+        let faceVertexCount = 0;
+        const startVertexCount = vertexCount;
+        for (let i = 1; i < face.length - 1; i++) {
+            const fi = face[i];
+            const fi1 = face[i + 1];
+            positions.push(p0.x, p0.y, p0.z);
+            positions.push(fi.x, fi.y, fi.z);
+            positions.push(fi1.x, fi1.y, fi1.z);
+            normals.push(normal.x, normal.y, normal.z);
+            normals.push(normal.x, normal.y, normal.z);
+            normals.push(normal.x, normal.y, normal.z);
+            indices.push(vertexCount, vertexCount + 1, vertexCount + 2);
+            faceVertexCount += 3;
+            vertexCount += 3;
         }
-        geo.dispose();
+        groups.push({
+            start: startVertexCount,
+            count: faceVertexCount,
+            materialIndex: assignedMatIndex,
+        });
     }
-    mergedGeometry.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
-    mergedGeometry.setAttribute('normal', new THREE.Float32BufferAttribute(normals, 3));
-    if (uvs.length > 0) {
-        mergedGeometry.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
+    const geometry = new THREE.BufferGeometry();
+    geometry.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
+    geometry.setAttribute('normal', new THREE.Float32BufferAttribute(normals, 3));
+    geometry.setIndex(indices);
+    for (const g of groups) {
+        geometry.addGroup(g.start, g.count, g.materialIndex);
     }
-    mergedGeometry.computeVertexNormals();
-    // Center the geometry at X=0 (translate by -ridgeLength/2)
-    // This matches the old geometry centering behavior
-    mergedGeometry.translate(-ridgeLength / 2, 0, 0);
-    return mergedGeometry;
+    // Merge identical vertices to optimize geometry for CSG and create clean topology
+    const mergedGeo = mergeVertices(geometry, 1e-4);
+    geometry.dispose();
+    return mergedGeo;
 }