@pascal-app/core 0.5.1 → 0.7.0

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,EACV,OAAO,EACP,SAAS,EACT,WAAW,EAEX,QAAQ,EAGT,MAAM,cAAc,CAAA;AAitBrB,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;QAQvC,SAAS;UAAQ,OAAO,CAAC,QAAQ,GAAG,WAAW,CAAC;IAyG5E"}