@pascal-app/core 0.5.0 → 0.6.0

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

@@ -0,0 +1,176 @@
+const CURVE_EPSILON = 1e-6;
+const DEFAULT_SAMPLE_SEGMENTS = 24;
+function clamp01(value) {
+    return Math.max(0, Math.min(1, value));
+}
+function lerp(a, b, t) {
+    return a + (b - a) * t;
+}
+function distance(a, b) {
+    return Math.hypot(b.x - a.x, b.y - a.y);
+}
+export function getWallStartPoint(wall) {
+    return { x: wall.start[0], y: wall.start[1] };
+}
+export function getWallEndPoint(wall) {
+    return { x: wall.end[0], y: wall.end[1] };
+}
+export function getWallChordLength(wall) {
+    return distance(getWallStartPoint(wall), getWallEndPoint(wall));
+}
+export function getMaxWallCurveOffset(wall) {
+    return getWallChordLength(wall) / 2;
+}
+export function getWallStraightSnapOffset(wall) {
+    return Math.min(0.03, Math.max(0.005, getWallChordLength(wall) * 0.005));
+}
+function clampCurveOffset(wall, offset) {
+    const maxOffset = getMaxWallCurveOffset(wall);
+    if (!Number.isFinite(maxOffset) || maxOffset < CURVE_EPSILON) {
+        return 0;
+    }
+    return Math.max(-maxOffset, Math.min(maxOffset, offset));
+}
+export function normalizeWallCurveOffset(wall, offset) {
+    const clamped = clampCurveOffset(wall, offset);
+    return Math.abs(clamped) <= getWallStraightSnapOffset(wall) ? 0 : clamped;
+}
+export function getClampedWallCurveOffset(wall) {
+    const value = wall.curveOffset ?? 0;
+    const normalized = normalizeWallCurveOffset(wall, value);
+    return Math.abs(normalized) > CURVE_EPSILON ? normalized : 0;
+}
+export function isCurvedWall(wall) {
+    return Math.abs(getClampedWallCurveOffset(wall)) > CURVE_EPSILON;
+}
+export function getWallChordFrame(wall) {
+    const start = getWallStartPoint(wall);
+    const end = getWallEndPoint(wall);
+    const dx = end.x - start.x;
+    const dy = end.y - start.y;
+    const length = Math.hypot(dx, dy);
+    if (length < CURVE_EPSILON) {
+        return {
+            start,
+            end,
+            midpoint: start,
+            tangent: { x: 1, y: 0 },
+            normal: { x: 0, y: 1 },
+            length: 0,
+        };
+    }
+    return {
+        start,
+        end,
+        midpoint: {
+            x: (start.x + end.x) / 2,
+            y: (start.y + end.y) / 2,
+        },
+        tangent: { x: dx / length, y: dy / length },
+        normal: { x: -dy / length, y: dx / length },
+        length,
+    };
+}
+function getWallArcData(wall) {
+    const chord = getWallChordFrame(wall);
+    const sagitta = getClampedWallCurveOffset(wall);
+    if (Math.abs(sagitta) <= CURVE_EPSILON || chord.length < CURVE_EPSILON) {
+        return null;
+    }
+    const absSagitta = Math.abs(sagitta);
+    const radius = chord.length * chord.length / (8 * absSagitta) + absSagitta / 2;
+    const centerOffset = radius - absSagitta;
+    const direction = Math.sign(sagitta) || 1;
+    const center = {
+        x: chord.midpoint.x + chord.normal.x * centerOffset * direction,
+        y: chord.midpoint.y + chord.normal.y * centerOffset * direction,
+    };
+    const startAngle = Math.atan2(chord.start.y - center.y, chord.start.x - center.x);
+    const endAngle = Math.atan2(chord.end.y - center.y, chord.end.x - center.x);
+    let delta = endAngle - startAngle;
+    if (direction > 0) {
+        while (delta <= 0)
+            delta += Math.PI * 2;
+    }
+    else {
+        while (delta >= 0)
+            delta -= Math.PI * 2;
+    }
+    return { center, radius, startAngle, delta, direction };
+}
+export function getWallCurveFrameAt(wall, t) {
+    const chord = getWallChordFrame(wall);
+    if (!isCurvedWall(wall) || chord.length < CURVE_EPSILON) {
+        return {
+            point: {
+                x: lerp(chord.start.x, chord.end.x, clamp01(t)),
+                y: lerp(chord.start.y, chord.end.y, clamp01(t)),
+            },
+            tangent: chord.tangent,
+            normal: chord.normal,
+        };
+    }
+    const arc = getWallArcData(wall);
+    if (!arc) {
+        return {
+            point: chord.midpoint,
+            tangent: chord.tangent,
+            normal: chord.normal,
+        };
+    }
+    const angle = arc.startAngle + arc.delta * clamp01(t);
+    const point = {
+        x: arc.center.x + Math.cos(angle) * arc.radius,
+        y: arc.center.y + Math.sin(angle) * arc.radius,
+    };
+    const tangent = arc.direction > 0
+        ? { x: -Math.sin(angle), y: Math.cos(angle) }
+        : { x: Math.sin(angle), y: -Math.cos(angle) };
+    return {
+        point,
+        tangent,
+        normal: {
+            x: -tangent.y,
+            y: tangent.x,
+        },
+    };
+}
+export function getWallMidpointHandlePoint(wall) {
+    return getWallCurveFrameAt(wall, 0.5).point;
+}
+export function sampleWallCenterline(wall, segments = DEFAULT_SAMPLE_SEGMENTS) {
+    const count = Math.max(1, segments);
+    return Array.from({ length: count + 1 }, (_, index) => getWallCurveFrameAt(wall, index / count).point);
+}
+export function getWallCurveLength(wall, segments = DEFAULT_SAMPLE_SEGMENTS) {
+    const points = sampleWallCenterline(wall, segments);
+    let totalLength = 0;
+    for (let index = 1; index < points.length; index += 1) {
+        totalLength += distance(points[index - 1], points[index]);
+    }
+    return totalLength;
+}
+export function getWallSurfacePolygon(wall, segments = DEFAULT_SAMPLE_SEGMENTS, miterOverrides) {
+    const halfThickness = (wall.thickness ?? 0.1) / 2;
+    const count = Math.max(1, segments);
+    const left = [];
+    const right = [];
+    for (let index = 0; index <= count; index += 1) {
+        const frame = getWallCurveFrameAt(wall, index / count);
+        left.push({
+            x: frame.point.x + frame.normal.x * halfThickness,
+            y: frame.point.y + frame.normal.y * halfThickness,
+        });
+        right.push({
+            x: frame.point.x - frame.normal.x * halfThickness,
+            y: frame.point.y - frame.normal.y * halfThickness,
+        });
+    }
+    if (left.length > 0 && right.length > 0) {
+        left[0] = miterOverrides?.startLeft ?? left[0];
+        right[0] = miterOverrides?.startRight ?? right[0];
+        left[left.length - 1] = miterOverrides?.endLeft ?? left[left.length - 1];
+        right[right.length - 1] = miterOverrides?.endRight ?? right[right.length - 1];
+    }
+    return [...right, ...left.reverse()];
+}

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

@@ -1 +1 @@
-{"version":3,"file":"wall-footprint.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-footprint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAC5C,OAAO,EAAE,KAAK,OAAO,EAAc,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAE9E,eAAO,MAAM,sBAAsB,MAAM,CAAA;AACzC,eAAO,MAAM,mBAAmB,MAAM,CAAA;AAEtC,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAE3D;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,aAAa,GAAG,OAAO,EAAE,CAkD5F"}
+{"version":3,"file":"wall-footprint.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-footprint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAE5C,OAAO,EAEL,KAAK,OAAO,EAEZ,KAAK,aAAa,EACnB,MAAM,iBAAiB,CAAA;AAExB,eAAO,MAAM,sBAAsB,MAAM,CAAA;AACzC,eAAO,MAAM,mBAAmB,MAAM,CAAA;AAGtC,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAE3D;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,aAAa,GAAG,OAAO,EAAE,CA6D5F"}

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

@@ -1,6 +1,8 @@
-import { pointToKey } from './wall-mitering';
+import { getWallSurfacePolygon, isCurvedWall } from './wall-curve';
+import { getWallMiterBoundaryPoints, pointToKey, } from './wall-mitering';
 export const DEFAULT_WALL_THICKNESS = 0.1;
 export const DEFAULT_WALL_HEIGHT = 2.5;
+const CURVED_WALL_SURFACE_SEGMENTS = 24;
 export function getWallThickness(wallNode) {
     return wallNode.thickness ?? DEFAULT_WALL_THICKNESS;
 }
@@ -20,6 +22,19 @@ export function getWallPlanFootprint(wallNode, miterData) {
     const keyEnd = pointToKey(wallEnd);
     const startJunction = junctionData.get(keyStart)?.get(wallNode.id);
     const endJunction = junctionData.get(keyEnd)?.get(wallNode.id);
+    if (isCurvedWall(wallNode)) {
+        const boundaryPoints = getWallMiterBoundaryPoints(wallNode, miterData);
+        if (!boundaryPoints) {
+            return [];
+        }
+        const { startLeft, startRight, endLeft, endRight } = boundaryPoints;
+        return getWallSurfacePolygon(wallNode, CURVED_WALL_SURFACE_SEGMENTS, {
+            endLeft,
+            endRight,
+            startLeft,
+            startRight,
+        });
+    }
     const pStartLeft = startJunction?.left || {
         x: wallStart.x + nUnit.x * halfT,
         y: wallStart.y + nUnit.y * halfT,
@@ -28,7 +43,6 @@ export function getWallPlanFootprint(wallNode, miterData) {
         x: wallStart.x - nUnit.x * halfT,
         y: wallStart.y - nUnit.y * halfT,
     };
-    // Junction offsets are stored relative to the outgoing direction.
     const pEndLeft = endJunction?.right || {
         x: wallEnd.x + nUnit.x * halfT,
         y: wallEnd.y + nUnit.y * halfT,

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

@@ -3,6 +3,12 @@ export interface Point2D {
     x: number;
     y: number;
 }
+export interface WallMiterBoundaryPoints {
+    startLeft: Point2D;
+    startRight: Point2D;
+    endLeft: Point2D;
+    endRight: Point2D;
+}
 type WallIntersections = Map<string, {
     left?: Point2D;
     right?: Point2D;
@@ -24,6 +30,7 @@ export interface WallMiterData {
  * Calculates miter data for all walls on a level
  */
 export declare function calculateLevelMiters(walls: WallNode[]): WallMiterData;
+export declare function getWallMiterBoundaryPoints(wall: WallNode, miterData: WallMiterData): WallMiterBoundaryPoints | null;
 /**
  * Gets wall IDs that share junctions with the given walls
  */

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

@@ -1 +1 @@
-{"version":3,"file":"wall-mitering.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-mitering.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAM5C,MAAM,WAAW,OAAO;IACtB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AASD,KAAK,iBAAiB,GAAG,GAAG,CAAC,MAAM,EAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC,CAAA;AAGzE,KAAK,YAAY,GAAG,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAA;AAQlD,iBAAS,UAAU,CAAC,CAAC,EAAE,OAAO,EAAE,SAAS,SAAY,GAAG,MAAM,CAG7D;AA8CD,UAAU,QAAQ;IAChB,YAAY,EAAE,OAAO,CAAA;IACrB,cAAc,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,QAAQ,CAAC;QAAC,OAAO,EAAE,OAAO,GAAG,KAAK,GAAG,aAAa,CAAA;KAAE,CAAC,CAAA;CACpF;AAkKD,MAAM,WAAW,aAAa;IAE5B,YAAY,EAAE,YAAY,CAAA;IAE1B,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;CACjC;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,aAAa,CAWrE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,EAAE,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CA8C/F;AAGD,OAAO,EAAE,UAAU,EAAE,CAAA"}
+{"version":3,"file":"wall-mitering.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-mitering.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAO5C,MAAM,WAAW,OAAO;IACtB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAED,MAAM,WAAW,uBAAuB;IACtC,SAAS,EAAE,OAAO,CAAA;IAClB,UAAU,EAAE,OAAO,CAAA;IACnB,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,OAAO,CAAA;CAClB;AASD,KAAK,iBAAiB,GAAG,GAAG,CAAC,MAAM,EAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC,CAAA;AAGzE,KAAK,YAAY,GAAG,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAA;AAQlD,iBAAS,UAAU,CAAC,CAAC,EAAE,OAAO,EAAE,SAAS,SAAY,GAAG,MAAM,CAG7D;AA8CD,UAAU,QAAQ;IAChB,YAAY,EAAE,OAAO,CAAA;IACrB,cAAc,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,QAAQ,CAAC;QAAC,OAAO,EAAE,OAAO,GAAG,KAAK,GAAG,aAAa,CAAA;KAAE,CAAC,CAAA;CACpF;AA+ND,MAAM,WAAW,aAAa;IAE5B,YAAY,EAAE,YAAY,CAAA;IAE1B,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;CACjC;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,aAAa,CAWrE;AAED,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,QAAQ,EACd,SAAS,EAAE,aAAa,GACvB,uBAAuB,GAAG,IAAI,CA0BhC;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,EAAE,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CA8C/F;AAGD,OAAO,EAAE,UAAU,EAAE,CAAA"}

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

@@ -1,3 +1,4 @@
+import { getWallCurveFrameAt, isCurvedWall } from './wall-curve';
 // ============================================================================
 // UTILITY FUNCTIONS
 // ============================================================================
@@ -79,6 +80,54 @@ function findJunctions(walls) {
     }
     return actualJunctions;
 }
+function getWallDirectionFromJunction(wall, endType) {
+    if (endType === 'passthrough') {
+        return {
+            x: wall.end[0] - wall.start[0],
+            y: wall.end[1] - wall.start[1],
+        };
+    }
+    if (isCurvedWall(wall)) {
+        const frame = getWallCurveFrameAt(wall, endType === 'start' ? 0 : 1);
+        return endType === 'start'
+            ? frame.tangent
+            : { x: -frame.tangent.x, y: -frame.tangent.y };
+    }
+    return endType === 'start'
+        ? { x: wall.end[0] - wall.start[0], y: wall.end[1] - wall.start[1] }
+        : { x: wall.start[0] - wall.end[0], y: wall.start[1] - wall.end[1] };
+}
+function getWallBoundaryFrame(wall, endType) {
+    if (isCurvedWall(wall)) {
+        const frame = getWallCurveFrameAt(wall, endType === 'start' ? 0 : 1);
+        return {
+            point: frame.point,
+            tangent: endType === 'start'
+                ? frame.tangent
+                : { x: -frame.tangent.x, y: -frame.tangent.y },
+            normal: frame.normal,
+        };
+    }
+    const point = endType === 'start'
+        ? { x: wall.start[0], y: wall.start[1] }
+        : { x: wall.end[0], y: wall.end[1] };
+    const vector = endType === 'start'
+        ? { x: wall.end[0] - wall.start[0], y: wall.end[1] - wall.start[1] }
+        : { x: wall.start[0] - wall.end[0], y: wall.start[1] - wall.end[1] };
+    const length = Math.hypot(vector.x, vector.y);
+    if (length < 1e-9) {
+        return {
+            point,
+            tangent: { x: 1, y: 0 },
+            normal: { x: 0, y: 1 },
+        };
+    }
+    return {
+        point,
+        tangent: { x: vector.x / length, y: vector.y / length },
+        normal: { x: -vector.y / length, y: vector.x / length },
+    };
+}
 function calculateJunctionIntersections(junction, getThickness) {
     const { meetingPoint, connectedWalls } = junction;
     const processedWalls = [];
@@ -104,9 +153,7 @@ function calculateJunctionIntersections(junction, getThickness) {
         }
         else {
             // Normal wall endpoint (start or end)
-            const v = endType === 'start'
-                ? { x: wall.end[0] - wall.start[0], y: wall.end[1] - wall.start[1] }
-                : { x: wall.start[0] - wall.end[0], y: wall.start[1] - wall.end[1] };
+            const v = getWallDirectionFromJunction(wall, endType);
             const L = Math.sqrt(v.x * v.x + v.y * v.y);
             if (L < 1e-9)
                 continue;
@@ -169,6 +216,32 @@ export function calculateLevelMiters(walls) {
     }
     return { junctionData, junctions };
 }
+export function getWallMiterBoundaryPoints(wall, miterData) {
+    const thickness = wall.thickness ?? 0.1;
+    const halfThickness = thickness / 2;
+    const startFrame = getWallBoundaryFrame(wall, 'start');
+    const endFrame = getWallBoundaryFrame(wall, 'end');
+    const startJunction = miterData.junctionData.get(pointToKey(startFrame.point))?.get(wall.id);
+    const endJunction = miterData.junctionData.get(pointToKey(endFrame.point))?.get(wall.id);
+    return {
+        startLeft: startJunction?.left ?? {
+            x: startFrame.point.x + startFrame.normal.x * halfThickness,
+            y: startFrame.point.y + startFrame.normal.y * halfThickness,
+        },
+        startRight: startJunction?.right ?? {
+            x: startFrame.point.x - startFrame.normal.x * halfThickness,
+            y: startFrame.point.y - startFrame.normal.y * halfThickness,
+        },
+        endLeft: endJunction?.right ?? {
+            x: endFrame.point.x + endFrame.normal.x * halfThickness,
+            y: endFrame.point.y + endFrame.normal.y * halfThickness,
+        },
+        endRight: endJunction?.left ?? {
+            x: endFrame.point.x - endFrame.normal.x * halfThickness,
+            y: endFrame.point.y - endFrame.normal.y * halfThickness,
+        },
+    };
+}
 /**
  * Gets wall IDs that share junctions with the given walls
  */

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

@@ -1 +1 @@
-{"version":3,"file":"wall-system.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-system.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAM9B,OAAO,KAAK,EAAE,OAAO,EAAa,QAAQ,EAAE,MAAM,cAAc,CAAA;AAGhE,OAAO,EAIL,KAAK,aAAa,EACnB,MAAM,iBAAiB,CAAA;AAUxB,eAAO,MAAM,UAAU,YAuDtB,CAAA;AA0DD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,QAAQ,EAClB,aAAa,EAAE,OAAO,EAAE,EACxB,SAAS,EAAE,aAAa,EACxB,aAAa,SAAI,oFA+FlB"}
+{"version":3,"file":"wall-system.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-system.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAM9B,OAAO,KAAK,EAAE,OAAO,EAAa,QAAQ,EAAE,MAAM,cAAc,CAAA;AAIhE,OAAO,EAML,KAAK,aAAa,EACnB,MAAM,iBAAiB,CAAA;AAsRxB,eAAO,MAAM,UAAU,YAuDtB,CAAA;AA0DD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,QAAQ,EAClB,aAAa,EAAE,OAAO,EAAE,EACxB,SAAS,EAAE,aAAa,EACxB,aAAa,SAAI,oFA2GlB"}

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.0",
+  "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",