@pascal-app/core 0.1.12 → 0.2.0

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;AAkED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,GAAG,KAAK,CAAC,cAAc,CAiC7E"}
+{"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;AAkED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,GAAG,KAAK,CAAC,cAAc,CAmD7E"}

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

@@ -24,7 +24,7 @@ export const SlabSystem = () => {
             }
             // If mesh not found, keep it dirty for next frame
         });
-    });
+    }, 1);
     return null;
 };
 /**
@@ -63,8 +63,8 @@ function outsetPolygon(polygon, amount) {
             offEdges.push([polygon[i][0], polygon[i][1], dx, dz]);
             continue;
         }
-        const nx = (s * dz / len) * amount;
-        const nz = (s * -dx / len) * amount;
+        const nx = ((s * dz) / len) * amount;
+        const nz = ((s * -dx) / len) * amount;
         offEdges.push([polygon[i][0] + nx, polygon[i][1] + nz, dx, dz]);
     }
     // Intersect consecutive offset edges to get new vertices
@@ -105,6 +105,21 @@ export function generateSlabGeometry(slabNode) {
         shape.lineTo(pt[0], -pt[1]);
     }
     shape.closePath();
+    // Add holes to the shape
+    const holes = slabNode.holes || [];
+    for (const holePolygon of holes) {
+        if (holePolygon.length < 3)
+            continue;
+        const holePath = new THREE.Path();
+        const holeFirstPt = holePolygon[0];
+        holePath.moveTo(holeFirstPt[0], -holeFirstPt[1]);
+        for (let i = 1; i < holePolygon.length; i++) {
+            const pt = holePolygon[i];
+            holePath.lineTo(pt[0], -pt[1]);
+        }
+        holePath.closePath();
+        shape.holes.push(holePath);
+    }
     // Extrude the shape by elevation
     const geometry = new THREE.ExtrudeGeometry(shape, {
         depth: elevation,

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

@@ -52,11 +52,11 @@ function findJunctions(walls) {
         if (!junctions.has(keyStart)) {
             junctions.set(keyStart, { meetingPoint: startPt, connectedWalls: [] });
         }
-        junctions.get(keyStart).connectedWalls.push({ wall, endType: 'start' });
+        junctions.get(keyStart)?.connectedWalls.push({ wall, endType: 'start' });
         if (!junctions.has(keyEnd)) {
             junctions.set(keyEnd, { meetingPoint: endPt, connectedWalls: [] });
         }
-        junctions.get(keyEnd).connectedWalls.push({ wall, endType: 'end' });
+        junctions.get(keyEnd)?.connectedWalls.push({ wall, endType: 'end' });
     }
     // Second pass: detect T-junctions (walls passing through junction points)
     for (const [_key, junction] of junctions.entries()) {

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;AAEhE,OAAO,EAKL,KAAK,aAAa,EACnB,MAAM,iBAAiB,CAAA;AAUxB,eAAO,MAAM,UAAU,YAuDtB,CAAA;AA2DD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,QAAQ,EAClB,aAAa,EAAE,OAAO,EAAE,EACxB,SAAS,EAAE,aAAa,EACxB,aAAa,SAAI,oFA8IlB"}
+{"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;AAEhE,OAAO,EAKL,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,oFA4IlB"}

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

@@ -1,7 +1,7 @@
 import { useFrame } from '@react-three/fiber';
 import * as THREE from 'three';
-import { computeBoundsTree } from 'three-mesh-bvh';
 import { Brush, Evaluator, SUBTRACTION } from 'three-bvh-csg';
+import { computeBoundsTree } from 'three-mesh-bvh';
 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';
@@ -33,7 +33,7 @@ export const WallSystem = () => {
             if (!dirtyWallsByLevel.has(levelId)) {
                 dirtyWallsByLevel.set(levelId, new Set());
             }
-            dirtyWallsByLevel.get(levelId).add(id);
+            dirtyWallsByLevel.get(levelId)?.add(id);
         });
         // Process each level that has dirty walls
         for (const [levelId, dirtyWallIds] of dirtyWallsByLevel) {
@@ -59,7 +59,7 @@ export const WallSystem = () => {
                 }
             }
         }
-    });
+    }, 4);
     return null;
 };
 /**
@@ -106,7 +106,7 @@ function updateWallGeometry(wallId, miterData) {
         collisionMesh.geometry.dispose();
         collisionMesh.geometry = collisionGeo;
     }
-    mesh.position.set(node.start[0], 0, node.start[1]);
+    mesh.position.set(node.start[0], slabElevation, node.start[1]);
     const angle = Math.atan2(node.end[1] - node.start[1], node.end[0] - node.start[0]);
     mesh.rotation.y = -angle;
 }
@@ -120,8 +120,10 @@ export function generateExtrudedWall(wallNode, childrenNodes, miterData, slabEle
     const { junctionData } = miterData;
     const wallStart = { x: wallNode.start[0], y: wallNode.start[1] };
     const wallEnd = { x: wallNode.end[0], y: wallNode.end[1] };
-    // Wall height is adjusted by slab elevation (positive reduces, negative increases)
-    const height = (wallNode.height ?? 2.5) - slabElevation;
+    // Positive slab: shift the whole wall up (full height preserved)
+    // Negative slab: extend wall downward so top stays fixed at wallNode.height
+    const wallHeight = wallNode.height ?? 2.5;
+    const height = slabElevation > 0 ? wallHeight : wallHeight - slabElevation;
     const thickness = wallNode.thickness ?? 0.1;
     const halfT = thickness / 2;
     // Wall direction and normal (exactly like demo)
@@ -201,10 +203,6 @@ export function generateExtrudedWall(wallNode, childrenNodes, miterData, slabEle
     });
     // Rotate so extrusion direction (Z) becomes height direction (Y)
     geometry.rotateX(-Math.PI / 2);
-    // Translate by slab elevation (works for both positive and negative values)
-    if (slabElevation !== 0) {
-        geometry.translate(0, slabElevation, 0);
-    }
     geometry.computeVertexNormals();
     // Apply CSG subtraction for cutouts (doors/windows)
     const cutoutBrushes = collectCutoutBrushes(wallNode, childrenNodes, thickness);
@@ -249,7 +247,7 @@ function collectCutoutBrushes(wallNode, childrenNodes, wallThickness) {
     wallMesh.updateMatrixWorld();
     const wallMatrixInverse = wallMesh.matrixWorld.clone().invert();
     for (const child of childrenNodes) {
-        if (child.type !== 'item')
+        if (child.type !== 'item' && child.type !== 'window' && child.type !== 'door')
             continue;
         const childMesh = sceneRegistry.nodes.get(child.id);
         if (!childMesh)
@@ -264,8 +262,8 @@ function collectCutoutBrushes(wallNode, childrenNodes, wallThickness) {
             continue;
         // Calculate bounds in wall-local space
         const v3 = new THREE.Vector3();
-        let minX = Infinity, maxX = -Infinity;
-        let minY = Infinity, maxY = -Infinity;
+        let minX = Number.POSITIVE_INFINITY, maxX = Number.NEGATIVE_INFINITY;
+        let minY = Number.POSITIVE_INFINITY, maxY = Number.NEGATIVE_INFINITY;
         for (let i = 0; i < positions.count; i++) {
             v3.fromBufferAttribute(positions, i);
             v3.applyMatrix4(cutoutMesh.matrixWorld);

package/dist/systems/window/window-system.d.ts

@@ -0,0 +1,2 @@
+export declare const WindowSystem: () => null;
+//# sourceMappingURL=window-system.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"window-system.d.ts","sourceRoot":"","sources":["../../../src/systems/window/window-system.tsx"],"names":[],"mappings":"AA4BA,eAAO,MAAM,YAAY,YA2BxB,CAAA"}

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

@@ -0,0 +1,147 @@
+import { useFrame } from '@react-three/fiber';
+import * as THREE from 'three';
+import { DoubleSide, MeshStandardNodeMaterial } from 'three/webgpu';
+import { sceneRegistry } from '../../hooks/scene-registry/scene-registry';
+import useScene from '../../store/use-scene';
+const glassMaterial = new MeshStandardNodeMaterial({
+    name: 'glass',
+    color: 'lightblue',
+    roughness: 0.05,
+    metalness: 0.1,
+    transparent: true,
+    opacity: 0.3,
+    side: DoubleSide,
+    depthWrite: false,
+});
+const frameMaterial = new MeshStandardNodeMaterial({
+    name: 'window-frame',
+    color: '#e8e8e8',
+    roughness: 0.6,
+    metalness: 0,
+});
+// Invisible material for root mesh — used as selection hitbox only
+const hitboxMaterial = new THREE.MeshBasicMaterial({ visible: false });
+export const WindowSystem = () => {
+    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 !== 'window')
+                return;
+            const mesh = sceneRegistry.nodes.get(id);
+            if (!mesh)
+                return; // Keep dirty until mesh mounts
+            updateWindowMesh(node, mesh);
+            clearDirty(id);
+            // Rebuild the parent wall so its cutout reflects the updated window geometry
+            if (node.parentId) {
+                useScene.getState().dirtyNodes.add(node.parentId);
+            }
+        });
+    }, 3);
+    return null;
+};
+function addBox(parent, material, w, h, d, x, y, z) {
+    const m = new THREE.Mesh(new THREE.BoxGeometry(w, h, d), material);
+    m.position.set(x, y, z);
+    parent.add(m);
+}
+function updateWindowMesh(node, mesh) {
+    // Root mesh is an invisible hitbox; all visuals live in child meshes
+    mesh.geometry.dispose();
+    mesh.geometry = new THREE.BoxGeometry(node.width, node.height, node.frameDepth);
+    mesh.material = hitboxMaterial;
+    // Sync transform from node (React may lag behind the system by a frame during drag)
+    mesh.position.set(node.position[0], node.position[1], node.position[2]);
+    mesh.rotation.set(node.rotation[0], node.rotation[1], node.rotation[2]);
+    // Dispose and remove all old visual children; preserve 'cutout'
+    for (const child of [...mesh.children]) {
+        if (child.name === 'cutout')
+            continue;
+        if (child instanceof THREE.Mesh)
+            child.geometry.dispose();
+        mesh.remove(child);
+    }
+    const { width, height, frameDepth, frameThickness, columnRatios, rowRatios, columnDividerThickness, rowDividerThickness, sill, sillDepth, sillThickness, } = node;
+    const innerW = width - 2 * frameThickness;
+    const innerH = height - 2 * frameThickness;
+    // ── Frame members ──
+    // Top / bottom — full width
+    addBox(mesh, frameMaterial, width, frameThickness, frameDepth, 0, height / 2 - frameThickness / 2, 0);
+    addBox(mesh, frameMaterial, width, frameThickness, frameDepth, 0, -height / 2 + frameThickness / 2, 0);
+    // Left / right — inner height to avoid corner overlap
+    addBox(mesh, frameMaterial, frameThickness, innerH, frameDepth, -width / 2 + frameThickness / 2, 0, 0);
+    addBox(mesh, frameMaterial, frameThickness, innerH, frameDepth, width / 2 - frameThickness / 2, 0, 0);
+    // ── Pane grid ──
+    const numCols = columnRatios.length;
+    const numRows = rowRatios.length;
+    const usableW = innerW - (numCols - 1) * columnDividerThickness;
+    const usableH = innerH - (numRows - 1) * rowDividerThickness;
+    const colSum = columnRatios.reduce((a, b) => a + b, 0);
+    const rowSum = rowRatios.reduce((a, b) => a + b, 0);
+    const colWidths = columnRatios.map((r) => (r / colSum) * usableW);
+    const rowHeights = rowRatios.map((r) => (r / rowSum) * usableH);
+    // Compute column x-centers starting from left edge of inner area
+    const colXCenters = [];
+    let cx = -innerW / 2;
+    for (let c = 0; c < numCols; c++) {
+        colXCenters.push(cx + colWidths[c] / 2);
+        cx += colWidths[c];
+        if (c < numCols - 1)
+            cx += columnDividerThickness;
+    }
+    // Compute row y-centers starting from top edge of inner area (R1 = top)
+    const rowYCenters = [];
+    let cy = innerH / 2;
+    for (let r = 0; r < numRows; r++) {
+        rowYCenters.push(cy - rowHeights[r] / 2);
+        cy -= rowHeights[r];
+        if (r < numRows - 1)
+            cy -= rowDividerThickness;
+    }
+    // Column dividers — full inner height
+    cx = -innerW / 2;
+    for (let c = 0; c < numCols - 1; c++) {
+        cx += colWidths[c];
+        addBox(mesh, frameMaterial, columnDividerThickness, innerH, frameDepth, cx + columnDividerThickness / 2, 0, 0);
+        cx += columnDividerThickness;
+    }
+    // Row dividers — per column width, so they don't overlap column dividers (top to bottom)
+    cy = innerH / 2;
+    for (let r = 0; r < numRows - 1; r++) {
+        cy -= rowHeights[r];
+        const divY = cy - rowDividerThickness / 2;
+        for (let c = 0; c < numCols; c++) {
+            addBox(mesh, frameMaterial, colWidths[c], rowDividerThickness, frameDepth, colXCenters[c], divY, 0);
+        }
+        cy -= rowDividerThickness;
+    }
+    // Glass panes
+    const glassDepth = Math.max(0.004, frameDepth * 0.08);
+    for (let c = 0; c < numCols; c++) {
+        for (let r = 0; r < numRows; r++) {
+            addBox(mesh, glassMaterial, colWidths[c], rowHeights[r], glassDepth, colXCenters[c], rowYCenters[r], 0);
+        }
+    }
+    // ── Sill ──
+    if (sill) {
+        const sillW = width + sillDepth * 0.4; // slightly wider than frame
+        // Protrudes from the front face of the frame (+Z)
+        const sillZ = frameDepth / 2 + sillDepth / 2;
+        addBox(mesh, frameMaterial, sillW, sillThickness, sillDepth, 0, -height / 2 - sillThickness / 2, sillZ);
+    }
+    // ── Cutout (for wall CSG) — always full window dimensions, 1m deep ──
+    let cutout = mesh.getObjectByName('cutout');
+    if (!cutout) {
+        cutout = new THREE.Mesh();
+        cutout.name = 'cutout';
+        mesh.add(cutout);
+    }
+    cutout.geometry.dispose();
+    cutout.geometry = new THREE.BoxGeometry(node.width, node.height, 1.0);
+    cutout.visible = false;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pascal-app/core",
-  "version": "0.1.12",
+  "version": "0.2.0",
   "description": "Core library for Pascal 3D building editor",
   "type": "module",
   "main": "./dist/index.js",
@@ -25,24 +25,24 @@
     "@react-three/drei": "^10",
     "@react-three/fiber": "^9",
     "react": "^18 || ^19",
-    "three": "^0.182"
+    "three": "^0.183"
   },
   "dependencies": {
     "dedent": "^1.7.1",
     "idb-keyval": "^6.2.2",
     "mitt": "^3.0.1",
     "nanoid": "^5.1.6",
-    "three-bvh-csg": "^0.0.17",
+    "three-bvh-csg": "^0.0.18",
     "three-mesh-bvh": "^0.9.8",
     "zod": "^4.3.5",
     "zundo": "^2.3.0",
     "zustand": "^5"
   },
   "devDependencies": {
-    "@repo/typescript-config": "*",
+    "@pascal/typescript-config": "*",
     "@types/react": "^19.2.2",
-    "typescript": "5.9.2",
-    "@types/three": "^0.182.0"
+    "typescript": "5.9.3",
+    "@types/three": "^0.183.0"
   },
   "keywords": [
     "3d",
@@ -54,8 +54,10 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/your-username/pascal-editor.git",
+    "url": "https://github.com/pascalorg/editor.git",
     "directory": "packages/core"
   },
-  "license": "MIT"
+  "license": "MIT",
+  "homepage": "https://github.com/pascalorg/editor/tree/main/packages/core#readme",
+  "bugs": "https://github.com/pascalorg/editor/issues"
 }