@pascal-app/core 0.5.0 → 0.6.0

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

@@ -0,0 +1,187 @@
+import { useFrame } from '@react-three/fiber';
+import * as THREE from 'three';
+import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+import { sceneRegistry } from '../../hooks/scene-registry/scene-registry';
+import useScene from '../../store/use-scene';
+import { getWallCurveFrameAt, getWallCurveLength } from '../wall/wall-curve';
+const MIN_CURVE_SEGMENT_LENGTH = 0.18;
+function createFencePartGeometry(part) {
+    const geometry = new THREE.BoxGeometry(1, 1, 1);
+    geometry.scale(part.scale[0], part.scale[1], part.scale[2]);
+    if (part.rotationY) {
+        geometry.rotateY(part.rotationY);
+    }
+    geometry.translate(part.position[0], part.position[1], part.position[2]);
+    applyFenceUVs(geometry);
+    return geometry;
+}
+function getFencePointAt(fence, t) {
+    const frame = getWallCurveFrameAt(fence, t);
+    return {
+        point: frame.point,
+        tangentAngle: Math.atan2(frame.tangent.y, frame.tangent.x),
+    };
+}
+function createStraightFenceSpanPart(start, end, centerY, height, depth) {
+    const dx = end[0] - start[0];
+    const dz = end[1] - start[1];
+    const length = Math.hypot(dx, dz);
+    if (length <= 1e-4) {
+        return null;
+    }
+    return {
+        position: [(start[0] + end[0]) / 2, centerY, (start[1] + end[1]) / 2],
+        rotationY: -Math.atan2(dz, dx),
+        scale: [length, height, depth],
+    };
+}
+function createFenceCurveSpanParts(fence, startT, endT, centerY, height, depth) {
+    const parts = [];
+    const frameCount = Math.max(1, Math.ceil((getWallCurveLength(fence) * Math.max(1e-4, endT - startT)) / MIN_CURVE_SEGMENT_LENGTH));
+    let previous = getFencePointAt(fence, startT);
+    for (let index = 1; index <= frameCount; index += 1) {
+        const t = startT + (endT - startT) * (index / frameCount);
+        const current = getFencePointAt(fence, t);
+        const segment = createStraightFenceSpanPart([previous.point.x, previous.point.y], [current.point.x, current.point.y], centerY, height, depth);
+        if (segment) {
+            parts.push(segment);
+        }
+        previous = current;
+    }
+    return parts;
+}
+function applyFenceUVs(geometry) {
+    const position = geometry.getAttribute('position');
+    const normal = geometry.getAttribute('normal');
+    if (!(position && normal))
+        return;
+    const uvs = new Float32Array(position.count * 2);
+    let minX = Number.POSITIVE_INFINITY;
+    let minY = Number.POSITIVE_INFINITY;
+    let minZ = Number.POSITIVE_INFINITY;
+    for (let index = 0; index < position.count; index += 1) {
+        minX = Math.min(minX, position.getX(index));
+        minY = Math.min(minY, position.getY(index));
+        minZ = Math.min(minZ, position.getZ(index));
+    }
+    for (let index = 0; index < position.count; index += 1) {
+        const px = position.getX(index);
+        const py = position.getY(index);
+        const pz = position.getZ(index);
+        const nx = Math.abs(normal.getX(index));
+        const ny = Math.abs(normal.getY(index));
+        const nz = Math.abs(normal.getZ(index));
+        let u = 0;
+        let v = 0;
+        if (ny >= nx && ny >= nz) {
+            u = px - minX;
+            v = pz - minZ;
+        }
+        else if (nx >= nz) {
+            u = pz - minZ;
+            v = py - minY;
+        }
+        else {
+            u = px - minX;
+            v = py - minY;
+        }
+        uvs[index * 2] = u;
+        uvs[index * 2 + 1] = v;
+    }
+    geometry.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
+    geometry.setAttribute('uv2', new THREE.Float32BufferAttribute(uvs.slice(), 2));
+}
+function getStyleDefaults(style) {
+    if (style === 'privacy') {
+        return { spacingFactor: 0.42, postFactor: 1.35, baseFactor: 1.2, topFactor: 1.2 };
+    }
+    if (style === 'rail') {
+        return { spacingFactor: 0.68, postFactor: 0.8, baseFactor: 0.85, topFactor: 0.85 };
+    }
+    return { spacingFactor: 0.3, postFactor: 0.55, baseFactor: 1, topFactor: 0.75 };
+}
+function createFenceParts(fence) {
+    const parts = [];
+    const length = Math.max(getWallCurveLength(fence), 0.01);
+    const panelDepth = Math.max(fence.thickness, 0.03);
+    const clearance = Math.max(fence.groundClearance, 0);
+    const styleDefaults = getStyleDefaults(fence.style);
+    const baseHeight = Math.max(fence.baseHeight * styleDefaults.baseFactor, 0.04);
+    const topRailHeight = Math.max(fence.topRailHeight * styleDefaults.topFactor, 0.01);
+    const verticalHeight = Math.max(fence.height - baseHeight - topRailHeight, 0.08);
+    const postWidth = Math.max(fence.postSize * styleDefaults.postFactor, 0.01);
+    const spacing = Math.max(fence.postSpacing * styleDefaults.spacingFactor, postWidth * 1.2);
+    const edgeInset = Math.max(fence.edgeInset ?? 0.015, 0.005);
+    const isFloating = fence.baseStyle === 'floating';
+    const baseY = isFloating ? clearance : 0;
+    const effectiveBaseHeight = baseHeight;
+    const startInsetT = Math.min(0.499, edgeInset / length);
+    const endInsetT = Math.max(0.501, 1 - edgeInset / length);
+    if (!isFloating) {
+        parts.push(...createFenceCurveSpanParts(fence, 0, 1, baseY + effectiveBaseHeight / 2, effectiveBaseHeight, panelDepth * 1.05));
+        parts.push(...createFenceCurveSpanParts(fence, 0, 1, baseY + effectiveBaseHeight + verticalHeight * 0.15, topRailHeight * 0.8, panelDepth * 0.35));
+    }
+    const count = Math.max(2, Math.floor((length - edgeInset * 2) / spacing) + 1);
+    const verticalY = baseY + effectiveBaseHeight + verticalHeight / 2;
+    for (let index = 0; index < count; index += 1) {
+        const t = count === 1 ? 0.5 : startInsetT + (endInsetT - startInsetT) * (index / (count - 1));
+        const frame = getFencePointAt(fence, t);
+        const isEdgePost = index === 0 || index === count - 1;
+        const postHeight = isFloating && isEdgePost
+            ? effectiveBaseHeight + verticalHeight + topRailHeight + clearance
+            : verticalHeight;
+        const postY = isFloating && isEdgePost ? postHeight / 2 : verticalY;
+        parts.push({
+            position: [frame.point.x, postY, frame.point.y],
+            rotationY: -frame.tangentAngle,
+            scale: [postWidth, postHeight, Math.max(panelDepth * 0.35, 0.012)],
+        });
+    }
+    parts.push(...createFenceCurveSpanParts(fence, 0, 1, baseY + effectiveBaseHeight + verticalHeight + topRailHeight / 2, topRailHeight, Math.max(panelDepth * 0.55, 0.018)));
+    if (isFloating) {
+        parts.push(...createFenceCurveSpanParts(fence, 0, 1, baseY + effectiveBaseHeight + topRailHeight / 2, topRailHeight, Math.max(panelDepth * 0.55, 0.018)));
+    }
+    return parts;
+}
+function generateFenceGeometry(fence) {
+    const parts = createFenceParts(fence);
+    const geometries = parts.map(createFencePartGeometry);
+    const merged = mergeGeometries(geometries, false) ?? new THREE.BufferGeometry();
+    geometries.forEach((geometry) => geometry.dispose());
+    const mergedUv = merged.getAttribute('uv');
+    if (mergedUv) {
+        merged.setAttribute('uv2', new THREE.Float32BufferAttribute(Array.from(mergedUv.array), 2));
+    }
+    merged.computeVertexNormals();
+    return merged;
+}
+function updateFenceGeometry(fenceId) {
+    const node = useScene.getState().nodes[fenceId];
+    if (!node || node.type !== 'fence')
+        return;
+    const mesh = sceneRegistry.nodes.get(fenceId);
+    if (!mesh)
+        return;
+    const newGeometry = generateFenceGeometry(node);
+    mesh.geometry.dispose();
+    mesh.geometry = newGeometry;
+    mesh.position.set(0, 0, 0);
+    mesh.rotation.set(0, 0, 0);
+}
+export const FenceSystem = () => {
+    const dirtyNodes = useScene((state) => state.dirtyNodes);
+    const clearDirty = useScene((state) => state.clearDirty);
+    useFrame(() => {
+        if (dirtyNodes.size === 0)
+            return;
+        const nodes = useScene.getState().nodes;
+        dirtyNodes.forEach((id) => {
+            const node = nodes[id];
+            if (!node || node.type !== 'fence')
+                return;
+            updateFenceGeometry(id);
+            clearDirty(id);
+        });
+    }, 4);
+    return null;
+};

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

@@ -1 +1 @@
-{"version":3,"file":"roof-system.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-system.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,EAAY,KAAK,EAA0B,MAAM,eAAe,CAAA;AAGvE,OAAO,KAAK,EAAgC,eAAe,EAAE,MAAM,cAAc,CAAA;AA+BjF,eAAO,MAAM,UAAU,YAuFtB,CAAA;AAuLD;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,eAAe,GACpB;IAAE,QAAQ,EAAE,KAAK,CAAC;IAAC,QAAQ,EAAE,KAAK,CAAC;IAAC,SAAS,EAAE,KAAK,CAAC;IAAC,UAAU,EAAE,KAAK,CAAA;CAAE,GAAG,IAAI,CAsRlF;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,eAAe,GAAG,KAAK,CAAC,cAAc,CAoDvF"}
+{"version":3,"file":"roof-system.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-system.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,EAAY,KAAK,EAA0B,MAAM,eAAe,CAAA;AAGvE,OAAO,KAAK,EAAgC,eAAe,EAAE,MAAM,cAAc,CAAA;AAgCjF,eAAO,MAAM,UAAU,YAuFtB,CAAA;AAwLD;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,eAAe,GACpB;IAAE,QAAQ,EAAE,KAAK,CAAC;IAAC,QAAQ,EAAE,KAAK,CAAC;IAAC,SAAS,EAAE,KAAK,CAAC;IAAC,UAAU,EAAE,KAAK,CAAA;CAAE,GAAG,IAAI,CAsRlF;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,eAAe,GAAG,KAAK,CAAC,cAAc,CAqDvF"}

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

@@ -8,7 +8,7 @@ import useScene from '../../store/use-scene';
 const csgEvaluator = new Evaluator();
 csgEvaluator.useGroups = true;
 csgEvaluator.consolidateGroups = false; // shared dummyMats across brushes causes consolidation to misalign groupIndices vs groupOrder indices → crash
-csgEvaluator.attributes = ['position', 'normal'];
+csgEvaluator.attributes = ['position', 'normal', 'uv'];
 function prepareBrushForCSG(brush) {
     brush.geometry.computeBoundsTree = computeBoundsTree;
     brush.geometry.computeBoundsTree({ maxLeafSize: 10 });
@@ -20,6 +20,7 @@ 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);
+const _uvFaceNormal = new THREE.Vector3();
 // Pending merged-roof updates carried across frames (for throttling)
 const pendingRoofUpdates = new Set();
 const MAX_ROOFS_PER_FRAME = 1;
@@ -217,6 +218,7 @@ function updateMergedRoofGeometry(roofNode, group, nodes) {
             for (const g of resultGeo.groups) {
                 g.materialIndex = mapRoofGroupMaterialIndex(g.materialIndex, resultMaterials, matToIndex);
             }
+            ensureUv2Attribute(resultGeo);
             resultGeo.computeVertexNormals();
             mergedMesh.geometry.dispose();
             mergedMesh.geometry = resultGeo;
@@ -500,6 +502,7 @@ export function generateRoofSegmentGeometry(node) {
     shinSlab.geometry.dispose();
     wallBrush.geometry.dispose();
     innerBrush.geometry.dispose();
+    ensureUv2Attribute(resultGeo);
     resultGeo.computeVertexNormals();
     return resultGeo;
 }
@@ -709,6 +712,7 @@ function getModuleFaces(type, w, d, wh, rh, baseY, insets, baseW, baseD, tanThet
 function createGeometryFromFaces(faces, matRule = null) {
     const positions = [];
     const normals = [];
+    const uvs = [];
     const indices = [];
     const groups = [];
     let vertexCount = 0;
@@ -743,6 +747,9 @@ function createGeometryFromFaces(faces, matRule = null) {
             normals.push(normal.x, normal.y, normal.z);
             normals.push(normal.x, normal.y, normal.z);
             normals.push(normal.x, normal.y, normal.z);
+            pushRoofUv(uvs, p0, normal);
+            pushRoofUv(uvs, fi, normal);
+            pushRoofUv(uvs, fi1, normal);
             indices.push(vertexCount, vertexCount + 1, vertexCount + 2);
             faceVertexCount += 3;
             vertexCount += 3;
@@ -756,6 +763,7 @@ function createGeometryFromFaces(faces, matRule = null) {
     const geometry = new THREE.BufferGeometry();
     geometry.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
     geometry.setAttribute('normal', new THREE.Float32BufferAttribute(normals, 3));
+    geometry.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
     geometry.setIndex(indices);
     for (const g of groups) {
         geometry.addGroup(g.start, g.count, g.materialIndex);
@@ -763,5 +771,27 @@ function createGeometryFromFaces(faces, matRule = null) {
     // Merge identical vertices to optimize geometry for CSG and create clean topology
     const mergedGeo = mergeVertices(geometry, 1e-4);
     geometry.dispose();
+    ensureUv2Attribute(mergedGeo);
     return mergedGeo;
 }
+function pushRoofUv(uvs, point, normal) {
+    _uvFaceNormal.copy(normal).normalize();
+    const absX = Math.abs(_uvFaceNormal.x);
+    const absY = Math.abs(_uvFaceNormal.y);
+    const absZ = Math.abs(_uvFaceNormal.z);
+    if (absY >= absX && absY >= absZ) {
+        uvs.push(point.x, point.z);
+        return;
+    }
+    if (absX >= absZ) {
+        uvs.push(point.z, point.y);
+        return;
+    }
+    uvs.push(point.x, point.y);
+}
+function ensureUv2Attribute(geometry) {
+    const uv = geometry.getAttribute('uv');
+    if (!uv)
+        return;
+    geometry.setAttribute('uv2', new THREE.Float32BufferAttribute(Array.from(uv.array), 2));
+}

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

@@ -1 +1 @@
-{"version":3,"file":"slab-system.d.ts","sourceRoot":"","sources":["../../../src/systems/slab/slab-system.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,KAAK,EAAa,QAAQ,EAAE,MAAM,cAAc,CAAA;AAOvD,eAAO,MAAM,UAAU,YAwBtB,CAAA;AAuED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,GAAG,KAAK,CAAC,cAAc,CAG7E"}
+{"version":3,"file":"slab-system.d.ts","sourceRoot":"","sources":["../../../src/systems/slab/slab-system.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,OAAO,KAAK,EAAa,QAAQ,EAAE,MAAM,cAAc,CAAA;AAcvD,eAAO,MAAM,UAAU,YAwBtB,CAAA;AAmFD;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,GAAG,KAAK,CAAC,cAAc,CAG7E"}

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

@@ -1,7 +1,14 @@
 import { useFrame } from '@react-three/fiber';
 import * as THREE from 'three';
 import { sceneRegistry } from '../../hooks/scene-registry/scene-registry';
+import { insetPolygonFromCentroid, simplifyClosedPolygon } from '../../lib/polygon-geometry';
 import useScene from '../../store/use-scene';
+function ensureUv2Attribute(geometry) {
+    const uv = geometry.getAttribute('uv');
+    if (!uv)
+        return;
+    geometry.setAttribute('uv2', new THREE.Float32BufferAttribute(Array.from(uv.array), 2));
+}
 // ============================================================================
 // SLAB SYSTEM
 // ============================================================================
@@ -32,6 +39,7 @@ export const SlabSystem = () => {
  */
 function updateSlabGeometry(node, mesh) {
     const newGeo = generateSlabGeometry(node);
+    ensureUv2Attribute(newGeo);
     mesh.geometry.dispose();
     mesh.geometry = newGeo;
     // For negative elevation, shift the mesh down so the top face sits at Y=elevation
@@ -41,6 +49,13 @@ function updateSlabGeometry(node, mesh) {
 }
 /** Half of default wall thickness — used to extend slab geometry under walls */
 const SLAB_OUTSET = 0.05;
+const AUTO_SLAB_INSET = 0.02;
+const AUTO_SLAB_SIMPLIFY_TOLERANCE = 0.08;
+function getRenderableSlabPolygon(slabNode) {
+    return slabNode.autoFromWalls
+        ? simplifyClosedPolygon(insetPolygonFromCentroid(slabNode.polygon, AUTO_SLAB_INSET), AUTO_SLAB_SIMPLIFY_TOLERANCE)
+        : outsetPolygon(slabNode.polygon, SLAB_OUTSET);
+}
 /**
  * Expand a polygon outward by a uniform distance.
  * Offsets each edge outward then intersects consecutive offset edges.
@@ -100,7 +115,7 @@ export function generateSlabGeometry(slabNode) {
  * Standard slab: flat extrusion upward from Y=0 by elevation thickness.
  */
 function generatePositiveSlabGeometry(slabNode) {
-    const polygon = outsetPolygon(slabNode.polygon, SLAB_OUTSET);
+    const polygon = getRenderableSlabPolygon(slabNode);
     const elevation = slabNode.elevation ?? 0.05;
     if (polygon.length < 3)
         return new THREE.BufferGeometry();
@@ -134,21 +149,41 @@ function generatePositiveSlabGeometry(slabNode) {
  *   - walls from Y=0 to Y=depth, inward-facing normals (visible from inside pool)
  */
 function generatePoolGeometry(slabNode) {
-    const polygon = outsetPolygon(slabNode.polygon, SLAB_OUTSET);
+    const polygon = getRenderableSlabPolygon(slabNode);
     const depth = Math.abs(slabNode.elevation ?? 0.05);
     if (polygon.length < 3)
         return new THREE.BufferGeometry();
     const positions = [];
+    const uvs = [];
     const indices = [];
     const n = polygon.length;
+    const bounds = new THREE.Box2();
+    for (const [x, z] of polygon) {
+        bounds.expandByPoint(new THREE.Vector2(x, z));
+    }
+    for (const hole of slabNode.holes ?? []) {
+        for (const [x, z] of hole) {
+            bounds.expandByPoint(new THREE.Vector2(x, z));
+        }
+    }
+    const floorWidth = Math.max(bounds.max.x - bounds.min.x, 0.001);
+    const floorHeight = Math.max(bounds.max.y - bounds.min.y, 0.001);
+    const pushFloorVertex = (x, y, z) => {
+        positions.push(x, y, z);
+        uvs.push((x - bounds.min.x) / floorWidth, (z - bounds.min.y) / floorHeight);
+    };
+    const pushWallVertex = (x, y, z, u, v) => {
+        positions.push(x, y, z);
+        uvs.push(u, v);
+    };
     // --- Floor at Y=0 ---
     for (const [x, z] of polygon)
-        positions.push(x, 0, z);
+        pushFloorVertex(x, 0, z);
     const pts2d = polygon.map(([x, z]) => new THREE.Vector2(x, z));
     const holesPts2d = (slabNode.holes ?? []).map((h) => h.map(([x, z]) => new THREE.Vector2(x, z)));
     for (const hole of slabNode.holes ?? []) {
         for (const [x, z] of hole)
-            positions.push(x, 0, z);
+            pushFloorVertex(x, 0, z);
     }
     const floorTris = THREE.ShapeUtils.triangulateShape(pts2d, holesPts2d);
     for (const tri of floorTris) {
@@ -162,15 +197,17 @@ function generatePoolGeometry(slabNode) {
         const [x0, z0] = polygon[i];
         const [x1, z1] = polygon[j];
         const vBase = positions.length / 3;
-        positions.push(x0, 0, z0); // v0 — floor level
-        positions.push(x1, 0, z1); // v1 — floor level
-        positions.push(x1, depth, z1); // v2 — ground level
-        positions.push(x0, depth, z0); // v3 — ground level
+        const segmentLength = Math.max(Math.hypot(x1 - x0, z1 - z0), 0.001);
+        pushWallVertex(x0, 0, z0, 0, 0); // v0 — floor level
+        pushWallVertex(x1, 0, z1, segmentLength, 0); // v1 — floor level
+        pushWallVertex(x1, depth, z1, segmentLength, depth); // v2 — ground level
+        pushWallVertex(x0, depth, z0, 0, depth); // v3 — ground level
         indices.push(vBase, vBase + 1, vBase + 2);
         indices.push(vBase, vBase + 2, vBase + 3);
     }
     const geo = new THREE.BufferGeometry();
     geo.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
+    geo.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
     geo.setIndex(indices);
     geo.computeVertexNormals();
     return geo;

package/dist/systems/stair/stair-opening-sync.d.ts

@@ -0,0 +1,6 @@
+import type { AnyNode, AnyNodeId, CeilingNode, SlabNode } from '../../schema';
+export declare function syncAutoStairOpenings(nodes: Record<string, AnyNode>): {
+    id: AnyNodeId;
+    data: Partial<SlabNode | CeilingNode>;
+}[];
+//# sourceMappingURL=stair-opening-sync.d.ts.map

package/dist/systems/stair/stair-opening-sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stair-opening-sync.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-opening-sync.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,WAAW,EAAa,QAAQ,EAA+B,MAAM,cAAc,CAAA;AAulBrH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;QAIvC,SAAS;UAAQ,OAAO,CAAC,QAAQ,GAAG,WAAW,CAAC;IA6F5E"}