@pascal-app/core 0.1.3

package/dist/store/use-scene.js

@@ -0,0 +1,127 @@
+'use client';
+import { temporal } from 'zundo';
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+import { BuildingNode } from '../schema';
+import { LevelNode } from '../schema/nodes/level';
+import { isObject } from '../utils/types';
+import * as nodeActions from './actions/node-actions';
+const useScene = create()(persist(temporal((set, get) => ({
+    // 1. Flat dictionary of all nodes
+    nodes: {},
+    // 2. Root node IDs
+    rootNodeIds: [],
+    // 3. Dirty set
+    dirtyNodes: new Set(),
+    clearScene: () => {
+        set({
+            nodes: {},
+            rootNodeIds: [],
+            dirtyNodes: new Set(),
+        });
+        get().loadScene(); // Default scene
+    },
+    setScene: (nodes, rootNodeIds) => {
+        set({
+            nodes,
+            rootNodeIds,
+            dirtyNodes: new Set(),
+        });
+        // Mark all nodes as dirty to trigger re-validation
+        Object.values(nodes).forEach((node) => {
+            get().markDirty(node.id);
+        });
+    },
+    loadScene: () => {
+        if (get().rootNodeIds.length > 0) {
+            // Assign all nodes as dirty to force re-validation
+            Object.values(get().nodes).forEach((node) => {
+                get().markDirty(node.id);
+            });
+            return; // Scene already loaded
+        }
+        const building = BuildingNode.parse({
+            children: [],
+        });
+        const level0 = LevelNode.parse({
+            level: 0,
+            children: [],
+        });
+        building.children.push(level0.id);
+        // Define all nodes flat
+        const nodes = {
+            [building.id]: building,
+            [level0.id]: level0,
+        };
+        // Root nodes are the levels
+        const rootNodeIds = [building.id];
+        set({ nodes, rootNodeIds });
+    },
+    markDirty: (id) => {
+        get().dirtyNodes.add(id);
+    },
+    clearDirty: (id) => {
+        get().dirtyNodes.delete(id);
+    },
+    createNodes: (ops) => nodeActions.createNodesAction(set, get, ops),
+    createNode: (node, parentId) => nodeActions.createNodesAction(set, get, [{ node, parentId }]),
+    updateNodes: (updates) => nodeActions.updateNodesAction(set, get, updates),
+    updateNode: (id, data) => nodeActions.updateNodesAction(set, get, [{ id, data }]),
+    // --- DELETE ---
+    deleteNodes: (ids) => nodeActions.deleteNodesAction(set, get, ids),
+    deleteNode: (id) => nodeActions.deleteNodesAction(set, get, [id]),
+}), {
+    partialize: (state) => {
+        const { nodes, rootNodeIds } = state; // Only track nodes and rootNodeIds in history
+        return { nodes, rootNodeIds };
+    },
+    limit: 50, // Limit to last 50 actions
+}), {
+    name: 'editor-storage',
+    partialize: (state) => ({
+        nodes: Object.fromEntries(Object.entries(state.nodes).filter(([_, node]) => {
+            const meta = node.metadata;
+            const isTransient = isObject(meta) && 'isTransient' in meta && meta.isTransient === true;
+            return !isTransient;
+        })),
+        rootNodeIds: state.rootNodeIds,
+    }),
+    onRehydrateStorage: (state) => {
+        console.log('hydrating...');
+        // optional
+        return (state, error) => {
+            if (error) {
+                console.log('an error happened during hydration', error);
+            }
+            else {
+                console.log('hydration finished');
+            }
+        };
+    },
+}));
+export default useScene;
+// Track previous temporal state lengths
+let prevPastLength = 0;
+let prevFutureLength = 0;
+// Subscribe to the temporal store (Undo/Redo events)
+useScene.temporal.subscribe((state) => {
+    const currentPastLength = state.pastStates.length;
+    const currentFutureLength = state.futureStates.length;
+    // Undo: futureStates increases (state moved from past to future)
+    // Redo: pastStates increases while futureStates decreases (state moved from future to past)
+    const didUndo = currentFutureLength > prevFutureLength;
+    const didRedo = currentPastLength > prevPastLength && currentFutureLength < prevFutureLength;
+    if (didUndo || didRedo) {
+        // Use RAF to ensure all middleware and store updates are complete
+        requestAnimationFrame(() => {
+            const currentNodes = useScene.getState().nodes;
+            // Trigger a full scene re-validation after undo/redo
+            Object.values(currentNodes).forEach((node) => {
+                useScene.getState().markDirty(node.id);
+            });
+        });
+    }
+    // Update tracked lengths
+    prevPastLength = currentPastLength;
+    prevFutureLength = currentFutureLength;
+});

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

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import type { CeilingNode } from '../../schema';
+export declare const CeilingSystem: () => null;
+/**
+ * Generates flat ceiling geometry from polygon (no extrusion)
+ */
+export declare function generateCeilingGeometry(ceilingNode: CeilingNode): THREE.BufferGeometry;
+//# sourceMappingURL=ceiling-system.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ceiling-system.d.ts","sourceRoot":"","sources":["../../../src/systems/ceiling/ceiling-system.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,KAAK,EAAa,WAAW,EAAE,MAAM,cAAc,CAAA;AAO1D,eAAO,MAAM,aAAa,YAuBzB,CAAA;AAeD;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,WAAW,GAAG,KAAK,CAAC,cAAc,CA6BtF"}

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

@@ -0,0 +1,65 @@
+import { useFrame } from '@react-three/fiber';
+import * as THREE from 'three';
+import { sceneRegistry } from '../../hooks/scene-registry/scene-registry';
+import useScene from '../../store/use-scene';
+// ============================================================================
+// CEILING SYSTEM
+// ============================================================================
+export const CeilingSystem = () => {
+    const dirtyNodes = useScene((state) => state.dirtyNodes);
+    const clearDirty = useScene((state) => state.clearDirty);
+    useFrame(() => {
+        if (dirtyNodes.size === 0)
+            return;
+        const nodes = useScene.getState().nodes;
+        // Process dirty ceilings
+        dirtyNodes.forEach((id) => {
+            const node = nodes[id];
+            if (!node || node.type !== 'ceiling')
+                return;
+            const mesh = sceneRegistry.nodes.get(id);
+            if (mesh) {
+                updateCeilingGeometry(node, mesh);
+                clearDirty(id);
+            }
+            // If mesh not found, keep it dirty for next frame
+        });
+    });
+    return null;
+};
+/**
+ * Updates the geometry for a single ceiling
+ */
+function updateCeilingGeometry(node, mesh) {
+    const newGeo = generateCeilingGeometry(node);
+    mesh.geometry.dispose();
+    mesh.geometry = newGeo;
+    // Position at the ceiling height
+    mesh.position.y = (node.height ?? 2.5) - 0.01; // Slight offset to avoid z-fighting with upper-level slabs
+}
+/**
+ * Generates flat ceiling geometry from polygon (no extrusion)
+ */
+export function generateCeilingGeometry(ceilingNode) {
+    const polygon = ceilingNode.polygon;
+    if (polygon.length < 3) {
+        return new THREE.BufferGeometry();
+    }
+    // Create shape from polygon
+    // Shape is in X-Y plane, we'll rotate to X-Z plane
+    const shape = new THREE.Shape();
+    const firstPt = polygon[0];
+    // Negate Y (which becomes Z) to get correct orientation after rotation
+    shape.moveTo(firstPt[0], -firstPt[1]);
+    for (let i = 1; i < polygon.length; i++) {
+        const pt = polygon[i];
+        shape.lineTo(pt[0], -pt[1]);
+    }
+    shape.closePath();
+    // Create flat shape geometry (no extrusion)
+    const geometry = new THREE.ShapeGeometry(shape);
+    // Rotate so the shape lies flat in X-Z plane
+    geometry.rotateX(-Math.PI / 2);
+    geometry.computeVertexNormals();
+    return geometry;
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"item-system.d.ts","sourceRoot":"","sources":["../../../src/systems/item/item-system.tsx"],"names":[],"mappings":"AAYA,eAAO,MAAM,UAAU,YAyCtB,CAAA"}

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

@@ -0,0 +1,43 @@
+import { useFrame } from '@react-three/fiber';
+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';
+// ============================================================================
+// ITEM SYSTEM
+// ============================================================================
+export const ItemSystem = () => {
+    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 !== 'item')
+                return;
+            const item = node;
+            const mesh = sceneRegistry.nodes.get(id);
+            if (!mesh)
+                return;
+            if (item.asset.attachTo === 'wall-side') {
+                // Wall-attached item: offset Z by half the parent wall's thickness
+                const parentWall = item.parentId ? nodes[item.parentId] : undefined;
+                if (parentWall && parentWall.type === 'wall') {
+                    const wallThickness = parentWall.thickness ?? 0.1;
+                    const side = item.side === 'front' ? 1 : -1;
+                    mesh.position.z = (wallThickness / 2) * side;
+                }
+            }
+            else if (!item.asset.attachTo) {
+                // Floor item: elevate by slab height (using full footprint overlap)
+                const levelId = resolveLevelId(item, nodes);
+                const slabElevation = spatialGridManager.getSlabElevationForItem(levelId, item.position, item.asset.dimensions, item.rotation);
+                mesh.position.y = slabElevation;
+            }
+            clearDirty(id);
+        });
+    });
+    return null;
+};

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

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import type { RoofNode } from '../../schema';
+export declare const RoofSystem: () => null;
+/**
+ * Generates detailed gable roof geometry with layers, walls, and overhangs
+ */
+export declare function generateRoofGeometry(roofNode: RoofNode): THREE.BufferGeometry;
+//# sourceMappingURL=roof-system.d.ts.map

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

@@ -0,0 +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,KAAK,EAAa,QAAQ,EAAE,MAAM,cAAc,CAAA;AAmBvD,eAAO,MAAM,UAAU,YAwBtB,CAAA;AAqJD;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,GAAG,KAAK,CAAC,cAAc,CAsH7E"}

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

@@ -0,0 +1,254 @@
+import { useFrame } from '@react-three/fiber';
+import * as THREE from 'three';
+import { sceneRegistry } from '../../hooks/scene-registry/scene-registry';
+import useScene from '../../store/use-scene';
+// ============================================================================
+// ROOF GEOMETRY CONSTANTS
+// ============================================================================
+const THICKNESS_A = 0.05; // Roof cover thickness (5cm)
+const THICKNESS_B = 0.1; // Structure thickness (10cm)
+const ROOF_COVER_OVERHANG = 0.05; // Extension of cover past structure (5cm)
+const EAVE_OVERHANG = 0.4; // Horizontal eave overhang (40cm)
+const RAKE_OVERHANG = 0.3; // Overhang at gable ends (30cm)
+const WALL_THICKNESS = 0.2; // Gable wall thickness (20cm)
+const BASE_HEIGHT = 0.5; // Base height / knee wall / truss heel (50cm)
+// ============================================================================
+// ROOF SYSTEM
+// ============================================================================
+export const RoofSystem = () => {
+    const dirtyNodes = useScene((state) => state.dirtyNodes);
+    const clearDirty = useScene((state) => state.clearDirty);
+    useFrame(() => {
+        if (dirtyNodes.size === 0)
+            return;
+        const nodes = useScene.getState().nodes;
+        // Process dirty roofs
+        dirtyNodes.forEach((id) => {
+            const node = nodes[id];
+            if (!node || node.type !== 'roof')
+                return;
+            const mesh = sceneRegistry.nodes.get(id);
+            if (mesh) {
+                updateRoofGeometry(node, mesh);
+                clearDirty(id);
+            }
+            // If mesh not found, keep it dirty for next frame
+        });
+    });
+    return null;
+};
+/**
+ * Updates the geometry and transform for a single roof
+ */
+function updateRoofGeometry(node, mesh) {
+    const newGeo = generateRoofGeometry(node);
+    mesh.geometry.dispose();
+    mesh.geometry = newGeo;
+    // Update position and rotation
+    mesh.position.set(node.position[0], node.position[1], node.position[2]);
+    mesh.rotation.y = node.rotation;
+}
+/**
+ * Helper to solve pitch angle analytically given rise, run and thicknesses
+ * Solves: run * tan(a) + (ThickA + ThickB)/cos(a) = rise
+ */
+function solvePitch(rise, run, thickA, thickB) {
+    const T = thickA + thickB;
+    if (run < 0.01)
+        return 0;
+    const R = Math.sqrt(run * run + rise * rise);
+    if (R <= T) {
+        return Math.atan2(rise, run) * 0.5; // Fallback
+    }
+    const phi = Math.atan2(rise, run);
+    const shift = Math.asin(T / R);
+    return phi - shift;
+}
+/**
+ * Helper to create a Three.js Shape from polygon points
+ */
+function createShape(points) {
+    const shape = new THREE.Shape();
+    if (points.length === 0)
+        return shape;
+    const firstPoint = points[0];
+    if (!firstPoint)
+        return shape;
+    shape.moveTo(firstPoint.x, firstPoint.y);
+    for (let i = 1; i < points.length; i++) {
+        const point = points[i];
+        if (point) {
+            shape.lineTo(point.x, point.y);
+        }
+    }
+    shape.closePath();
+    return shape;
+}
+/**
+ * Generate profile for one side of the roof (left or right)
+ */
+function getSideProfile(dir, width, roofHeight) {
+    const halfWall = WALL_THICKNESS / 2;
+    const rise = Math.max(0, roofHeight - BASE_HEIGHT);
+    const run = width - halfWall;
+    const angle = solvePitch(rise, run, THICKNESS_A, THICKNESS_B);
+    const tanA = Math.tan(angle);
+    const cosA = Math.cos(angle);
+    const sinA = Math.sin(angle);
+    const ridgeUnderY = BASE_HEIGHT + run * tanA;
+    const ridgeInterfaceY = ridgeUnderY + THICKNESS_B / cosA;
+    const ridgeTopY = ridgeInterfaceY + THICKNESS_A / cosA;
+    const wallOuterTopY = BASE_HEIGHT - WALL_THICKNESS * tanA;
+    const overhangDx = EAVE_OVERHANG * cosA;
+    const eaveTopZ = width + halfWall + overhangDx;
+    const eaveTopY = ridgeTopY - eaveTopZ * tanA;
+    const coverExtDx = ROOF_COVER_OVERHANG * cosA;
+    const coverExtDy = ROOF_COVER_OVERHANG * sinA;
+    const eaveTopExtZ = eaveTopZ + coverExtDx;
+    const eaveTopExtY = eaveTopY - coverExtDy;
+    const eaveInterfaceExtZ = eaveTopExtZ - THICKNESS_A * sinA;
+    const eaveInterfaceExtY = eaveTopExtY - THICKNESS_A * cosA;
+    const eaveInterfaceZ = eaveTopZ;
+    const eaveBottomZ = eaveTopZ;
+    const eaveBottomY = ridgeUnderY - eaveTopZ * tanA;
+    // Layer A (Cover)
+    const pointsA = [
+        { x: 0, y: ridgeTopY },
+        { x: dir * eaveTopExtZ, y: eaveTopExtY },
+        { x: dir * eaveInterfaceExtZ, y: eaveInterfaceExtY },
+        { x: 0, y: ridgeInterfaceY },
+    ];
+    // Layer B (Structure)
+    const pointsB = [
+        { x: 0, y: ridgeInterfaceY },
+        { x: dir * eaveInterfaceZ, y: ridgeInterfaceY - eaveTopZ * tanA },
+        { x: dir * eaveBottomZ, y: eaveBottomY },
+        { x: 0, y: ridgeUnderY },
+    ];
+    // Side Wall
+    const zInner = width - halfWall;
+    const zOuter = width + halfWall;
+    const pointsSide = [
+        { x: dir * zInner, y: 0 },
+        { x: dir * zOuter, y: 0 },
+        { x: dir * zOuter, y: Math.max(0, wallOuterTopY) },
+        { x: dir * zInner, y: BASE_HEIGHT },
+    ];
+    // Gable Top (C1)
+    const pointsC1 = [
+        { x: 0, y: BASE_HEIGHT },
+        { x: dir * zInner, y: BASE_HEIGHT },
+        { x: dir * zInner, y: BASE_HEIGHT },
+        { x: 0, y: ridgeUnderY },
+    ];
+    // Gable Base (C2)
+    const pointsC2 = [
+        { x: 0, y: 0 },
+        { x: dir * zInner, y: 0 },
+        { x: dir * zInner, y: BASE_HEIGHT },
+        { x: 0, y: BASE_HEIGHT },
+    ];
+    return { pointsA, pointsB, pointsSide, pointsC1, pointsC2 };
+}
+/**
+ * Generates detailed gable roof geometry with layers, walls, and overhangs
+ */
+export function generateRoofGeometry(roofNode) {
+    const { length, height, leftWidth, rightWidth } = roofNode;
+    const ridgeLength = length;
+    // Get profiles for both sides
+    const leftP = getSideProfile(1, leftWidth, height);
+    const rightP = getSideProfile(-1, rightWidth, height);
+    // Create shapes from profiles
+    const shapes = {
+        ALeft: createShape(leftP.pointsA),
+        ARight: createShape(rightP.pointsA),
+        BLeft: createShape(leftP.pointsB),
+        BRight: createShape(rightP.pointsB),
+        SideLeft: createShape(leftP.pointsSide),
+        SideRight: createShape(rightP.pointsSide),
+        C1Left: createShape(leftP.pointsC1),
+        C1Right: createShape(rightP.pointsC1),
+        C2Left: createShape(leftP.pointsC2),
+        C2Right: createShape(rightP.pointsC2),
+    };
+    // Calculate extrusion lengths and offsets
+    const lengths = {
+        A: ridgeLength + 2 * RAKE_OVERHANG + 2 * ROOF_COVER_OVERHANG + WALL_THICKNESS,
+        B: ridgeLength + 2 * RAKE_OVERHANG + WALL_THICKNESS,
+        Side: ridgeLength + WALL_THICKNESS,
+        Gable: WALL_THICKNESS,
+    };
+    const offsets = {
+        A: -RAKE_OVERHANG - ROOF_COVER_OVERHANG - WALL_THICKNESS / 2,
+        B: -RAKE_OVERHANG - WALL_THICKNESS / 2,
+        Side: -WALL_THICKNESS / 2,
+        GableFront: -WALL_THICKNESS / 2,
+        GableBack: ridgeLength - WALL_THICKNESS / 2,
+    };
+    // Helper to create and position extruded geometry
+    const createPart = (shape, depth, xOffset) => {
+        const geo = new THREE.ExtrudeGeometry(shape, { depth, bevelEnabled: false });
+        // Rotate to align: extrusion goes along X axis
+        geo.rotateY(Math.PI / 2);
+        geo.translate(xOffset, 0, 0);
+        return geo;
+    };
+    // Create all parts
+    const geometries = [];
+    // Layer A (Cover) - both sides
+    geometries.push(createPart(shapes.ALeft, lengths.A, offsets.A));
+    geometries.push(createPart(shapes.ARight, lengths.A, offsets.A));
+    // Layer B (Structure) - both sides
+    geometries.push(createPart(shapes.BLeft, lengths.B, offsets.B));
+    geometries.push(createPart(shapes.BRight, lengths.B, offsets.B));
+    // Side Walls - both sides
+    geometries.push(createPart(shapes.SideLeft, lengths.Side, offsets.Side));
+    geometries.push(createPart(shapes.SideRight, lengths.Side, offsets.Side));
+    // Gable Walls (Front)
+    geometries.push(createPart(shapes.C1Left, lengths.Gable, offsets.GableFront));
+    geometries.push(createPart(shapes.C1Right, lengths.Gable, offsets.GableFront));
+    geometries.push(createPart(shapes.C2Left, lengths.Gable, offsets.GableFront));
+    geometries.push(createPart(shapes.C2Right, lengths.Gable, offsets.GableFront));
+    // Gable Walls (Back)
+    geometries.push(createPart(shapes.C1Left, lengths.Gable, offsets.GableBack));
+    geometries.push(createPart(shapes.C1Right, lengths.Gable, offsets.GableBack));
+    geometries.push(createPart(shapes.C2Left, lengths.Gable, offsets.GableBack));
+    geometries.push(createPart(shapes.C2Right, lengths.Gable, offsets.GableBack));
+    // Merge all geometries
+    const mergedGeometry = new THREE.BufferGeometry();
+    const positions = [];
+    const normals = [];
+    const uvs = [];
+    for (const geo of geometries) {
+        const posAttr = geo.getAttribute('position');
+        const normAttr = geo.getAttribute('normal');
+        const uvAttr = geo.getAttribute('uv');
+        if (posAttr) {
+            for (let i = 0; i < posAttr.count; i++) {
+                positions.push(posAttr.getX(i), posAttr.getY(i), posAttr.getZ(i));
+            }
+        }
+        if (normAttr) {
+            for (let i = 0; i < normAttr.count; i++) {
+                normals.push(normAttr.getX(i), normAttr.getY(i), normAttr.getZ(i));
+            }
+        }
+        if (uvAttr) {
+            for (let i = 0; i < uvAttr.count; i++) {
+                uvs.push(uvAttr.getX(i), uvAttr.getY(i));
+            }
+        }
+        geo.dispose();
+    }
+    mergedGeometry.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
+    mergedGeometry.setAttribute('normal', new THREE.Float32BufferAttribute(normals, 3));
+    if (uvs.length > 0) {
+        mergedGeometry.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
+    }
+    mergedGeometry.computeVertexNormals();
+    // Center the geometry at X=0 (translate by -ridgeLength/2)
+    // This matches the old geometry centering behavior
+    mergedGeometry.translate(-ridgeLength / 2, 0, 0);
+    return mergedGeometry;
+}

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

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import type { SlabNode } from '../../schema';
+export declare const SlabSystem: () => null;
+/**
+ * Generates extruded slab geometry from polygon
+ */
+export declare function generateSlabGeometry(slabNode: SlabNode): THREE.BufferGeometry;
+//# sourceMappingURL=slab-system.d.ts.map

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

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

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

@@ -0,0 +1,117 @@
+import { useFrame } from '@react-three/fiber';
+import * as THREE from 'three';
+import { sceneRegistry } from '../../hooks/scene-registry/scene-registry';
+import useScene from '../../store/use-scene';
+// ============================================================================
+// SLAB SYSTEM
+// ============================================================================
+export const SlabSystem = () => {
+    const dirtyNodes = useScene((state) => state.dirtyNodes);
+    const clearDirty = useScene((state) => state.clearDirty);
+    useFrame(() => {
+        if (dirtyNodes.size === 0)
+            return;
+        const nodes = useScene.getState().nodes;
+        // Process dirty slabs
+        dirtyNodes.forEach((id) => {
+            const node = nodes[id];
+            if (!node || node.type !== 'slab')
+                return;
+            const mesh = sceneRegistry.nodes.get(id);
+            if (mesh) {
+                updateSlabGeometry(node, mesh);
+                clearDirty(id);
+            }
+            // If mesh not found, keep it dirty for next frame
+        });
+    });
+    return null;
+};
+/**
+ * Updates the geometry for a single slab
+ */
+function updateSlabGeometry(node, mesh) {
+    const newGeo = generateSlabGeometry(node);
+    mesh.geometry.dispose();
+    mesh.geometry = newGeo;
+}
+/** Half of default wall thickness — used to extend slab geometry under walls */
+const SLAB_OUTSET = 0.05;
+/**
+ * Expand a polygon outward by a uniform distance.
+ * Offsets each edge outward then intersects consecutive offset edges.
+ */
+function outsetPolygon(polygon, amount) {
+    const n = polygon.length;
+    if (n < 3)
+        return polygon;
+    // Determine winding via signed area
+    let area2 = 0;
+    for (let i = 0; i < n; i++) {
+        const j = (i + 1) % n;
+        area2 += polygon[i][0] * polygon[j][1] - polygon[j][0] * polygon[i][1];
+    }
+    const s = area2 >= 0 ? 1 : -1;
+    // Offset each edge outward by amount
+    const offEdges = [];
+    for (let i = 0; i < n; i++) {
+        const j = (i + 1) % n;
+        const dx = polygon[j][0] - polygon[i][0];
+        const dz = polygon[j][1] - polygon[i][1];
+        const len = Math.sqrt(dx * dx + dz * dz);
+        if (len < 1e-9) {
+            offEdges.push([polygon[i][0], polygon[i][1], dx, dz]);
+            continue;
+        }
+        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
+    const result = [];
+    for (let i = 0; i < n; i++) {
+        const j = (i + 1) % n;
+        const [ax, az, adx, adz] = offEdges[i];
+        const [bx, bz, bdx, bdz] = offEdges[j];
+        const denom = adx * bdz - adz * bdx;
+        if (Math.abs(denom) < 1e-9) {
+            // Parallel edges — use offset endpoint
+            result.push([ax + adx, az + adz]);
+        }
+        else {
+            const t = ((bx - ax) * bdz - (bz - az) * bdx) / denom;
+            result.push([ax + t * adx, az + t * adz]);
+        }
+    }
+    return result;
+}
+/**
+ * Generates extruded slab geometry from polygon
+ */
+export function generateSlabGeometry(slabNode) {
+    const polygon = outsetPolygon(slabNode.polygon, SLAB_OUTSET);
+    const elevation = slabNode.elevation ?? 0.05;
+    if (polygon.length < 3) {
+        return new THREE.BufferGeometry();
+    }
+    // Create shape from polygon
+    // Shape is in X-Y plane, we'll rotate to X-Z plane after extrusion
+    const shape = new THREE.Shape();
+    const firstPt = polygon[0];
+    // Negate Y (which becomes Z) to get correct orientation after rotation
+    shape.moveTo(firstPt[0], -firstPt[1]);
+    for (let i = 1; i < polygon.length; i++) {
+        const pt = polygon[i];
+        shape.lineTo(pt[0], -pt[1]);
+    }
+    shape.closePath();
+    // Extrude the shape by elevation
+    const geometry = new THREE.ExtrudeGeometry(shape, {
+        depth: elevation,
+        bevelEnabled: false,
+    });
+    // Rotate so extrusion direction (Z) becomes height direction (Y)
+    geometry.rotateX(-Math.PI / 2);
+    geometry.computeVertexNormals();
+    return geometry;
+}