@pascal-app/viewer 0.6.0 → 0.8.0

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

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

package/dist/systems/column/column-geometry.d.ts

@@ -0,0 +1,22 @@
+import { type BufferGeometry } from 'three';
+export declare function createColumnBoxGeometry(width: number, height: number, depth: number, bevelRadius?: number): BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>;
+export declare function createColumnCylinderGeometry({ height, radiusBottom, radiusTop, radiusX, radiusZ, segments, }: {
+    height: number;
+    radiusBottom: number;
+    radiusTop?: number;
+    radiusX?: number;
+    radiusZ?: number;
+    segments?: number;
+}): BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>;
+export declare function createColumnSphereGeometry(radius: number, widthSegments?: number, heightSegments?: number): BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>;
+export declare function createColumnTorusGeometry({ arc, radialSegments, ringRadius, scaleX, scaleY, scaleZ, tubeRadius, tubularSegments, }: {
+    arc?: number;
+    radialSegments?: number;
+    ringRadius: number;
+    scaleX?: number;
+    scaleY?: number;
+    scaleZ?: number;
+    tubeRadius: number;
+    tubularSegments?: number;
+}): BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>;
+//# sourceMappingURL=column-geometry.d.ts.map

package/dist/systems/column/column-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"column-geometry.d.ts","sourceRoot":"","sources":["../../../src/systems/column/column-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EAKpB,MAAM,OAAO,CAAA;AAkHd,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,WAAW,SAAI,kGAOhB;AAED,wBAAgB,4BAA4B,CAAC,EAC3C,MAAM,EACN,YAAY,EACZ,SAAwB,EACxB,OAAW,EACX,OAAW,EACX,QAAa,GACd,EAAE;IACD,MAAM,EAAE,MAAM,CAAA;IACd,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,kGASA;AAED,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM,EAAE,aAAa,SAAK,EAAE,cAAc,SAAI,kGAEhG;AAED,wBAAgB,yBAAyB,CAAC,EACxC,GAAiB,EACjB,cAAmB,EACnB,UAAU,EACV,MAAmB,EACnB,MAAmB,EACnB,MAAU,EACV,UAAU,EACV,eAAoB,GACrB,EAAE;IACD,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,UAAU,EAAE,MAAM,CAAA;IAClB,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB,kGAIA"}

package/dist/systems/column/column-geometry.js

@@ -0,0 +1,108 @@
+import { BoxGeometry, CylinderGeometry, Float32BufferAttribute, SphereGeometry, TorusGeometry, } from 'three';
+import { RoundedBoxGeometry } from 'three/examples/jsm/geometries/RoundedBoxGeometry.js';
+const COLUMN_UV_SCALE = 1;
+function setUvAttributes(geometry, uvs) {
+    geometry.setAttribute('uv', new Float32BufferAttribute(uvs, 2));
+    geometry.setAttribute('uv2', new Float32BufferAttribute(uvs.slice(), 2));
+    return geometry;
+}
+function toUvReadyGeometry(geometry) {
+    return geometry.index ? geometry.toNonIndexed() : geometry;
+}
+function applyPlanarColumnUvs(geometry) {
+    const mappedGeometry = toUvReadyGeometry(geometry);
+    const positions = mappedGeometry.getAttribute('position');
+    const normals = mappedGeometry.getAttribute('normal');
+    const uvs = [];
+    for (let index = 0; index < positions.count; index += 1) {
+        const x = positions.getX(index);
+        const y = positions.getY(index);
+        const z = positions.getZ(index);
+        const normalX = normals ? Math.abs(normals.getX(index)) : 0;
+        const normalY = normals ? Math.abs(normals.getY(index)) : 1;
+        const normalZ = normals ? Math.abs(normals.getZ(index)) : 0;
+        if (normalY >= normalX && normalY >= normalZ) {
+            uvs.push(x * COLUMN_UV_SCALE, z * COLUMN_UV_SCALE);
+        }
+        else if (normalX >= normalZ) {
+            uvs.push(z * COLUMN_UV_SCALE, y * COLUMN_UV_SCALE);
+        }
+        else {
+            uvs.push(x * COLUMN_UV_SCALE, y * COLUMN_UV_SCALE);
+        }
+    }
+    return setUvAttributes(mappedGeometry, uvs);
+}
+function ellipseCircumference(radiusX, radiusZ) {
+    const a = Math.max(0.001, Math.abs(radiusX));
+    const b = Math.max(0.001, Math.abs(radiusZ));
+    return Math.PI * (3 * (a + b) - Math.sqrt((3 * a + b) * (a + 3 * b)));
+}
+function applyCylindricalColumnUvs(geometry, sideCircumference, height) {
+    const mappedGeometry = toUvReadyGeometry(geometry);
+    const positions = mappedGeometry.getAttribute('position');
+    const normals = mappedGeometry.getAttribute('normal');
+    const defaultUvs = mappedGeometry.getAttribute('uv');
+    const halfHeight = height / 2;
+    const uvs = [];
+    for (let index = 0; index < positions.count; index += 1) {
+        const x = positions.getX(index);
+        const y = positions.getY(index);
+        const z = positions.getZ(index);
+        const normalY = normals ? Math.abs(normals.getY(index)) : 0;
+        if (normalY > 0.65) {
+            uvs.push(x * COLUMN_UV_SCALE, z * COLUMN_UV_SCALE);
+        }
+        else {
+            const defaultU = defaultUvs ? defaultUvs.getX(index) : 0;
+            uvs.push(defaultU * sideCircumference * COLUMN_UV_SCALE, (y + halfHeight) * COLUMN_UV_SCALE);
+        }
+    }
+    return setUvAttributes(mappedGeometry, uvs);
+}
+function applySphericalColumnUvs(geometry, radius) {
+    const mappedGeometry = toUvReadyGeometry(geometry);
+    const defaultUvs = mappedGeometry.getAttribute('uv');
+    if (!defaultUvs)
+        return mappedGeometry;
+    const uvs = [];
+    const circumference = Math.PI * 2 * radius;
+    const arcHeight = Math.PI * radius;
+    for (let index = 0; index < defaultUvs.count; index += 1) {
+        uvs.push(defaultUvs.getX(index) * circumference * COLUMN_UV_SCALE, defaultUvs.getY(index) * arcHeight * COLUMN_UV_SCALE);
+    }
+    return setUvAttributes(mappedGeometry, uvs);
+}
+function applyTorusColumnUvs(geometry, ringRadius, tubeRadius) {
+    const mappedGeometry = toUvReadyGeometry(geometry);
+    const defaultUvs = mappedGeometry.getAttribute('uv');
+    if (!defaultUvs)
+        return mappedGeometry;
+    const uvs = [];
+    const ringLength = Math.PI * 2 * Math.max(0.001, ringRadius);
+    const tubeLength = Math.PI * 2 * Math.max(0.001, tubeRadius);
+    for (let index = 0; index < defaultUvs.count; index += 1) {
+        uvs.push(defaultUvs.getX(index) * ringLength * COLUMN_UV_SCALE, defaultUvs.getY(index) * tubeLength * COLUMN_UV_SCALE);
+    }
+    return setUvAttributes(mappedGeometry, uvs);
+}
+export function createColumnBoxGeometry(width, height, depth, bevelRadius = 0) {
+    const geometry = bevelRadius > 0.001
+        ? new RoundedBoxGeometry(width, height, depth, 3, bevelRadius)
+        : new BoxGeometry(width, height, depth);
+    return applyPlanarColumnUvs(geometry);
+}
+export function createColumnCylinderGeometry({ height, radiusBottom, radiusTop = radiusBottom, radiusX = 1, radiusZ = 1, segments = 32, }) {
+    const geometry = new CylinderGeometry(radiusTop, radiusBottom, height, segments);
+    geometry.scale(radiusX, 1, radiusZ);
+    const sideRadius = Math.max(radiusTop, radiusBottom);
+    return applyCylindricalColumnUvs(geometry, ellipseCircumference(sideRadius * radiusX, sideRadius * radiusZ), height);
+}
+export function createColumnSphereGeometry(radius, widthSegments = 10, heightSegments = 8) {
+    return applySphericalColumnUvs(new SphereGeometry(radius, widthSegments, heightSegments), radius);
+}
+export function createColumnTorusGeometry({ arc = Math.PI * 2, radialSegments = 10, ringRadius, scaleX = ringRadius, scaleY = ringRadius, scaleZ = 1, tubeRadius, tubularSegments = 24, }) {
+    const geometry = new TorusGeometry(1, 0.18, radialSegments, tubularSegments, arc);
+    geometry.scale(scaleX, scaleY, scaleZ);
+    return applyTorusColumnUvs(geometry, ringRadius, tubeRadius);
+}

package/dist/systems/door/door-animation-system.d.ts

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

package/dist/systems/door/door-animation-system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"door-animation-system.d.ts","sourceRoot":"","sources":["../../../src/systems/door/door-animation-system.tsx"],"names":[],"mappings":"AAYA,eAAO,MAAM,mBAAmB,YA8C/B,CAAA"}

package/dist/systems/door/door-animation-system.js

@@ -0,0 +1,53 @@
+import { emitter, useInteractive, useScene } from '@pascal-app/core';
+import { useFrame } from '@react-three/fiber';
+const easeDoorAnimation = (value) => value * value * (3 - 2 * value);
+function markDoorDirty(doorId) {
+    const scene = useScene.getState();
+    const node = scene.nodes[doorId];
+    scene.dirtyNodes.add(doorId);
+    if (node?.parentId)
+        scene.dirtyNodes.add(node.parentId);
+}
+export const DoorAnimationSystem = () => {
+    useFrame(({ clock }) => {
+        const interactive = useInteractive.getState();
+        const entries = Object.entries(interactive.doorAnimations);
+        if (entries.length === 0)
+            return;
+        const now = clock.getElapsedTime() * 1000;
+        for (const [doorId, animation] of entries) {
+            const typedDoorId = doorId;
+            const scene = useScene.getState();
+            const node = scene.nodes[typedDoorId];
+            if (node?.type !== 'door') {
+                interactive.cancelDoorAnimation(typedDoorId);
+                interactive.removeDoorOpenState(typedDoorId);
+                continue;
+            }
+            const startedAt = animation.startedAt ?? now;
+            if (animation.startedAt === null) {
+                interactive.startDoorAnimation(typedDoorId, { ...animation, startedAt });
+            }
+            const progress = Math.min(1, (now - startedAt) / animation.durationMs);
+            const value = animation.from + (animation.to - animation.from) * easeDoorAnimation(progress);
+            interactive.setDoorOpenState(typedDoorId, { [animation.field]: value });
+            markDoorDirty(typedDoorId);
+            if (progress < 1)
+                continue;
+            interactive.cancelDoorAnimation(typedDoorId);
+            if (animation.persist) {
+                scene.updateNode(typedDoorId, { [animation.field]: animation.to });
+                interactive.removeDoorOpenState(typedDoorId);
+                markDoorDirty(typedDoorId);
+            }
+            else {
+                interactive.setDoorOpenState(typedDoorId, { [animation.field]: animation.to });
+            }
+            emitter.emit('door:animation-completed', {
+                doorId: typedDoorId,
+                field: animation.field,
+            });
+        }
+    }, 2);
+    return null;
+};

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

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

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

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