@pascal-app/viewer 0.7.0 → 0.9.1

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

@@ -1,4 +1,4 @@
-import { calculateLevelMiters, DEFAULT_WALL_HEIGHT, getAdjacentWallIds, getWallCurveFrameAt, getWallMiterBoundaryPoints, getWallPlanFootprint, getWallSurfacePolygon, getWallThickness, isCurvedWall, pointToKey, resolveLevelId, sceneRegistry, spatialGridManager, useScene, } from '@pascal-app/core';
+import { calculateLevelMiters, DEFAULT_WALL_HEIGHT, getAdjacentWallIds, getEffectiveNode, getWallCurveFrameAt, getWallMiterBoundaryPoints, getWallPlanFootprint, getWallSurfacePolygon, getWallThickness, isCurvedWall, pointToKey, resolveLevelId, sceneRegistry, spatialGridManager, useLiveNodeOverrides, useLiveTransforms, useScene, } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
 import * as THREE from 'three';
 import { Brush, Evaluator, SUBTRACTION } from 'three-bvh-csg';
@@ -13,6 +13,9 @@ function computeGeometryBoundsTree(geometry) {
     geometry.computeBoundsTree = computeBoundsTree;
     geometry.computeBoundsTree({ maxLeafSize: 10 });
 }
+function csgGeometry(brush) {
+    return brush.geometry;
+}
 function ensureUv2Attribute(geometry) {
     const uv = geometry.getAttribute('uv');
     if (!uv)
@@ -20,7 +23,7 @@ function ensureUv2Attribute(geometry) {
     geometry.setAttribute('uv2', new THREE.Float32BufferAttribute(Array.from(uv.array), 2));
 }
 function insetCurvedWallBoundaryPointsFor3D(wall, boundaryPoints, miterData) {
-    if (!boundaryPoints || !isCurvedWall(wall)) {
+    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));
@@ -205,49 +208,158 @@ function assignWallMaterialGroups(geometry, wall, boundaryEdges) {
 // WALL SYSTEM
 // ============================================================================
 let useFrameNb = 0;
+// ─── Drag-throttle state (singleton — one WallSystem mounted globally) ──
+//
+// Endpoint drags fire `markDirty(wallId)` on every pointermove tick. Without
+// throttling, each tick rebuilds the dragged wall (~1 CSG + miter pass) AND
+// every adjacent wall sharing a corner (3–4× in a t-junction or room).
+// Visible as drag lag, especially on walls with door/window cutouts.
+//
+// Strategy: rebuild the dragged wall every tick (so the drag follows the
+// cursor with full fidelity), but defer adjacent rebuilds to a trailing-
+// edge flush DRAG_FLUSH_MS after the dirty stream stops. Visually, neighbor
+// corners stay at their pre-drag miter until release, then snap into place
+// within ~80ms. Standard CAD-app behavior. Speeds up t-junction drags ~3×,
+// 4-corner-room drags ~4×.
+const DRAG_FLUSH_MS = 80;
+const MAX_WALL_REBUILDS_PER_FRAME = 8;
+const WALL_PROGRESSIVE_DIRTY_THRESHOLD = MAX_WALL_REBUILDS_PER_FRAME;
+const WALL_PROGRESSIVE_TIME_BUDGET_MS = 8;
+let lastWallDirtyAtMs = 0;
+const pendingAdjacentByLevel = new Map();
+function getPendingAdjacentCount() {
+    let count = 0;
+    for (const ids of pendingAdjacentByLevel.values()) {
+        count += ids.size;
+    }
+    return count;
+}
 export const WallSystem = () => {
     const dirtyNodes = useScene((state) => state.dirtyNodes);
     const clearDirty = useScene((state) => state.clearDirty);
+    // Subscribe so override-only changes (no scene write) still re-run
+    // this component, which lets the gate below pick up the latest
+    // `dirtyNodes` set from the same render pass that received the
+    // override-publishing `markDirty` call. Without this, very fast
+    // drags could land an override and a markDirty in the same React
+    // tick and the next `useFrame` would still see the stale closure.
+    useLiveNodeOverrides((s) => s.overrides);
     useFrame(() => {
-        if (dirtyNodes.size === 0)
+        const hasDirty = dirtyNodes.size > 0;
+        const hasPending = pendingAdjacentByLevel.size > 0;
+        if (!hasDirty && !hasPending)
             return;
         const nodes = useScene.getState().nodes;
+        const now = performance.now();
         // Collect dirty walls and their levels
         const dirtyWallsByLevel = new Map();
+        let dirtyWallCount = 0;
         useFrameNb += 1;
-        dirtyNodes.forEach((id) => {
-            const node = nodes[id];
-            if (!node || node.type !== 'wall')
-                return;
-            const levelId = node.parentId;
-            if (!levelId)
-                return;
-            if (!dirtyWallsByLevel.has(levelId)) {
-                dirtyWallsByLevel.set(levelId, new Set());
-            }
-            dirtyWallsByLevel.get(levelId)?.add(id);
-        });
+        if (hasDirty) {
+            dirtyNodes.forEach((id) => {
+                const node = nodes[id];
+                if (!node || node.type !== 'wall')
+                    return;
+                const levelId = node.parentId;
+                if (!levelId)
+                    return;
+                if (!dirtyWallsByLevel.has(levelId)) {
+                    dirtyWallsByLevel.set(levelId, new Set());
+                }
+                dirtyWallsByLevel.get(levelId)?.add(id);
+                dirtyWallCount += 1;
+            });
+        }
+        const hasDirtyWalls = dirtyWallsByLevel.size > 0;
+        if (hasDirtyWalls) {
+            lastWallDirtyAtMs = now;
+        }
+        const useProgressiveWallRebuilds = dirtyWallCount > WALL_PROGRESSIVE_DIRTY_THRESHOLD;
+        let rebuiltWallsThisFrame = 0;
+        const rebuildFrameStartedAt = now;
         // Process each level that has dirty walls
         for (const [levelId, dirtyWallIds] of dirtyWallsByLevel) {
+            if (useProgressiveWallRebuilds && rebuiltWallsThisFrame >= MAX_WALL_REBUILDS_PER_FRAME) {
+                break;
+            }
             const levelWalls = getLevelWalls(levelId);
             const miterData = calculateLevelMiters(levelWalls);
-            // Update dirty walls
+            const rebuiltWallIds = new Set();
+            // Update dirty walls — always, no throttling. The dragged wall must
+            // follow the cursor with full fidelity (cutouts and all). Large imports
+            // enter the progressive path so initial load can't lock the tab.
             for (const wallId of dirtyWallIds) {
+                if (useProgressiveWallRebuilds) {
+                    if (rebuiltWallsThisFrame >= MAX_WALL_REBUILDS_PER_FRAME) {
+                        break;
+                    }
+                    if (rebuiltWallsThisFrame > 0 &&
+                        performance.now() - rebuildFrameStartedAt >= WALL_PROGRESSIVE_TIME_BUDGET_MS) {
+                        break;
+                    }
+                }
                 const mesh = sceneRegistry.nodes.get(wallId);
                 if (mesh) {
                     updateWallGeometry(wallId, miterData);
                     clearDirty(wallId);
+                    rebuiltWallIds.add(wallId);
+                    rebuiltWallsThisFrame += 1;
                 }
                 // If mesh not found, keep it dirty for next frame
             }
-            // Update adjacent walls that share junctions
-            const adjacentWallIds = getAdjacentWallIds(levelWalls, dirtyWallIds);
+            if (rebuiltWallIds.size === 0) {
+                continue;
+            }
+            // Adjacent walls sharing junctions — *defer* during active drag
+            // (dirty arrived this frame), flush on the trailing edge.
+            const adjacentWallIds = getAdjacentWallIds(levelWalls, rebuiltWallIds);
+            let pending = pendingAdjacentByLevel.get(levelId);
+            if (!pending) {
+                pending = new Set();
+                pendingAdjacentByLevel.set(levelId, pending);
+            }
             for (const wallId of adjacentWallIds) {
                 if (!dirtyWallIds.has(wallId)) {
+                    pending.add(wallId);
+                }
+            }
+        }
+        // Trailing-edge flush: if no new dirty marks for DRAG_FLUSH_MS, the
+        // drag has ended — rebuild the queued neighbors so corners snap into
+        // their correct miter joins.
+        const quiet = !hasDirtyWalls && now - lastWallDirtyAtMs >= DRAG_FLUSH_MS;
+        if (quiet && pendingAdjacentByLevel.size > 0) {
+            const pendingCount = getPendingAdjacentCount();
+            const useProgressiveAdjacentRebuilds = pendingCount > WALL_PROGRESSIVE_DIRTY_THRESHOLD;
+            let rebuiltAdjacentThisFrame = 0;
+            const adjacentFrameStartedAt = performance.now();
+            for (const [levelId, pendingIds] of pendingAdjacentByLevel) {
+                if (pendingIds.size === 0)
+                    continue;
+                const levelWalls = getLevelWalls(levelId);
+                const miterData = calculateLevelMiters(levelWalls);
+                for (const wallId of Array.from(pendingIds)) {
+                    if (useProgressiveAdjacentRebuilds) {
+                        if (rebuiltAdjacentThisFrame >= MAX_WALL_REBUILDS_PER_FRAME) {
+                            break;
+                        }
+                        if (rebuiltAdjacentThisFrame > 0 &&
+                            performance.now() - adjacentFrameStartedAt >= WALL_PROGRESSIVE_TIME_BUDGET_MS) {
+                            break;
+                        }
+                    }
                     const mesh = sceneRegistry.nodes.get(wallId);
-                    if (mesh) {
+                    if (mesh)
                         updateWallGeometry(wallId, miterData);
-                    }
+                    pendingIds.delete(wallId);
+                    rebuiltAdjacentThisFrame += 1;
+                }
+                if (pendingIds.size === 0) {
+                    pendingAdjacentByLevel.delete(levelId);
+                }
+                if (useProgressiveAdjacentRebuilds &&
+                    rebuiltAdjacentThisFrame >= MAX_WALL_REBUILDS_PER_FRAME) {
+                    break;
                 }
             }
         }
@@ -255,7 +367,22 @@ export const WallSystem = () => {
     return null;
 };
 /**
- * Gets all walls that belong to a level
+ * Merge any live override for a wall into the scene record. Lets the
+ * 2D move handler publish `{ start, end, curveOffset }` to
+ * `useLiveNodeOverrides` and have the geometry / miter pipeline use
+ * those values without zustand churn during the drag. When no
+ * override is set, the wall is returned unchanged.
+ */
+function getEffectiveWall(wall) {
+    const override = useLiveNodeOverrides.getState().get(wall.id);
+    if (!override || Object.keys(override).length === 0)
+        return wall;
+    return { ...wall, ...override };
+}
+/**
+ * Gets all walls that belong to a level, with any live overrides
+ * merged in so miters compute against the cursor-driven positions
+ * (not the pre-drag scene state).
  */
 function getLevelWalls(levelId) {
     const { nodes } = useScene.getState();
@@ -266,28 +393,49 @@ function getLevelWalls(levelId) {
     for (const childId of level.children) {
         const child = nodes[childId];
         if (child?.type === 'wall') {
-            walls.push(child);
+            walls.push(getEffectiveWall(child));
         }
     }
     return walls;
 }
 /**
- * Updates the geometry for a single wall
+ * Updates the geometry for a single wall. Reads the effective node
+ * (override-merged) so a 2D drag visibly moves the 3D mesh without
+ * having touched `useScene` mid-drag.
  */
 function updateWallGeometry(wallId, miterData) {
     const nodes = useScene.getState().nodes;
-    const node = nodes[wallId];
-    if (!node || node.type !== 'wall')
+    const sceneNode = nodes[wallId];
+    if (!sceneNode || sceneNode.type !== 'wall')
         return;
+    const node = getEffectiveWall(sceneNode);
     const mesh = sceneRegistry.nodes.get(wallId);
     if (!mesh)
         return;
     const levelId = resolveLevelId(node, nodes);
-    const slabElevation = spatialGridManager.getSlabElevationForWall(levelId, node.start, node.end);
+    const slabElevation = spatialGridManager.getSlabElevationForWall(levelId, node.start, node.end, node.curveOffset ?? 0, node.thickness);
     const childrenIds = node.children || [];
+    // Merge live overrides into door / window children so cutouts track an
+    // in-flight resize drag (door width arrow, window height arrow, etc.)
+    // without waiting on the scene store. Non-cutout children pass through
+    // unchanged.
     const childrenNodes = childrenIds
         .map((childId) => nodes[childId])
-        .filter((n) => n !== undefined);
+        .filter((n) => n !== undefined)
+        .map((child) => {
+        if (child.type !== 'door' && child.type !== 'window')
+            return child;
+        // `getEffectiveNode` folds in resize overrides (width/height arrows).
+        // Position moves publish to `useLiveTransforms` instead, so fold that
+        // in too — otherwise shaped openings (arch/rounded/`opening`), whose
+        // cutout brush is rebuilt from `node.position`, lag the live move
+        // (rectangular cutouts already track via the live mesh matrixWorld).
+        const effective = getEffectiveNode(child);
+        const live = useLiveTransforms.getState().get(child.id);
+        if (!live?.position)
+            return effective;
+        return { ...effective, position: live.position };
+    });
     const newGeo = generateExtrudedWall(node, childrenNodes, miterData, slabElevation);
     mesh.geometry.dispose();
     mesh.geometry = newGeo;
@@ -380,16 +528,16 @@ export function generateExtrudedWall(wallNode, childrenNodes, miterData, slabEle
         cutoutBrush.updateMatrixWorld();
         const newResult = csgEvaluator.evaluate(resultBrush, cutoutBrush, SUBTRACTION);
         if (resultBrush !== wallBrush) {
-            resultBrush.geometry.dispose();
+            csgGeometry(resultBrush).dispose();
         }
         resultBrush = newResult;
     }
     // Clean up
-    wallBrush.geometry.dispose();
+    csgGeometry(wallBrush).dispose();
     for (const brush of cutoutBrushes) {
-        brush.geometry.dispose();
+        csgGeometry(brush).dispose();
     }
-    const resultGeometry = resultBrush.geometry;
+    const resultGeometry = csgGeometry(resultBrush);
     resultGeometry.computeVertexNormals();
     assignWallMaterialGroups(resultGeometry, wallNode, boundaryEdges);
     ensureUv2Attribute(resultGeometry);

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

@@ -1 +1 @@
-{"version":3,"file":"window-system.d.ts","sourceRoot":"","sources":["../../../src/systems/window/window-system.tsx"],"names":[],"mappings":"AAaA,eAAO,MAAM,yBAAyB,yBAAyB,CAAA;AAC/D,eAAO,MAAM,8BAA8B,8BAA8B,CAAA;AACzE,eAAO,MAAM,+BAA+B,+BAA+B,CAAA;AAC3E,eAAO,MAAM,gCAAgC,gCAAgC,CAAA;AAC7E,eAAO,MAAM,4BAA4B,4BAA4B,CAAA;AACrE,eAAO,MAAM,yBAAyB,yBAAyB,CAAA;AAC/D,eAAO,MAAM,4BAA4B,4BAA4B,CAAA;AACrE,eAAO,MAAM,0BAA0B,0BAA0B,CAAA;AACjE,eAAO,MAAM,uBAAuB,uBAAuB,CAAA;AAC3D,eAAO,MAAM,uBAAuB,uBAAuB,CAAA;AAE3D,eAAO,MAAM,YAAY,YA2BxB,CAAA"}
+{"version":3,"file":"window-system.d.ts","sourceRoot":"","sources":["../../../src/systems/window/window-system.tsx"],"names":[],"mappings":"AAuBA,eAAO,MAAM,yBAAyB,yBAAyB,CAAA;AAC/D,eAAO,MAAM,8BAA8B,8BAA8B,CAAA;AACzE,eAAO,MAAM,+BAA+B,+BAA+B,CAAA;AAC3E,eAAO,MAAM,gCAAgC,gCAAgC,CAAA;AAC7E,eAAO,MAAM,4BAA4B,4BAA4B,CAAA;AACrE,eAAO,MAAM,yBAAyB,yBAAyB,CAAA;AAC/D,eAAO,MAAM,4BAA4B,4BAA4B,CAAA;AACrE,eAAO,MAAM,0BAA0B,0BAA0B,CAAA;AACjE,eAAO,MAAM,uBAAuB,uBAAuB,CAAA;AAC3D,eAAO,MAAM,uBAAuB,uBAAuB,CAAA;AAM3D,eAAO,MAAM,YAAY,YA0FxB,CAAA"}

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

@@ -1,9 +1,13 @@
-import { sceneRegistry, useInteractive, useScene, } from '@pascal-app/core';
+import { getEffectiveNode, sceneRegistry, useInteractive, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
+import { useEffect, useRef } from 'react';
 import * as THREE from 'three';
-import { baseMaterial, glassMaterial } from '../../lib/materials';
+import { createSurfaceRoleMaterial, glassMaterial as defaultGlassMaterial, baseMaterial as getBaseMaterial, } from '../../lib/materials';
+import useViewer from '../../store/use-viewer';
 // Invisible material for root mesh — used as selection hitbox only
 const hitboxMaterial = new THREE.MeshBasicMaterial({ visible: false });
+let baseMaterial = getBaseMaterial();
+let glassMaterial = defaultGlassMaterial;
 export const CASEMENT_WINDOW_SASH_NAME = 'casement-window-sash';
 export const FRENCH_CASEMENT_LEFT_SASH_NAME = 'french-casement-left-sash';
 export const FRENCH_CASEMENT_RIGHT_SASH_NAME = 'french-casement-right-sash';
@@ -14,27 +18,87 @@ export const DOUBLE_HUNG_BOTTOM_SASH_NAME = 'double-hung-bottom-sash';
 export const LOUVERED_WINDOW_SLATS_NAME = 'louvered-window-slats';
 export const AWNING_WINDOW_SASH_NAME = 'awning-window-sash';
 export const HOPPER_WINDOW_SASH_NAME = 'hopper-window-sash';
+const MAX_WINDOW_REBUILDS_PER_FRAME = 16;
+const WINDOW_PROGRESSIVE_DIRTY_THRESHOLD = MAX_WINDOW_REBUILDS_PER_FRAME;
+const WINDOW_PROGRESSIVE_TIME_BUDGET_MS = 8;
 export const WindowSystem = () => {
     const dirtyNodes = useScene((state) => state.dirtyNodes);
     const clearDirty = useScene((state) => state.clearDirty);
+    const shading = useViewer((state) => state.shading);
+    const textures = useViewer((state) => state.textures);
+    const colorPreset = useViewer((state) => state.colorPreset);
+    const materialRevisionRef = useRef(null);
+    // Subscribe so override-only updates re-run this component. Mirrors
+    // WallSystem + DoorSystem.
+    useLiveNodeOverrides((s) => s.overrides);
+    baseMaterial = textures
+        ? getBaseMaterial(shading)
+        : createSurfaceRoleMaterial('joinery', colorPreset);
+    glassMaterial = textures
+        ? defaultGlassMaterial
+        : createSurfaceRoleMaterial('glazing', colorPreset);
+    useEffect(() => {
+        const materialRevision = `${shading}:${textures ? 'textures' : 'solid'}:${colorPreset}`;
+        if (materialRevisionRef.current === materialRevision)
+            return;
+        materialRevisionRef.current = materialRevision;
+        const nodes = useScene.getState().nodes;
+        for (const node of Object.values(nodes)) {
+            if (node?.type === 'window') {
+                useScene.getState().dirtyNodes.add(node.id);
+            }
+        }
+    });
     useFrame(() => {
         if (dirtyNodes.size === 0)
             return;
+        baseMaterial = textures
+            ? getBaseMaterial(shading)
+            : createSurfaceRoleMaterial('joinery', colorPreset);
+        glassMaterial = textures
+            ? defaultGlassMaterial
+            : createSurfaceRoleMaterial('glazing', colorPreset);
         const nodes = useScene.getState().nodes;
+        const dirtyWindowIds = [];
         dirtyNodes.forEach((id) => {
             const node = nodes[id];
             if (!node || node.type !== 'window')
                 return;
+            dirtyWindowIds.push(id);
+        });
+        const useProgressiveWindowRebuilds = dirtyWindowIds.length > WINDOW_PROGRESSIVE_DIRTY_THRESHOLD;
+        const frameStartedAt = performance.now();
+        let rebuiltWindowsThisFrame = 0;
+        for (const id of dirtyWindowIds) {
+            if (useProgressiveWindowRebuilds) {
+                if (rebuiltWindowsThisFrame >= MAX_WINDOW_REBUILDS_PER_FRAME) {
+                    break;
+                }
+                if (rebuiltWindowsThisFrame > 0 &&
+                    performance.now() - frameStartedAt >= WINDOW_PROGRESSIVE_TIME_BUDGET_MS) {
+                    break;
+                }
+            }
+            const node = nodes[id];
+            if (!node || node.type !== 'window')
+                continue;
             const mesh = sceneRegistry.nodes.get(id);
             if (!mesh)
-                return; // Keep dirty until mesh mounts
-            updateWindowMesh(node, mesh);
+                continue; // Keep dirty until mesh mounts
+            // Merge any live override (width / height / position) so the mesh
+            // rebuild reflects the in-flight drag without zustand churn.
+            const effectiveNode = getEffectiveNode(node);
+            updateWindowMesh(effectiveNode, mesh);
             clearDirty(id);
+            rebuiltWindowsThisFrame += 1;
             // Rebuild the parent wall so its cutout reflects the updated window geometry
-            if (node.parentId) {
-                useScene.getState().dirtyNodes.add(node.parentId);
+            // Avoid triggering expensive wall CSG rebuilds while the window is being interactively moved/duplicated.
+            // The editor tools will request a final wall rebuild on commit.
+            const isTransient = !!node.metadata?.isTransient;
+            if (!isTransient && effectiveNode.parentId) {
+                useScene.getState().dirtyNodes.add(effectiveNode.parentId);
             }
-        });
+        }
     }, 3);
     return null;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pascal-app/viewer",
-  "version": "0.7.0",
+  "version": "0.9.1",
   "description": "3D viewer component for Pascal building editor",
   "type": "module",
   "main": "./dist/index.js",
@@ -22,24 +22,23 @@
     "prepublishOnly": "npm run build"
   },
   "peerDependencies": {
-    "@pascal-app/core": "^0.7.0",
+    "@pascal-app/core": "^0.9.1",
     "@react-three/drei": "^10",
     "@react-three/fiber": "^9",
     "react": "^18 || ^19",
     "three": "^0.184"
   },
   "dependencies": {
-    "polygon-clipping": "^0.15.7",
     "three-bvh-csg": "^0.0.18",
     "three-mesh-bvh": "^0.9.8",
     "zustand": "^5"
   },
   "devDependencies": {
     "@pascal/typescript-config": "*",
-    "@types/node": "^25.5.0",
+    "@types/node": "^22",
     "@types/react": "^19.2.2",
     "@types/three": "^0.184.0",
-    "typescript": "5.9.3"
+    "typescript": "6.0.3"
   },
   "keywords": [
     "3d",

package/dist/components/renderers/building/building-renderer.d.ts

@@ -1,5 +0,0 @@
-import { type BuildingNode } from '@pascal-app/core';
-export declare const BuildingRenderer: ({ node }: {
-    node: BuildingNode;
-}) => import("react/jsx-runtime").JSX.Element;
-//# sourceMappingURL=building-renderer.d.ts.map

package/dist/components/renderers/building/building-renderer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"building-renderer.d.ts","sourceRoot":"","sources":["../../../../src/components/renderers/building/building-renderer.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAe,MAAM,kBAAkB,CAAA;AAMjE,eAAO,MAAM,gBAAgB,GAAI,UAAU;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,4CAkBhE,CAAA"}

package/dist/components/renderers/building/building-renderer.js

@@ -1,11 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { useRegistry } from '@pascal-app/core';
-import { useRef } from 'react';
-import { useNodeEvents } from '../../../hooks/use-node-events';
-import { NodeRenderer } from '../node-renderer';
-export const BuildingRenderer = ({ node }) => {
-    const ref = useRef(null);
-    useRegistry(node.id, node.type, ref);
-    const handlers = useNodeEvents(node, 'building');
-    return (_jsx("group", { position: node.position, ref: ref, rotation: [node.rotation[0], node.rotation[1], node.rotation[2]], ...handlers, children: node.children.map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, childId))) }));
-};

package/dist/components/renderers/ceiling/ceiling-renderer.d.ts

@@ -1,5 +0,0 @@
-import { type CeilingNode } from '@pascal-app/core';
-export declare const CeilingRenderer: ({ node }: {
-    node: CeilingNode;
-}) => import("react/jsx-runtime").JSX.Element;
-//# sourceMappingURL=ceiling-renderer.d.ts.map

package/dist/components/renderers/ceiling/ceiling-renderer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ceiling-renderer.d.ts","sourceRoot":"","sources":["../../../../src/components/renderers/ceiling/ceiling-renderer.tsx"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,WAAW,EAIjB,MAAM,kBAAkB,CAAA;AA8CzB,eAAO,MAAM,eAAe,GAAI,UAAU;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,4CAoC9D,CAAA"}

package/dist/components/renderers/ceiling/ceiling-renderer.js

@@ -1,58 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { getMaterialPresetByRef, resolveMaterial, useRegistry, } from '@pascal-app/core';
-import { useMemo, useRef } from 'react';
-import { float, mix, positionWorld, smoothstep } from 'three/tsl';
-import { BackSide, FrontSide, MeshBasicNodeMaterial } from 'three/webgpu';
-import { useNodeEvents } from '../../../hooks/use-node-events';
-import { NodeRenderer } from '../node-renderer';
-const gridScale = 5;
-const gridX = positionWorld.x.mul(gridScale).fract();
-const gridY = positionWorld.z.mul(gridScale).fract();
-const lineWidth = 0.05;
-const lineX = smoothstep(lineWidth, 0, gridX).add(smoothstep(1.0 - lineWidth, 1.0, gridX));
-const lineY = smoothstep(lineWidth, 0, gridY).add(smoothstep(1.0 - lineWidth, 1.0, gridY));
-const gridPattern = lineX.max(lineY);
-const gridOpacity = mix(float(0.2), float(0.6), gridPattern);
-function createCeilingMaterials(color = '#999999') {
-    const topMaterial = new MeshBasicNodeMaterial({
-        color,
-        transparent: true,
-        depthWrite: false,
-        side: FrontSide,
-    });
-    topMaterial.opacityNode = gridOpacity;
-    const bottomMaterial = new MeshBasicNodeMaterial({
-        color,
-        transparent: true,
-        side: BackSide,
-    });
-    return { topMaterial, bottomMaterial };
-}
-const ceilingMaterialCache = new Map();
-function getCeilingMaterials(color = '#999999') {
-    const cacheKey = color;
-    const cached = ceilingMaterialCache.get(cacheKey);
-    if (cached)
-        return cached;
-    const materials = createCeilingMaterials(color);
-    ceilingMaterialCache.set(cacheKey, materials);
-    return materials;
-}
-export const CeilingRenderer = ({ node }) => {
-    const ref = useRef(null);
-    useRegistry(node.id, 'ceiling', ref);
-    const handlers = useNodeEvents(node, 'ceiling');
-    const materials = useMemo(() => {
-        const preset = getMaterialPresetByRef(node.materialPreset);
-        const props = preset?.mapProperties ?? resolveMaterial(node.material);
-        const color = props.color || '#999999';
-        return getCeilingMaterials(color);
-    }, [
-        node.materialPreset,
-        node.material,
-        node.material?.preset,
-        node.material?.properties,
-        node.material?.texture,
-    ]);
-    return (_jsxs("mesh", { material: materials.bottomMaterial, ref: ref, children: [_jsx("boxGeometry", { args: [0, 0, 0] }), _jsx("mesh", { material: materials.topMaterial, name: "ceiling-grid", ...handlers, scale: 0, visible: false, children: _jsx("boxGeometry", { args: [0, 0, 0] }) }), node.children.map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, childId)))] }));
-};

package/dist/components/renderers/column/column-renderer.d.ts

@@ -1,5 +0,0 @@
-import { type ColumnNode } from '@pascal-app/core';
-export declare const ColumnRenderer: ({ node }: {
-    node: ColumnNode;
-}) => import("react/jsx-runtime").JSX.Element;
-//# sourceMappingURL=column-renderer.d.ts.map

package/dist/components/renderers/column/column-renderer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"column-renderer.d.ts","sourceRoot":"","sources":["../../../../src/components/renderers/column/column-renderer.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAkC,MAAM,kBAAkB,CAAA;AA64ClF,eAAO,MAAM,cAAc,GAAI,UAAU;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,4CA0E5D,CAAA"}