@pascal-app/viewer 0.8.0 → 0.9.2

package/dist/components/renderers/stair-segment/stair-segment-renderer.js

@@ -1,51 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { useRegistry, useScene, } from '@pascal-app/core';
-import { useEffect, useLayoutEffect, useMemo, useRef } from 'react';
-import * as THREE from 'three';
-import { useNodeEvents } from '../../../hooks/use-node-events';
-import { getStraightStairSegmentBodyMaterials } from '../../../systems/stair/stair-materials';
-export const StairSegmentRenderer = ({ node }) => {
-    const ref = useRef(null);
-    const nodes = useScene((state) => state.nodes);
-    useRegistry(node.id, 'stair-segment', ref);
-    useLayoutEffect(() => {
-        useScene.getState().markDirty(node.id);
-    }, [node.id]);
-    const handlers = useNodeEvents(node, 'stair-segment');
-    const parentNode = node.parentId
-        ? nodes[node.parentId]
-        : undefined;
-    const material = useMemo(() => {
-        return getStraightStairSegmentBodyMaterials(node, parentNode);
-    }, [
-        node.materialPreset,
-        node.material,
-        node.material?.preset,
-        node.material?.properties,
-        node.material?.texture,
-        parentNode?.materialPreset,
-        parentNode?.material,
-        parentNode?.material?.preset,
-        parentNode?.material?.properties,
-        parentNode?.material?.texture,
-        parentNode?.railingMaterialPreset,
-        parentNode?.railingMaterial,
-        parentNode?.sideMaterialPreset,
-        parentNode?.sideMaterial,
-        parentNode?.treadMaterialPreset,
-        parentNode?.treadMaterial,
-    ]);
-    const placeholderGeometry = useMemo(() => {
-        const geometry = new THREE.BufferGeometry();
-        geometry.setAttribute('position', new THREE.Float32BufferAttribute([], 3));
-        geometry.addGroup(0, 0, 0);
-        geometry.addGroup(0, 0, 1);
-        return geometry;
-    }, []);
-    useEffect(() => {
-        return () => {
-            placeholderGeometry.dispose();
-        };
-    }, [placeholderGeometry]);
-    return (_jsx("mesh", { geometry: placeholderGeometry, material: material, position: node.position, ref: ref, "rotation-y": node.rotation, visible: node.visible, ...handlers }));
-};

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

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

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

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

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

@@ -1,16 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useRegistry, useScene } from '@pascal-app/core';
-import { useLayoutEffect, useRef } from 'react';
-import { useNodeEvents } from '../../../hooks/use-node-events';
-import { getVisibleWallMaterials } from '../../../systems/wall/wall-materials';
-import { NodeRenderer } from '../node-renderer';
-export const WallRenderer = ({ node }) => {
-    const ref = useRef(null);
-    useRegistry(node.id, 'wall', ref);
-    useLayoutEffect(() => {
-        useScene.getState().markDirty(node.id);
-    }, [node.id]);
-    const handlers = useNodeEvents(node, 'wall');
-    const material = getVisibleWallMaterials(node);
-    return (_jsxs("mesh", { castShadow: true, material: material, receiveShadow: true, ref: ref, visible: node.visible, children: [_jsx("boxGeometry", { args: [0, 0, 0] }), _jsx("mesh", { name: "collision-mesh", visible: false, ...handlers, children: _jsx("boxGeometry", { args: [0, 0, 0] }) }), node.children.map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, `${node.id}:${childId}`)))] }));
-};

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

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

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

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

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

@@ -1,21 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { useRegistry, useScene } from '@pascal-app/core';
-import { useLayoutEffect, useMemo, useRef } from 'react';
-import { useNodeEvents } from '../../../hooks/use-node-events';
-import { createMaterial, DEFAULT_WINDOW_MATERIAL } from '../../../lib/materials';
-export const WindowRenderer = ({ node }) => {
-    const ref = useRef(null);
-    useRegistry(node.id, 'window', ref);
-    useLayoutEffect(() => {
-        useScene.getState().markDirty(node.id);
-    }, [node.id]);
-    const handlers = useNodeEvents(node, 'window');
-    const isTransient = !!node.metadata?.isTransient;
-    const material = useMemo(() => {
-        const mat = node.material;
-        if (!mat)
-            return DEFAULT_WINDOW_MATERIAL;
-        return createMaterial(mat);
-    }, [node.material, node.material?.preset, node.material?.properties, node.material?.texture]);
-    return (_jsx("mesh", { castShadow: true, material: material, position: node.position, receiveShadow: true, ref: ref, rotation: node.rotation, visible: node.visible, ...(isTransient ? {} : handlers), children: _jsx("boxGeometry", { args: [0, 0, 0] }) }));
-};

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

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

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

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

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

@@ -1,181 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useRegistry } from '@pascal-app/core';
-import { Html } from '@react-three/drei';
-import { useMemo, useRef } from 'react';
-import { BufferGeometry, Color, DoubleSide, Float32BufferAttribute, Shape } from 'three';
-import { color, float, uniform, uv } from 'three/tsl';
-import { MeshBasicNodeMaterial } from 'three/webgpu';
-import { useNodeEvents } from '../../../hooks/use-node-events';
-import { ZONE_LAYER } from '../../../lib/layers';
-const Y_OFFSET = 0.01;
-const WALL_HEIGHT = 2.3;
-/**
- * Creates a gradient material for zone walls using TSL
- * Gradient goes from zone color at bottom to transparent at top
- */
-const createWallGradientMaterial = (zoneColor) => {
-    const baseColor = color(new Color(zoneColor));
-    // Use UV y coordinate for vertical gradient (0 at bottom, 1 at top)
-    const gradientT = uv().y;
-    const opacity = uniform(0);
-    // Fade opacity from 0.6 at bottom to 0 at top
-    const finalOpacity = float(0.6).mul(float(1).sub(gradientT)).mul(opacity);
-    return new MeshBasicNodeMaterial({
-        transparent: true,
-        colorNode: baseColor,
-        opacityNode: finalOpacity,
-        side: DoubleSide,
-        depthWrite: true,
-        depthTest: false,
-        userData: {
-            uOpacity: opacity,
-        },
-    });
-};
-/**
- * Creates a floor material for zones using TSL
- */
-const createFloorMaterial = (zoneColor) => {
-    const baseColor = color(new Color(zoneColor));
-    const opacity = uniform(0);
-    return new MeshBasicNodeMaterial({
-        transparent: true,
-        colorNode: baseColor,
-        opacityNode: float(0.25).mul(opacity),
-        side: DoubleSide,
-        depthWrite: false,
-        depthTest: false,
-        userData: { uOpacity: opacity },
-    });
-};
-/**
- * Creates wall geometry for zone borders
- * Each wall segment is a vertical quad from one polygon point to the next
- */
-const createWallGeometry = (polygon) => {
-    const geometry = new BufferGeometry();
-    if (polygon.length < 2)
-        return geometry;
-    const positions = [];
-    const uvs = [];
-    const indices = [];
-    // Create a wall segment for each edge of the polygon
-    for (let i = 0; i < polygon.length; i++) {
-        const current = polygon[i];
-        const next = polygon[(i + 1) % polygon.length];
-        const baseIndex = i * 4;
-        // Four vertices per wall segment (two triangles forming a quad)
-        // Bottom-left
-        positions.push(current[0], Y_OFFSET, current[1]);
-        uvs.push(0, 0);
-        // Bottom-right
-        positions.push(next[0], Y_OFFSET, next[1]);
-        uvs.push(1, 0);
-        // Top-right
-        positions.push(next[0], Y_OFFSET + WALL_HEIGHT, next[1]);
-        uvs.push(1, 1);
-        // Top-left
-        positions.push(current[0], Y_OFFSET + WALL_HEIGHT, current[1]);
-        uvs.push(0, 1);
-        // Two triangles for the quad
-        indices.push(baseIndex, baseIndex + 1, baseIndex + 2, baseIndex, baseIndex + 2, baseIndex + 3);
-    }
-    geometry.setAttribute('position', new Float32BufferAttribute(positions, 3));
-    geometry.setAttribute('uv', new Float32BufferAttribute(uvs, 2));
-    geometry.setIndex(indices);
-    geometry.computeVertexNormals();
-    return geometry;
-};
-export const ZoneRenderer = ({ node }) => {
-    const ref = useRef(null);
-    useRegistry(node.id, 'zone', ref);
-    // Create floor shape from polygon
-    const floorShape = useMemo(() => {
-        if (!node?.polygon || node.polygon.length < 3)
-            return null;
-        const shape = new Shape();
-        const firstPt = node.polygon[0];
-        // Shape is in X-Y plane, we rotate it to X-Z plane
-        // Negate Y (which becomes Z) to get correct orientation
-        shape.moveTo(firstPt[0], -firstPt[1]);
-        for (let i = 1; i < node.polygon.length; i++) {
-            const pt = node.polygon[i];
-            shape.lineTo(pt[0], -pt[1]);
-        }
-        shape.closePath();
-        return shape;
-    }, [node?.polygon]);
-    // Create wall geometry from polygon
-    const wallGeometry = useMemo(() => {
-        if (!node?.polygon || node.polygon.length < 2)
-            return null;
-        return createWallGeometry(node.polygon);
-    }, [node?.polygon]);
-    // Calculate polygon centroid for label positioning using the geometric centroid formula
-    // This correctly handles polygons regardless of vertex distribution along edges
-    const centroid = useMemo(() => {
-        if (!node?.polygon || node.polygon.length < 3)
-            return [0, 0];
-        const polygon = node.polygon;
-        let signedArea = 0;
-        let cx = 0;
-        let cz = 0;
-        for (let i = 0; i < polygon.length; i++) {
-            const [x0, z0] = polygon[i];
-            const [x1, z1] = polygon[(i + 1) % polygon.length];
-            // Cross product for signed area
-            const cross = x0 * z1 - x1 * z0;
-            signedArea += cross;
-            cx += (x0 + x1) * cross;
-            cz += (z0 + z1) * cross;
-        }
-        signedArea /= 2;
-        const factor = 1 / (6 * signedArea);
-        return [cx * factor, cz * factor];
-    }, [node?.polygon]);
-    // Create materials
-    const floorMaterial = useMemo(() => {
-        if (!node?.color)
-            return null;
-        return createFloorMaterial(node.color);
-    }, [node?.color]);
-    const wallMaterial = useMemo(() => {
-        if (!node?.color)
-            return null;
-        return createWallGradientMaterial(node.color);
-    }, [node?.color]);
-    const handlers = useNodeEvents(node, 'zone');
-    if (!(node && floorShape && wallGeometry && floorMaterial && wallMaterial)) {
-        return null;
-    }
-    return (_jsxs("group", { ref: ref, ...handlers, userData: { labelPosition: [centroid[0], 1, centroid[1]] }, children: [_jsx(Html, { name: "label", position: [centroid[0], 1, centroid[1]], style: { pointerEvents: 'none' }, zIndexRange: [10, 0], children: _jsxs("div", { id: `${node.id}-label`, style: {
-                        display: 'flex',
-                        flexDirection: 'column',
-                        alignItems: 'center',
-                        transform: 'translate3d(-50%, -50%, 0)',
-                        opacity: 0,
-                        transition: 'opacity 0.3s ease-in-out',
-                    }, children: [_jsx("div", { style: {
-                                width: 'max-content',
-                                color: 'white',
-                                textShadow: `-1px -1px 0 ${node.color}, 1px -1px 0 ${node.color}, -1px 1px 0 ${node.color}, 1px 1px 0 ${node.color}`,
-                                textAlign: 'center',
-                            }, children: _jsx("span", { children: node.name }) }), _jsxs("div", { className: "label-pin", style: {
-                                display: 'flex',
-                                flexDirection: 'column',
-                                alignItems: 'center',
-                                marginTop: '2px',
-                                opacity: 0,
-                                transition: 'opacity 0.5s ease-in-out',
-                            }, children: [_jsx("div", { style: {
-                                        width: '2px',
-                                        height: '40px',
-                                        backgroundColor: node.color,
-                                    } }), _jsx("div", { style: {
-                                        width: '10px',
-                                        height: '10px',
-                                        borderRadius: '50%',
-                                        backgroundColor: node.color,
-                                        border: '1px solid white',
-                                    } })] })] }) }), _jsx("mesh", { layers: ZONE_LAYER, material: floorMaterial, name: "floor", position: [0, Y_OFFSET, 0], rotation: [-Math.PI / 2, 0, 0], children: _jsx("shapeGeometry", { args: [floorShape] }) }), _jsx("mesh", { geometry: wallGeometry, layers: ZONE_LAYER, material: wallMaterial, name: "walls" })] }));
-};

package/dist/components/viewer/ground-occluder.d.ts

@@ -1,2 +0,0 @@
-export declare const GroundOccluder: () => import("react/jsx-runtime").JSX.Element;
-//# sourceMappingURL=ground-occluder.d.ts.map

package/dist/components/viewer/ground-occluder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ground-occluder.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/ground-occluder.tsx"],"names":[],"mappings":"AAMA,eAAO,MAAM,cAAc,+CAuG1B,CAAA"}

package/dist/components/viewer/ground-occluder.js

@@ -1,79 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useScene } from '@pascal-app/core';
-import polygonClipping from 'polygon-clipping';
-import { useMemo } from 'react';
-import * as THREE from 'three';
-import useViewer from '../../store/use-viewer';
-export const GroundOccluder = () => {
-    const theme = useViewer((state) => state.theme);
-    const bgColor = theme === 'dark' ? '#1f2433' : '#fafafa';
-    const nodes = useScene((state) => state.nodes);
-    const shape = useMemo(() => {
-        const s = new THREE.Shape();
-        const size = 1000;
-        // Create outer infinite plane
-        s.moveTo(-size, -size);
-        s.lineTo(size, -size);
-        s.lineTo(size, size);
-        s.lineTo(-size, size);
-        s.closePath();
-        const levelIndexById = new Map();
-        let lowestLevelIndex = Number.POSITIVE_INFINITY;
-        Object.values(nodes).forEach((node) => {
-            if (node.type !== 'level') {
-                return;
-            }
-            levelIndexById.set(node.id, node.level);
-            lowestLevelIndex = Math.min(lowestLevelIndex, node.level);
-        });
-        // Only the lowest level should punch through the ground plane.
-        // Upper-level slabs should still cast shadows, but they should not
-        // reveal their footprint on the level-zero ground material.
-        const polygons = [];
-        Object.values(nodes).forEach((node) => {
-            if (!(node.type === 'slab' &&
-                node.visible &&
-                node.polygon.length >= 3 &&
-                // Only recessed slabs should punch through the ground plane.
-                (node.elevation ?? 0.05) < 0)) {
-                return;
-            }
-            if (Number.isFinite(lowestLevelIndex)) {
-                const parentLevelIndex = node.parentId
-                    ? levelIndexById.get(node.parentId)
-                    : undefined;
-                if (parentLevelIndex !== lowestLevelIndex) {
-                    return;
-                }
-            }
-            polygons.push(node.polygon);
-        });
-        if (polygons.length > 0) {
-            // Format for polygon-clipping: [[[x, y], [x, y], ...]]
-            const multiPolygons = polygons.map((pts) => {
-                const ring = pts.map((p) => [p[0], -p[1]]); // Negate Y (which was Z)
-                return [ring];
-            });
-            // Union all polygons together to prevent artifacts from overlapping
-            const unionedPolygons = polygonClipping.union(multiPolygons[0], ...multiPolygons.slice(1));
-            // Add each resulting unioned polygon as a hole
-            for (const geom of unionedPolygons) {
-                // First ring in each geometry is the exterior ring
-                if (geom.length > 0) {
-                    const ring = geom[0];
-                    const hole = new THREE.Path();
-                    if (ring.length > 0) {
-                        hole.moveTo(ring[0][0], ring[0][1]);
-                        for (let i = 1; i < ring.length; i++) {
-                            hole.lineTo(ring[i][0], ring[i][1]);
-                        }
-                        hole.closePath();
-                        s.holes.push(hole);
-                    }
-                }
-            }
-        }
-        return s;
-    }, [nodes]);
-    return (_jsxs("mesh", { "position-y": -0.05, "rotation-x": -Math.PI / 2, children: [_jsx("shapeGeometry", { args: [shape] }), _jsx("meshBasicMaterial", { color: bgColor, depthWrite: true, polygonOffset: true, polygonOffsetFactor: 1, polygonOffsetUnits: 1 })] }));
-};