@pascal-app/viewer 0.1.2 → 0.1.5

package/dist/components/viewer/post-processing.d.ts

@@ -0,0 +1,17 @@
+export declare const SSGI_PARAMS: {
+    enabled: boolean;
+    sliceCount: number;
+    stepCount: number;
+    radius: number;
+    expFactor: number;
+    thickness: number;
+    backfaceLighting: number;
+    aoIntensity: number;
+    giIntensity: number;
+    useLinearThickness: boolean;
+    useScreenSpaceSampling: boolean;
+    useTemporalFiltering: boolean;
+};
+declare const PostProcessingPasses: () => null;
+export default PostProcessingPasses;
+//# sourceMappingURL=post-processing.d.ts.map

package/dist/components/viewer/post-processing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"post-processing.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/post-processing.tsx"],"names":[],"mappings":"AA0BA,eAAO,MAAM,WAAW;;;;;;;;;;;;;CAavB,CAAA;AAED,QAAA,MAAM,oBAAoB,YA8IzB,CAAA;AAED,eAAe,oBAAoB,CAAA"}

package/dist/components/viewer/post-processing.js

@@ -0,0 +1,139 @@
+import { useFrame, useThree } from '@react-three/fiber';
+import { useEffect, useRef } from 'react';
+import { Color, UnsignedByteType } from 'three';
+import { outline } from 'three/addons/tsl/display/OutlineNode.js';
+import { ssgi } from 'three/addons/tsl/display/SSGINode.js';
+import { traa } from 'three/addons/tsl/display/TRAANode.js';
+import { add, colorToDirection, diffuseColor, directionToColor, mrt, normalView, oscSine, output, pass, sample, time, uniform, vec4, velocity, } from 'three/tsl';
+import { PostProcessing } from 'three/webgpu';
+import useViewer from '../../store/use-viewer';
+// SSGI Parameters - adjust these to fine-tune global illumination and ambient occlusion
+export const SSGI_PARAMS = {
+    enabled: true,
+    sliceCount: 2,
+    stepCount: 8,
+    radius: 2,
+    expFactor: 2,
+    thickness: 0.5,
+    backfaceLighting: 0.5,
+    aoIntensity: 1.5,
+    giIntensity: 0.5,
+    useLinearThickness: false,
+    useScreenSpaceSampling: true,
+    useTemporalFiltering: true,
+};
+const PostProcessingPasses = () => {
+    const { gl: renderer, scene, camera } = useThree();
+    const postProcessingRef = useRef(null);
+    useEffect(() => {
+        if (!renderer || !scene || !camera) {
+            return;
+        }
+        // Scene pass with MRT for SSGI
+        const scenePass = pass(scene, camera);
+        scenePass.setMRT(mrt({
+            output: output,
+            diffuseColor: diffuseColor,
+            normal: directionToColor(normalView),
+            velocity: velocity,
+        }));
+        // Get texture outputs
+        const scenePassColor = scenePass.getTextureNode('output');
+        const scenePassDiffuse = scenePass.getTextureNode('diffuseColor');
+        const scenePassDepth = scenePass.getTextureNode('depth');
+        const scenePassNormal = scenePass.getTextureNode('normal');
+        const scenePassVelocity = scenePass.getTextureNode('velocity');
+        // Optimize texture bandwidth
+        const diffuseTexture = scenePass.getTexture('diffuseColor');
+        diffuseTexture.type = UnsignedByteType;
+        const normalTexture = scenePass.getTexture('normal');
+        normalTexture.type = UnsignedByteType;
+        // Extract normal from color-encoded texture
+        const sceneNormal = sample((uv) => {
+            return colorToDirection(scenePassNormal.sample(uv));
+        });
+        // SSGI Pass (cast to PerspectiveCamera for SSGI)
+        const giPass = ssgi(scenePassColor, scenePassDepth, sceneNormal, camera);
+        giPass.sliceCount.value = SSGI_PARAMS.sliceCount;
+        giPass.stepCount.value = SSGI_PARAMS.stepCount;
+        giPass.radius.value = SSGI_PARAMS.radius;
+        giPass.expFactor.value = SSGI_PARAMS.expFactor;
+        giPass.thickness.value = SSGI_PARAMS.thickness;
+        giPass.backfaceLighting.value = SSGI_PARAMS.backfaceLighting;
+        giPass.aoIntensity.value = SSGI_PARAMS.aoIntensity;
+        giPass.giIntensity.value = SSGI_PARAMS.giIntensity;
+        giPass.useLinearThickness.value = SSGI_PARAMS.useLinearThickness;
+        giPass.useScreenSpaceSampling.value = SSGI_PARAMS.useScreenSpaceSampling;
+        giPass.useTemporalFiltering = SSGI_PARAMS.useTemporalFiltering;
+        // Extract GI and AO from SSGI pass
+        const gi = giPass.rgb;
+        const ao = giPass.a;
+        // Composite: scene * AO + diffuse * GI
+        const compositePass = vec4(add(scenePassColor.rgb.mul(ao), scenePassDiffuse.rgb.mul(gi)), scenePassColor.a);
+        // TRAA (Temporal Reprojection Anti-Aliasing)
+        const traaPass = traa(compositePass, scenePassDepth, scenePassVelocity, camera);
+        function generateSelectedOutlinePass() {
+            const edgeStrength = uniform(3);
+            const edgeGlow = uniform(0);
+            const edgeThickness = uniform(1);
+            const visibleEdgeColor = uniform(new Color(0xffffff));
+            const hiddenEdgeColor = uniform(new Color(0xf3ff47));
+            const outlinePass = outline(scene, camera, {
+                selectedObjects: useViewer.getState().outliner.selectedObjects,
+                edgeGlow,
+                edgeThickness,
+            });
+            const { visibleEdge, hiddenEdge } = outlinePass;
+            const outlineColor = visibleEdge
+                .mul(visibleEdgeColor)
+                .add(hiddenEdge.mul(hiddenEdgeColor))
+                .mul(edgeStrength);
+            return outlineColor;
+        }
+        function generateHoverOutlinePass() {
+            const edgeStrength = uniform(5);
+            const edgeGlow = uniform(0.5);
+            const edgeThickness = uniform(1.5);
+            const pulsePeriod = uniform(3);
+            const visibleEdgeColor = uniform(new Color(0x00aaff));
+            const hiddenEdgeColor = uniform(new Color(0xf3ff47));
+            const outlinePass = outline(scene, camera, {
+                selectedObjects: useViewer.getState().outliner.hoveredObjects,
+                edgeGlow,
+                edgeThickness,
+            });
+            const { visibleEdge, hiddenEdge } = outlinePass;
+            const period = time.div(pulsePeriod).mul(2);
+            const osc = oscSine(period).mul(0.5).add(0.5); // osc [ 0.5, 1.0 ]
+            const outlineColor = visibleEdge
+                .mul(visibleEdgeColor)
+                .add(hiddenEdge.mul(hiddenEdgeColor))
+                .mul(edgeStrength);
+            const outlinePulse = pulsePeriod.greaterThan(0).select(outlineColor.mul(osc), outlineColor);
+            return outlinePulse;
+        }
+        // Setup post-processing
+        const postProcessing = new PostProcessing(renderer);
+        const selectedOutlinePass = generateSelectedOutlinePass();
+        const hoverOutlinePass = generateHoverOutlinePass();
+        // Combine SSGI output with outlines
+        const finalOutput = SSGI_PARAMS.enabled
+            ? selectedOutlinePass.add(hoverOutlinePass).add(traaPass)
+            : selectedOutlinePass.add(hoverOutlinePass).add(scenePassColor);
+        postProcessing.outputNode = finalOutput;
+        postProcessingRef.current = postProcessing;
+        return () => {
+            if (postProcessingRef.current) {
+                postProcessingRef.current.dispose();
+            }
+            postProcessingRef.current = null;
+        };
+    }, [renderer, scene, camera]);
+    useFrame(() => {
+        if (postProcessingRef.current) {
+            postProcessingRef.current.render();
+        }
+    }, 1);
+    return null;
+};
+export default PostProcessingPasses;

package/dist/components/viewer/selection-manager.d.ts

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

package/dist/components/viewer/selection-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection-manager.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/selection-manager.tsx"],"names":[],"mappings":"AAkNA,eAAO,MAAM,gBAAgB,+CA0D5B,CAAA"}

package/dist/components/viewer/selection-manager.js

@@ -0,0 +1,279 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { emitter, pointInPolygon, sceneRegistry, useScene, } from '@pascal-app/core';
+import { useThree } from '@react-three/fiber';
+import { useEffect, useRef } from 'react';
+import { Vector3 } from 'three';
+import useViewer from '../../store/use-viewer';
+const tempWorldPos = new Vector3();
+// Tolerance for edge detection (in meters)
+const EDGE_TOLERANCE = 0.5;
+// Expand polygon outward by a small amount to include items on edges
+const expandPolygon = (polygon, tolerance) => {
+    if (polygon.length < 3)
+        return polygon;
+    // Calculate centroid
+    let cx = 0, cz = 0;
+    for (const [x, z] of polygon) {
+        cx += x;
+        cz += z;
+    }
+    cx /= polygon.length;
+    cz /= polygon.length;
+    // Expand each point outward from centroid
+    return polygon.map(([x, z]) => {
+        const dx = x - cx;
+        const dz = z - cz;
+        const len = Math.sqrt(dx * dx + dz * dz);
+        if (len === 0)
+            return [x, z];
+        const scale = (len + tolerance) / len;
+        return [cx + dx * scale, cz + dz * scale];
+    });
+};
+// Check if point is in polygon with tolerance for edges
+const pointInPolygonWithTolerance = (x, z, polygon) => {
+    // First try exact check
+    if (pointInPolygon(x, z, polygon))
+        return true;
+    // Then try with expanded polygon for edge tolerance
+    const expanded = expandPolygon(polygon, EDGE_TOLERANCE);
+    return pointInPolygon(x, z, expanded);
+};
+// Check if a node belongs to the selected level (directly or via wall parent)
+const isNodeOnLevel = (node, levelId) => {
+    const nodes = useScene.getState().nodes;
+    // Direct child of level
+    if (node.parentId === levelId)
+        return true;
+    // Wall-attached items (windows/doors): check if parent wall is on the level
+    if (node.type === 'item' && node.parentId) {
+        const parentNode = nodes[node.parentId];
+        if (parentNode?.type === 'wall' && parentNode.parentId === levelId) {
+            return true;
+        }
+    }
+    return false;
+};
+// Check if a node is on the selected level and within the selected zone's polygon
+const isNodeInZone = (node, levelId, zoneId) => {
+    const nodes = useScene.getState().nodes;
+    const zone = nodes[zoneId];
+    if (!zone?.polygon?.length)
+        return false;
+    // First check: node must be on the same level (directly or via wall)
+    if (!isNodeOnLevel(node, levelId))
+        return false;
+    // Use world position from scene registry for accurate polygon check
+    const object3D = sceneRegistry.nodes.get(node.id);
+    if (object3D) {
+        object3D.getWorldPosition(tempWorldPos);
+        return pointInPolygonWithTolerance(tempWorldPos.x, tempWorldPos.z, zone.polygon);
+    }
+    // Fallback to node data if 3D object not available
+    if (node.type === 'item') {
+        const item = node;
+        return pointInPolygonWithTolerance(item.position[0], item.position[2], zone.polygon);
+    }
+    if (node.type === 'wall') {
+        const wall = node;
+        const startIn = pointInPolygonWithTolerance(wall.start[0], wall.start[1], zone.polygon);
+        const endIn = pointInPolygonWithTolerance(wall.end[0], wall.end[1], zone.polygon);
+        return startIn || endIn;
+    }
+    if (node.type === 'slab' || node.type === 'ceiling') {
+        const poly = node.polygon;
+        if (!poly?.length)
+            return false;
+        // Check if any point of the node's polygon is in the zone (with tolerance)
+        for (const [px, pz] of poly) {
+            if (pointInPolygonWithTolerance(px, pz, zone.polygon))
+                return true;
+        }
+        // Check if any point of the zone is in the node's polygon
+        for (const [zx, zz] of zone.polygon) {
+            if (pointInPolygon(zx, zz, poly))
+                return true;
+        }
+        return false;
+    }
+    if (node.type === 'roof') {
+        // Roofs on the same level are valid when zone is selected
+        return true;
+    }
+    return false;
+};
+const getStrategy = () => {
+    const { buildingId, levelId, zoneId } = useViewer.getState().selection;
+    // No building selected -> can select buildings
+    if (!buildingId) {
+        return {
+            types: ['building'],
+            handleClick: (node) => {
+                useViewer.getState().setSelection({ buildingId: node.id });
+            },
+            handleDeselect: () => {
+                // Nothing to deselect at root level
+            },
+            isValid: (node) => node.type === 'building',
+        };
+    }
+    // Building selected, no level -> can select levels
+    if (!levelId) {
+        return {
+            types: ['level'],
+            handleClick: (node) => {
+                useViewer.getState().setSelection({ levelId: node.id });
+            },
+            handleDeselect: () => {
+                useViewer.getState().setSelection({ buildingId: null });
+            },
+            isValid: (node) => node.type === 'level',
+        };
+    }
+    // Level selected, no zone -> can select zones (only zones on the selected level)
+    if (!zoneId) {
+        return {
+            types: ['zone'],
+            handleClick: (node) => {
+                useViewer.getState().setSelection({ zoneId: node.id });
+            },
+            handleDeselect: () => {
+                useViewer.getState().setSelection({ levelId: null });
+            },
+            isValid: (node) => node.type === 'zone' && node.parentId === levelId,
+        };
+    }
+    // Zone selected -> can select/hover contents (walls, items, slabs, ceilings, roofs)
+    return {
+        types: ['wall', 'item', 'slab', 'ceiling', 'roof'],
+        handleClick: (node) => {
+            const { selectedIds } = useViewer.getState().selection;
+            // Toggle selection - if already selected, deselect; otherwise select
+            if (selectedIds.includes(node.id)) {
+                useViewer.getState().setSelection({ selectedIds: selectedIds.filter((id) => id !== node.id) });
+            }
+            else {
+                useViewer.getState().setSelection({ selectedIds: [node.id] });
+            }
+        },
+        handleDeselect: () => {
+            const { selectedIds } = useViewer.getState().selection;
+            // If items are selected, deselect them first; otherwise go back to level
+            if (selectedIds.length > 0) {
+                useViewer.getState().setSelection({ selectedIds: [] });
+            }
+            else {
+                useViewer.getState().setSelection({ zoneId: null });
+            }
+        },
+        isValid: (node) => {
+            const validTypes = ['wall', 'item', 'slab', 'ceiling', 'roof'];
+            if (!validTypes.includes(node.type))
+                return false;
+            return isNodeInZone(node, levelId, zoneId);
+        },
+    };
+};
+export const SelectionManager = () => {
+    const selection = useViewer((s) => s.selection);
+    const clickHandledRef = useRef(false);
+    useEffect(() => {
+        const onEnter = (event) => {
+            const strategy = getStrategy();
+            if (!strategy)
+                return;
+            if (strategy.isValid(event.node)) {
+                event.stopPropagation();
+                useViewer.setState({ hoveredId: event.node.id });
+            }
+        };
+        const onLeave = (event) => {
+            const strategy = getStrategy();
+            if (!strategy)
+                return;
+            if (strategy.isValid(event.node)) {
+                event.stopPropagation();
+                useViewer.setState({ hoveredId: null });
+            }
+        };
+        const onClick = (event) => {
+            const strategy = getStrategy();
+            if (!strategy)
+                return;
+            if (!strategy.isValid(event.node))
+                return;
+            event.stopPropagation();
+            clickHandledRef.current = true;
+            strategy.handleClick(event.node);
+            // Clear hover immediately after clicking on building/level/zone
+            useViewer.setState({ hoveredId: null });
+        };
+        // Subscribe to all node types
+        const allTypes = ['building', 'level', 'zone', 'wall', 'item', 'slab', 'ceiling', 'roof'];
+        for (const type of allTypes) {
+            emitter.on(`${type}:enter`, onEnter);
+            emitter.on(`${type}:leave`, onLeave);
+            emitter.on(`${type}:click`, onClick);
+        }
+        return () => {
+            for (const type of allTypes) {
+                emitter.off(`${type}:enter`, onEnter);
+                emitter.off(`${type}:leave`, onLeave);
+                emitter.off(`${type}:click`, onClick);
+            }
+        };
+    }, [selection]);
+    return (_jsxs(_Fragment, { children: [_jsx(PointerMissedHandler, { clickHandledRef: clickHandledRef }), _jsx(OutlinerSync, {})] }));
+};
+const PointerMissedHandler = ({ clickHandledRef }) => {
+    const gl = useThree((s) => s.gl);
+    useEffect(() => {
+        const handleClick = (event) => {
+            // Only handle left clicks
+            if (event.button !== 0)
+                return;
+            // Use requestAnimationFrame to check after R3F event handlers
+            requestAnimationFrame(() => {
+                if (clickHandledRef.current) {
+                    clickHandledRef.current = false;
+                    return;
+                }
+                // Click was not handled by any 3D object -> deselect
+                const strategy = getStrategy();
+                if (strategy) {
+                    strategy.handleDeselect();
+                    useViewer.setState({ hoveredId: null });
+                }
+            });
+        };
+        const canvas = gl.domElement;
+        canvas.addEventListener('click', handleClick);
+        return () => {
+            canvas.removeEventListener('click', handleClick);
+        };
+    }, [gl, clickHandledRef]);
+    return null;
+};
+const OutlinerSync = () => {
+    const selection = useViewer((s) => s.selection);
+    const hoveredId = useViewer((s) => s.hoveredId);
+    const outliner = useViewer((s) => s.outliner);
+    useEffect(() => {
+        // Sync selected objects
+        outliner.selectedObjects.length = 0;
+        for (const id of selection.selectedIds) {
+            const obj = sceneRegistry.nodes.get(id);
+            if (obj)
+                outliner.selectedObjects.push(obj);
+        }
+        // Sync hovered objects
+        outliner.hoveredObjects.length = 0;
+        if (hoveredId) {
+            const obj = sceneRegistry.nodes.get(hoveredId);
+            if (obj)
+                outliner.hoveredObjects.push(obj);
+        }
+    }, [selection, hoveredId, outliner]);
+    return null;
+};

package/dist/components/viewer/viewer-camera.d.ts

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

package/dist/components/viewer/viewer-camera.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"viewer-camera.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/viewer-camera.tsx"],"names":[],"mappings":"AAGA,eAAO,MAAM,YAAY,+CAOxB,CAAA"}

package/dist/components/viewer/viewer-camera.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { OrthographicCamera, PerspectiveCamera } from "@react-three/drei";
+import useViewer from "../../store/use-viewer";
+export const ViewerCamera = () => {
+    const cameraMode = useViewer((state) => state.cameraMode);
+    return cameraMode === 'perspective' ? (_jsx(PerspectiveCamera, { far: 1000, fov: 50, makeDefault: true, near: 0.1, position: [10, 10, 10] })) : (_jsx(OrthographicCamera, { far: 1000, makeDefault: true, near: -1000, position: [10, 10, 10], zoom: 20 }));
+};

package/dist/hooks/use-asset-url.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Resolves an asset:// URL to a blob URL for use with Three.js loaders.
+ * Returns null while loading or if resolution fails.
+ */
+export declare function useAssetUrl(url: string): string | null;
+//# sourceMappingURL=use-asset-url.d.ts.map

package/dist/hooks/use-asset-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-asset-url.d.ts","sourceRoot":"","sources":["../../src/hooks/use-asset-url.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAetD"}

package/dist/hooks/use-asset-url.js

@@ -0,0 +1,21 @@
+import { loadAssetUrl } from '@pascal-app/core';
+import { useEffect, useState } from 'react';
+/**
+ * Resolves an asset:// URL to a blob URL for use with Three.js loaders.
+ * Returns null while loading or if resolution fails.
+ */
+export function useAssetUrl(url) {
+    const [resolved, setResolved] = useState(null);
+    useEffect(() => {
+        let cancelled = false;
+        setResolved(null);
+        loadAssetUrl(url).then((result) => {
+            if (!cancelled)
+                setResolved(result);
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [url]);
+    return resolved;
+}

package/dist/hooks/use-gltf-ktx2.d.ts

@@ -0,0 +1,4 @@
+import { useGLTF } from "@react-three/drei";
+declare const useGLTFKTX2: (path: string) => ReturnType<typeof useGLTF>;
+export { useGLTFKTX2 };
+//# sourceMappingURL=use-gltf-ktx2.d.ts.map

package/dist/hooks/use-gltf-ktx2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-gltf-ktx2.d.ts","sourceRoot":"","sources":["../../src/hooks/use-gltf-ktx2.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAQ3C,QAAA,MAAM,WAAW,GAAI,MAAM,MAAM,KAAG,UAAU,CAAC,OAAO,OAAO,CAS5D,CAAA;AACD,OAAO,EAAE,WAAW,EAAE,CAAA"}

package/dist/hooks/use-gltf-ktx2.js

@@ -0,0 +1,16 @@
+import { useGLTF } from "@react-three/drei";
+import { useThree } from "@react-three/fiber";
+import { KTX2Loader } from "three/examples/jsm/Addons.js";
+import { MeshoptDecoder } from "three/examples/jsm/libs/meshopt_decoder.module.js";
+const ktx2LoaderInstance = new KTX2Loader();
+ktx2LoaderInstance.setTranscoderPath('https://cdn.jsdelivr.net/gh/pmndrs/drei-assets@master/basis/');
+const useGLTFKTX2 = (path) => {
+    const gl = useThree((state) => state.gl);
+    return useGLTF(path, true, true, (loader) => {
+        ktx2LoaderInstance.detectSupport(gl);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        loader.setKTX2Loader(ktx2LoaderInstance);
+        loader.setMeshoptDecoder(MeshoptDecoder);
+    });
+};
+export { useGLTFKTX2 };

package/dist/hooks/use-grid-events.d.ts

@@ -0,0 +1,12 @@
+import type { ThreeEvent } from "@react-three/fiber";
+export declare function useGridEvents(): {
+    onPointerDown: (e: ThreeEvent<PointerEvent>) => void;
+    onPointerUp: (e: ThreeEvent<PointerEvent>) => void;
+    onClick: (e: ThreeEvent<PointerEvent>) => void;
+    onPointerEnter: (e: ThreeEvent<PointerEvent>) => void;
+    onPointerLeave: (e: ThreeEvent<PointerEvent>) => void;
+    onPointerMove: (e: ThreeEvent<PointerEvent>) => void;
+    onDoubleClick: (e: ThreeEvent<PointerEvent>) => void;
+    onContextMenu: (e: ThreeEvent<PointerEvent>) => void;
+};
+//# sourceMappingURL=use-grid-events.d.ts.map

package/dist/hooks/use-grid-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-grid-events.d.ts","sourceRoot":"","sources":["../../src/hooks/use-grid-events.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD,wBAAgB,aAAa;uBAYN,UAAU,CAAC,YAAY,CAAC;qBAI1B,UAAU,CAAC,YAAY,CAAC;iBAI5B,UAAU,CAAC,YAAY,CAAC;wBAIjB,UAAU,CAAC,YAAY,CAAC;wBACxB,UAAU,CAAC,YAAY,CAAC;uBACzB,UAAU,CAAC,YAAY,CAAC;uBACxB,UAAU,CAAC,YAAY,CAAC;uBACxB,UAAU,CAAC,YAAY,CAAC;EAE9C"}

package/dist/hooks/use-grid-events.js

@@ -0,0 +1,33 @@
+import { emitter } from "@pascal-app/core";
+export function useGridEvents() {
+    const emit = (suffix, e) => {
+        const eventKey = `grid:${suffix}`;
+        const payload = {
+            position: [e.point.x, e.point.y, e.point.z],
+            nativeEvent: e,
+        };
+        emitter.emit(eventKey, payload);
+    };
+    return {
+        onPointerDown: (e) => {
+            if (e.button !== 0)
+                return;
+            emit("pointerdown", e);
+        },
+        onPointerUp: (e) => {
+            if (e.button !== 0)
+                return;
+            emit("pointerup", e);
+        },
+        onClick: (e) => {
+            if (e.button !== 0)
+                return;
+            emit("click", e);
+        },
+        onPointerEnter: (e) => emit("enter", e),
+        onPointerLeave: (e) => emit("leave", e),
+        onPointerMove: (e) => emit("move", e),
+        onDoubleClick: (e) => emit("double-click", e),
+        onContextMenu: (e) => emit("context-menu", e),
+    };
+}

package/dist/hooks/use-node-events.d.ts

@@ -0,0 +1,49 @@
+import { type BuildingEvent, type BuildingNode, type CeilingEvent, type CeilingNode, type ItemEvent, type ItemNode, type LevelEvent, type LevelNode, type RoofEvent, type RoofNode, type SlabEvent, type SlabNode, type WallEvent, type WallNode, type ZoneEvent, type ZoneNode } from '@pascal-app/core';
+import type { ThreeEvent } from '@react-three/fiber';
+type NodeConfig = {
+    item: {
+        node: ItemNode;
+        event: ItemEvent;
+    };
+    wall: {
+        node: WallNode;
+        event: WallEvent;
+    };
+    building: {
+        node: BuildingNode;
+        event: BuildingEvent;
+    };
+    level: {
+        node: LevelNode;
+        event: LevelEvent;
+    };
+    zone: {
+        node: ZoneNode;
+        event: ZoneEvent;
+    };
+    slab: {
+        node: SlabNode;
+        event: SlabEvent;
+    };
+    ceiling: {
+        node: CeilingNode;
+        event: CeilingEvent;
+    };
+    roof: {
+        node: RoofNode;
+        event: RoofEvent;
+    };
+};
+type NodeType = keyof NodeConfig;
+export declare function useNodeEvents<T extends NodeType>(node: NodeConfig[T]['node'], type: T): {
+    onPointerDown: (e: ThreeEvent<PointerEvent>) => void;
+    onPointerUp: (e: ThreeEvent<PointerEvent>) => void;
+    onClick: (e: ThreeEvent<PointerEvent>) => void;
+    onPointerEnter: (e: ThreeEvent<PointerEvent>) => void;
+    onPointerLeave: (e: ThreeEvent<PointerEvent>) => void;
+    onPointerMove: (e: ThreeEvent<PointerEvent>) => void;
+    onDoubleClick: (e: ThreeEvent<PointerEvent>) => void;
+    onContextMenu: (e: ThreeEvent<PointerEvent>) => void;
+};
+export {};
+//# sourceMappingURL=use-node-events.d.ts.map

package/dist/hooks/use-node-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-node-events.d.ts","sourceRoot":"","sources":["../../src/hooks/use-node-events.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,WAAW,EAGhB,KAAK,SAAS,EACd,KAAK,QAAQ,EACb,KAAK,UAAU,EACf,KAAK,SAAS,EACd,KAAK,SAAS,EACd,KAAK,QAAQ,EACb,KAAK,SAAS,EACd,KAAK,QAAQ,EACb,KAAK,SAAS,EACd,KAAK,QAAQ,EACb,KAAK,SAAS,EACd,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAEpD,KAAK,UAAU,GAAG;IAChB,IAAI,EAAE;QAAE,IAAI,EAAE,QAAQ,CAAC;QAAC,KAAK,EAAE,SAAS,CAAA;KAAE,CAAA;IAC1C,IAAI,EAAE;QAAE,IAAI,EAAE,QAAQ,CAAC;QAAC,KAAK,EAAE,SAAS,CAAA;KAAE,CAAA;IAC1C,QAAQ,EAAE;QAAE,IAAI,EAAE,YAAY,CAAC;QAAC,KAAK,EAAE,aAAa,CAAA;KAAE,CAAA;IACtD,KAAK,EAAE;QAAE,IAAI,EAAE,SAAS,CAAC;QAAC,KAAK,EAAE,UAAU,CAAA;KAAE,CAAA;IAC7C,IAAI,EAAE;QAAE,IAAI,EAAE,QAAQ,CAAC;QAAC,KAAK,EAAE,SAAS,CAAA;KAAE,CAAA;IAC1C,IAAI,EAAE;QAAE,IAAI,EAAE,QAAQ,CAAC;QAAC,KAAK,EAAE,SAAS,CAAA;KAAE,CAAA;IAC1C,OAAO,EAAE;QAAE,IAAI,EAAE,WAAW,CAAC;QAAC,KAAK,EAAE,YAAY,CAAA;KAAE,CAAA;IACnD,IAAI,EAAE;QAAE,IAAI,EAAE,QAAQ,CAAC;QAAC,KAAK,EAAE,SAAS,CAAA;KAAE,CAAA;CAC3C,CAAA;AAED,KAAK,QAAQ,GAAG,MAAM,UAAU,CAAA;AAEhC,wBAAgB,aAAa,CAAC,CAAC,SAAS,QAAQ,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC;uBAiB/D,UAAU,CAAC,YAAY,CAAC;qBAI1B,UAAU,CAAC,YAAY,CAAC;iBAI5B,UAAU,CAAC,YAAY,CAAC;wBAIjB,UAAU,CAAC,YAAY,CAAC;wBACxB,UAAU,CAAC,YAAY,CAAC;uBACzB,UAAU,CAAC,YAAY,CAAC;uBACxB,UAAU,CAAC,YAAY,CAAC;uBACxB,UAAU,CAAC,YAAY,CAAC;EAE9C"}

package/dist/hooks/use-node-events.js

@@ -0,0 +1,38 @@
+import { emitter, } from '@pascal-app/core';
+export function useNodeEvents(node, type) {
+    const emit = (suffix, e) => {
+        const eventKey = `${type}:${suffix}`;
+        const localPoint = e.object.worldToLocal(e.point.clone());
+        const payload = {
+            node,
+            position: [e.point.x, e.point.y, e.point.z],
+            localPosition: [localPoint.x, localPoint.y, localPoint.z],
+            normal: e.face ? [e.face.normal.x, e.face.normal.y, e.face.normal.z] : undefined,
+            stopPropagation: () => e.stopPropagation(),
+            nativeEvent: e,
+        };
+        emitter.emit(eventKey, payload);
+    };
+    return {
+        onPointerDown: (e) => {
+            if (e.button !== 0)
+                return;
+            emit('pointerdown', e);
+        },
+        onPointerUp: (e) => {
+            if (e.button !== 0)
+                return;
+            emit('pointerup', e);
+        },
+        onClick: (e) => {
+            if (e.button !== 0)
+                return;
+            emit('click', e);
+        },
+        onPointerEnter: (e) => emit('enter', e),
+        onPointerLeave: (e) => emit('leave', e),
+        onPointerMove: (e) => emit('move', e),
+        onDoubleClick: (e) => emit('double-click', e),
+        onContextMenu: (e) => emit('context-menu', e),
+    };
+}