@pascal-app/viewer 0.6.0 → 0.8.0

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"fence-system.d.ts","sourceRoot":"","sources":["../../../src/systems/fence/fence-system.tsx"],"names":[],"mappings":"AA+QA,eAAO,MAAM,WAAW,YAiBvB,CAAA"}

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

@@ -0,0 +1,185 @@
+import { getWallCurveFrameAt, getWallCurveLength, sceneRegistry, useScene, } from '@pascal-app/core';
+import { useFrame } from '@react-three/fiber';
+import * as THREE from 'three';
+import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+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/guide/guide-system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"guide-system.d.ts","sourceRoot":"","sources":["../../../src/systems/guide/guide-system.tsx"],"names":[],"mappings":"AAIA,eAAO,MAAM,WAAW,YAsCvB,CAAA"}
+{"version":3,"file":"guide-system.d.ts","sourceRoot":"","sources":["../../../src/systems/guide/guide-system.tsx"],"names":[],"mappings":"AAIA,eAAO,MAAM,WAAW,YAcvB,CAAA"}

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

@@ -1,4 +1,4 @@
-import { emitter, sceneRegistry } from '@pascal-app/core';
+import { sceneRegistry } from '@pascal-app/core';
 import { useEffect } from 'react';
 import useViewer from '../../store/use-viewer';
 export const GuideSystem = () => {
@@ -12,30 +12,5 @@ export const GuideSystem = () => {
             }
         });
     }, [showGuides]);
-    useEffect(() => {
-        const hideForCapture = () => {
-            const guides = sceneRegistry.byType.guide || new Set();
-            guides.forEach((guideId) => {
-                const node = sceneRegistry.nodes.get(guideId);
-                if (node)
-                    node.visible = false;
-            });
-        };
-        const restoreAfterCapture = () => {
-            const showGuidesNow = useViewer.getState().showGuides;
-            const guides = sceneRegistry.byType.guide || new Set();
-            guides.forEach((guideId) => {
-                const node = sceneRegistry.nodes.get(guideId);
-                if (node)
-                    node.visible = showGuidesNow;
-            });
-        };
-        emitter.on('thumbnail:before-capture', hideForCapture);
-        emitter.on('thumbnail:after-capture', restoreAfterCapture);
-        return () => {
-            emitter.off('thumbnail:before-capture', hideForCapture);
-            emitter.off('thumbnail:after-capture', restoreAfterCapture);
-        };
-    }, []);
     return null;
 };

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":"AAiBA,eAAO,MAAM,UAAU,YA6CtB,CAAA"}

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

@@ -0,0 +1,44 @@
+import { getScaledDimensions, resolveLevelId, sceneRegistry, spatialGridManager, useScene, } from '@pascal-app/core';
+import { useFrame } from '@react-three/fiber';
+// ============================================================================
+// 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) {
+                // If parented to another item (surface placement), R3F handles positioning via the hierarchy
+                const parentNode = item.parentId ? nodes[item.parentId] : undefined;
+                if (parentNode?.type !== 'item') {
+                    // Floor item: elevate by slab height (using full footprint overlap)
+                    const levelId = resolveLevelId(item, nodes);
+                    const slabElevation = spatialGridManager.getSlabElevationForItem(levelId, item.position, getScaledDimensions(item), item.rotation);
+                    mesh.position.y = slabElevation + item.position[1];
+                }
+            }
+            clearDirty(id);
+        });
+    }, 2);
+    return null;
+};

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

@@ -1 +1 @@
-{"version":3,"file":"roof-materials.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-materials.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;AAiBhG,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,GAAG,iBAAiB,GAAG,IAAI,CAmB7E"}
+{"version":3,"file":"roof-materials.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-materials.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;AA4BhG,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,GAAG,iBAAiB,GAAG,IAAI,CA8B7E"}

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

@@ -1,6 +1,13 @@
 import { getEffectiveRoofSurfaceMaterial, } from '@pascal-app/core';
 import * as THREE from 'three';
 import { createMaterial, createMaterialFromPresetRef } from '../../lib/materials';
+const roofMaterialArrayCache = new Map();
+function getSurfaceMaterialSignature(spec) {
+    return JSON.stringify({
+        material: spec.material ?? null,
+        materialPreset: spec.materialPreset ?? null,
+    });
+}
 function createResolvedMaterial(material, materialPreset) {
     if (materialPreset) {
         return createMaterialFromPresetRef(materialPreset);
@@ -14,16 +21,26 @@ export function getRoofMaterialArray(node) {
     const top = getEffectiveRoofSurfaceMaterial(node, 'top');
     const edge = getEffectiveRoofSurfaceMaterial(node, 'edge');
     const wall = getEffectiveRoofSurfaceMaterial(node, 'wall');
+    const cacheKey = JSON.stringify({
+        top: getSurfaceMaterialSignature(top),
+        edge: getSurfaceMaterialSignature(edge),
+        wall: getSurfaceMaterialSignature(wall),
+    });
+    const cached = roofMaterialArrayCache.get(cacheKey);
+    if (cached)
+        return cached;
     const topMaterial = createResolvedMaterial(top.material, top.materialPreset);
     const edgeMaterial = createResolvedMaterial(edge.material, edge.materialPreset);
     const wallMaterial = createResolvedMaterial(wall.material, wall.materialPreset);
     if (!(topMaterial || edgeMaterial || wallMaterial)) {
         return null;
     }
-    return [
+    const materialArray = [
         edgeMaterial ?? wallMaterial ?? topMaterial ?? new THREE.MeshStandardMaterial(),
         wallMaterial ?? edgeMaterial ?? topMaterial ?? new THREE.MeshStandardMaterial(),
         wallMaterial ?? edgeMaterial ?? topMaterial ?? new THREE.MeshStandardMaterial(),
         topMaterial ?? wallMaterial ?? edgeMaterial ?? new THREE.MeshStandardMaterial(),
     ];
+    roofMaterialArrayCache.set(cacheKey, materialArray);
+    return materialArray;
 }

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

@@ -0,0 +1,16 @@
+import { type RoofSegmentNode } from '@pascal-app/core';
+import * as THREE from 'three';
+import { Brush } from 'three-bvh-csg';
+export declare const RoofSystem: () => null;
+/**
+ * Generate complete hollow-shell geometry for a roof segment.
+ * Ports the prototype's CSG approach using three-bvh-csg.
+ */
+export declare function getRoofSegmentBrushes(node: RoofSegmentNode): {
+    deckSlab: Brush;
+    shinSlab: Brush;
+    wallBrush: Brush;
+    innerBrush: Brush;
+} | null;
+export declare function generateRoofSegmentGeometry(node: RoofSegmentNode): 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":"AAAA,OAAO,EAIL,KAAK,eAAe,EAIrB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,EAAY,KAAK,EAA0B,MAAM,eAAe,CAAA;AA4CvE,eAAO,MAAM,UAAU,YAsFtB,CAAA;AAqLD;;;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,CAqRlF;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,eAAe,GAAG,KAAK,CAAC,cAAc,CAmDvF"}