@pascal-app/core 0.5.1 → 0.6.0

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

@@ -6,10 +6,202 @@ import { sceneRegistry } from '../../hooks/scene-registry/scene-registry';
 import { spatialGridManager } from '../../hooks/spatial-grid/spatial-grid-manager';
 import { resolveLevelId } from '../../hooks/spatial-grid/spatial-grid-sync';
 import useScene from '../../store/use-scene';
+import { getWallCurveFrameAt, getWallSurfacePolygon, isCurvedWall } from './wall-curve';
 import { DEFAULT_WALL_HEIGHT, getWallPlanFootprint, getWallThickness } from './wall-footprint';
-import { calculateLevelMiters, getAdjacentWallIds, } from './wall-mitering';
+import { calculateLevelMiters, getAdjacentWallIds, getWallMiterBoundaryPoints, pointToKey, } from './wall-mitering';
 // Reusable CSG evaluator for better performance
 const csgEvaluator = new Evaluator();
+const CURVED_WALL_3D_ENDPOINT_INSET = 0.0015;
+const WALL_FACE_NORMAL_Y_EPSILON = 0.6;
+const WALL_FACE_EDGE_DISTANCE_EPSILON = 0.003;
+function ensureUv2Attribute(geometry) {
+    const uv = geometry.getAttribute('uv');
+    if (!uv)
+        return;
+    geometry.setAttribute('uv2', new THREE.Float32BufferAttribute(Array.from(uv.array), 2));
+}
+function insetCurvedWallBoundaryPointsFor3D(wall, boundaryPoints, miterData) {
+    if (!boundaryPoints || !isCurvedWall(wall)) {
+        return boundaryPoints;
+    }
+    const insetDistance = Math.min(CURVED_WALL_3D_ENDPOINT_INSET, Math.max((wall.thickness ?? 0.1) * 0.01, 0.0005));
+    if (insetDistance <= 0) {
+        return boundaryPoints;
+    }
+    const next = { ...boundaryPoints };
+    const startJunction = miterData.junctions.get(pointToKey({ x: wall.start[0], y: wall.start[1] }));
+    const endJunction = miterData.junctions.get(pointToKey({ x: wall.end[0], y: wall.end[1] }));
+    if (startJunction && startJunction.connectedWalls.length > 1) {
+        const frame = getWallCurveFrameAt(wall, 0);
+        next.startLeft = {
+            x: next.startLeft.x + frame.tangent.x * insetDistance,
+            y: next.startLeft.y + frame.tangent.y * insetDistance,
+        };
+        next.startRight = {
+            x: next.startRight.x + frame.tangent.x * insetDistance,
+            y: next.startRight.y + frame.tangent.y * insetDistance,
+        };
+    }
+    if (endJunction && endJunction.connectedWalls.length > 1) {
+        const frame = getWallCurveFrameAt(wall, 1);
+        next.endLeft = {
+            x: next.endLeft.x - frame.tangent.x * insetDistance,
+            y: next.endLeft.y - frame.tangent.y * insetDistance,
+        };
+        next.endRight = {
+            x: next.endRight.x - frame.tangent.x * insetDistance,
+            y: next.endRight.y - frame.tangent.y * insetDistance,
+        };
+    }
+    return next;
+}
+function addTaggedWallBoundaryEdge(edges, points, startIndex, endIndex, tag) {
+    const start = points[startIndex];
+    const end = points[endIndex];
+    if (!(start && end))
+        return;
+    if (Math.hypot(end.x - start.x, end.z - start.z) < 1e-6)
+        return;
+    edges.push({
+        start: new THREE.Vector2(start.x, start.z),
+        end: new THREE.Vector2(end.x, end.z),
+        tag,
+    });
+}
+function buildTaggedWallBoundaryEdges(wall, localPoints, miterData) {
+    if (localPoints.length < 2)
+        return [];
+    const edges = [];
+    if (isCurvedWall(wall)) {
+        const sidePointCount = Math.floor(localPoints.length / 2);
+        if (sidePointCount < 2)
+            return edges;
+        for (let index = 0; index < sidePointCount - 1; index += 1) {
+            addTaggedWallBoundaryEdge(edges, localPoints, index, index + 1, 'back');
+        }
+        addTaggedWallBoundaryEdge(edges, localPoints, sidePointCount - 1, sidePointCount, 'base');
+        for (let index = sidePointCount; index < localPoints.length - 1; index += 1) {
+            addTaggedWallBoundaryEdge(edges, localPoints, index, index + 1, 'front');
+        }
+        addTaggedWallBoundaryEdge(edges, localPoints, localPoints.length - 1, 0, 'base');
+        return edges;
+    }
+    const startKey = pointToKey({ x: wall.start[0], y: wall.start[1] });
+    const startJunction = miterData.junctionData.get(startKey)?.get(wall.id);
+    const startLeftIndex = startJunction ? localPoints.length - 2 : localPoints.length - 1;
+    const endLeftIndex = startJunction ? localPoints.length - 3 : localPoints.length - 2;
+    addTaggedWallBoundaryEdge(edges, localPoints, 0, 1, 'back');
+    for (let index = 1; index < endLeftIndex; index += 1) {
+        addTaggedWallBoundaryEdge(edges, localPoints, index, index + 1, 'base');
+    }
+    addTaggedWallBoundaryEdge(edges, localPoints, endLeftIndex, startLeftIndex, 'front');
+    for (let index = startLeftIndex; index < localPoints.length - 1; index += 1) {
+        addTaggedWallBoundaryEdge(edges, localPoints, index, index + 1, 'base');
+    }
+    addTaggedWallBoundaryEdge(edges, localPoints, localPoints.length - 1, 0, 'base');
+    return edges;
+}
+function distanceToWallBoundaryEdge(point, edge) {
+    const edgeDx = edge.end.x - edge.start.x;
+    const edgeDz = edge.end.y - edge.start.y;
+    const pointDx = point.x - edge.start.x;
+    const pointDz = point.y - edge.start.y;
+    const edgeLengthSq = edgeDx * edgeDx + edgeDz * edgeDz;
+    if (edgeLengthSq < 1e-12) {
+        return point.distanceTo(edge.start);
+    }
+    const t = THREE.MathUtils.clamp((pointDx * edgeDx + pointDz * edgeDz) / edgeLengthSq, 0, 1);
+    const closestX = edge.start.x + edgeDx * t;
+    const closestZ = edge.start.y + edgeDz * t;
+    return Math.hypot(point.x - closestX, point.y - closestZ);
+}
+function getWallFaceMaterialIndex(wall, face) {
+    const semantic = face === 'front' ? wall.frontSide : wall.backSide;
+    const fallback = face === 'front' ? 1 : 2;
+    if (semantic === 'interior')
+        return 1;
+    if (semantic === 'exterior')
+        return 2;
+    return fallback;
+}
+function assignWallMaterialGroups(geometry, wall, boundaryEdges) {
+    const position = geometry.getAttribute('position');
+    if (!position)
+        return;
+    const index = geometry.getIndex();
+    const triangleCount = index ? Math.floor(index.count / 3) : Math.floor(position.count / 3);
+    if (triangleCount === 0) {
+        geometry.clearGroups();
+        return;
+    }
+    const triangleMaterials = new Array(triangleCount).fill(0);
+    const a = new THREE.Vector3();
+    const b = new THREE.Vector3();
+    const c = new THREE.Vector3();
+    const ab = new THREE.Vector3();
+    const ac = new THREE.Vector3();
+    const normal = new THREE.Vector3();
+    const centroid = new THREE.Vector3();
+    const projectedCentroid = new THREE.Vector2();
+    const maxBoundaryDistance = Math.max(getWallThickness(wall) * 0.02, WALL_FACE_EDGE_DISTANCE_EPSILON);
+    for (let triangleIndex = 0; triangleIndex < triangleCount; triangleIndex += 1) {
+        const baseIndex = triangleIndex * 3;
+        const ia = index ? index.getX(baseIndex) : baseIndex;
+        const ib = index ? index.getX(baseIndex + 1) : baseIndex + 1;
+        const ic = index ? index.getX(baseIndex + 2) : baseIndex + 2;
+        a.fromBufferAttribute(position, ia);
+        b.fromBufferAttribute(position, ib);
+        c.fromBufferAttribute(position, ic);
+        ab.subVectors(b, a);
+        ac.subVectors(c, a);
+        normal.crossVectors(ab, ac);
+        if (normal.lengthSq() < 1e-12) {
+            triangleMaterials[triangleIndex] = 0;
+            continue;
+        }
+        normal.normalize();
+        if (Math.abs(normal.y) >= WALL_FACE_NORMAL_Y_EPSILON) {
+            triangleMaterials[triangleIndex] = 0;
+            continue;
+        }
+        centroid
+            .copy(a)
+            .add(b)
+            .add(c)
+            .multiplyScalar(1 / 3);
+        projectedCentroid.set(centroid.x, centroid.z);
+        let nearestTag = null;
+        let nearestDistance = Number.POSITIVE_INFINITY;
+        for (const edge of boundaryEdges) {
+            const distance = distanceToWallBoundaryEdge(projectedCentroid, edge);
+            if (distance < nearestDistance) {
+                nearestDistance = distance;
+                nearestTag = edge.tag;
+            }
+        }
+        if (!nearestTag || nearestDistance > maxBoundaryDistance) {
+            triangleMaterials[triangleIndex] = 0;
+            continue;
+        }
+        if (nearestTag === 'base') {
+            triangleMaterials[triangleIndex] = 0;
+            continue;
+        }
+        triangleMaterials[triangleIndex] = getWallFaceMaterialIndex(wall, nearestTag);
+    }
+    geometry.clearGroups();
+    let currentMaterial = triangleMaterials[0] ?? 0;
+    let groupStart = 0;
+    for (let triangleIndex = 1; triangleIndex < triangleCount; triangleIndex += 1) {
+        const materialIndex = triangleMaterials[triangleIndex] ?? 0;
+        if (materialIndex === currentMaterial)
+            continue;
+        geometry.addGroup(groupStart * 3, (triangleIndex - groupStart) * 3, currentMaterial);
+        groupStart = triangleIndex;
+        currentMaterial = materialIndex;
+    }
+    geometry.addGroup(groupStart * 3, (triangleCount - groupStart) * 3, currentMaterial);
+}
 // ============================================================================
 // WALL SYSTEM
 // ============================================================================
@@ -131,7 +323,10 @@ export function generateExtrudedWall(wallNode, childrenNodes, miterData, slabEle
     if (L < 1e-9) {
         return new THREE.BufferGeometry();
     }
-    const polyPoints = getWallPlanFootprint(wallNode, miterData);
+    const boundaryPoints = getWallMiterBoundaryPoints(wallNode, miterData);
+    const polyPoints = isCurvedWall(wallNode)
+        ? getWallSurfacePolygon(wallNode, 24, insetCurvedWallBoundaryPointsFor3D(wallNode, boundaryPoints, miterData) ?? undefined)
+        : getWallPlanFootprint(wallNode, miterData);
     if (polyPoints.length < 3) {
         return new THREE.BufferGeometry();
     }
@@ -150,6 +345,7 @@ export function generateExtrudedWall(wallNode, childrenNodes, miterData, slabEle
     };
     // Convert polygon to local coordinates
     const localPoints = polyPoints.map(worldToLocal);
+    const boundaryEdges = buildTaggedWallBoundaryEdges(wallNode, localPoints, miterData);
     // Build THREE.js shape
     // Shape uses (x, y) where we map: shape.x = local.x, shape.y = -local.z
     // The negation is needed because after rotateX(-PI/2), shape.y becomes -geometry.z
@@ -167,6 +363,8 @@ export function generateExtrudedWall(wallNode, childrenNodes, miterData, slabEle
     // Rotate so extrusion direction (Z) becomes height direction (Y)
     geometry.rotateX(-Math.PI / 2);
     geometry.computeVertexNormals();
+    assignWallMaterialGroups(geometry, wallNode, boundaryEdges);
+    ensureUv2Attribute(geometry);
     // Apply CSG subtraction for cutouts (doors/windows)
     const cutoutBrushes = collectCutoutBrushes(wallNode, childrenNodes, thickness);
     if (cutoutBrushes.length === 0) {
@@ -195,6 +393,8 @@ export function generateExtrudedWall(wallNode, childrenNodes, miterData, slabEle
     }
     const resultGeometry = resultBrush.geometry;
     resultGeometry.computeVertexNormals();
+    assignWallMaterialGroups(resultGeometry, wallNode, boundaryEdges);
+    ensureUv2Attribute(resultGeometry);
     return resultGeometry;
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pascal-app/core",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "Core library for Pascal 3D building editor",
   "type": "module",
   "main": "./dist/index.js",
@@ -30,7 +30,7 @@
     "@react-three/drei": "^10",
     "@react-three/fiber": "^9",
     "react": "^18 || ^19",
-    "three": "^0.182"
+    "three": "^0.184"
   },
   "dependencies": {
     "dedent": "^1.7.1",
@@ -47,7 +47,7 @@
     "@pascal/typescript-config": "*",
     "@types/react": "^19.2.2",
     "typescript": "5.9.3",
-    "@types/three": "^0.183.0"
+    "@types/three": "^0.184.0"
   },
   "keywords": [
     "3d",