@pascal-app/viewer 0.8.0 → 0.9.2

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

@@ -1,6 +1,7 @@
-import { sceneRegistry, useScene } from '@pascal-app/core';
+import { getEffectiveNode, nodeRegistry, sceneRegistry, useLiveTransforms, useScene, } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
 import * as THREE from 'three';
+import { mergeSurfaceHolePolygons } from '../surface-hole-geometry';
 function ensureUv2Attribute(geometry) {
     const uv = geometry.getAttribute('uv');
     if (!uv)
@@ -20,11 +21,16 @@ export const CeilingSystem = () => {
         // Process dirty ceilings
         dirtyNodes.forEach((id) => {
             const node = nodes[id];
-            if (!node || node.type !== 'ceiling')
+            if (node?.type !== 'ceiling')
                 return;
             const mesh = sceneRegistry.nodes.get(id);
             if (mesh) {
-                updateCeilingGeometry(node, mesh);
+                // Merge any live drag override so the polygon / height resize
+                // arrow rebuilds the mesh at pointer rate — zustand only learns
+                // the final value on commit. Mirrors WallSystem / GeometrySystem.
+                const effective = getEffectiveNode(node);
+                const itemHoles = collectCeilingHoles(effective, nodes);
+                updateCeilingGeometry(effective, mesh, itemHoles);
                 clearDirty(id);
             }
             // If mesh not found, keep it dirty for next frame
@@ -32,28 +38,73 @@ export const CeilingSystem = () => {
     });
     return null;
 };
+/**
+ * Collects ceiling-hole polygons from child nodes that declare the `ceilingCut`
+ * capability. Each child's `buildCeilingHole` returns a rotated-rectangle
+ * footprint in ceiling-local [x, z] space (or `null` to opt out), which is
+ * merged as an extra hole before triangulation.
+ *
+ * The viewer never branches on `child.type` — the dispatch goes through
+ * `nodeRegistry`, so any future kind (a heat lamp, a skylight panel, …) can
+ * participate just by declaring `capabilities.ceilingCut` on its definition.
+ */
+function collectCeilingHoles(ceiling, nodes) {
+    const holes = [];
+    for (const childId of ceiling.children ?? []) {
+        const child = nodes[childId];
+        if (!child)
+            continue;
+        const def = nodeRegistry.get(child.type);
+        const hole = def?.capabilities?.ceilingCut?.buildCeilingHole(child);
+        if (hole)
+            holes.push(hole);
+    }
+    return holes;
+}
 /**
  * Updates the geometry for a single ceiling
  */
-function updateCeilingGeometry(node, mesh) {
-    const newGeo = generateCeilingGeometry(node);
+function updateCeilingGeometry(node, mesh, extraHoles = []) {
+    const newGeo = generateCeilingGeometry(node, extraHoles);
     mesh.geometry.dispose();
     mesh.geometry = newGeo;
     const gridMesh = mesh.getObjectByName('ceiling-grid');
     if (gridMesh) {
         gridMesh.geometry.dispose();
-        gridMesh.geometry = newGeo;
+        gridMesh.geometry = newGeo.clone();
     }
-    // Position at the ceiling height
-    mesh.position.y = (node.height ?? 2.5) - 0.01; // Slight offset to avoid z-fighting with upper-level slabs
+    // Position at the ceiling height and reset X/Z so live-drag mesh
+    // offsets (set by move tools during the drag) don't leak into the
+    // canonical position after the rebuild. Matches the pattern used by
+    // FenceSystem.updateFenceGeometry / GeometrySystem (both fully reset
+    // position+rotation after rebuild).
+    const liveTransform = useLiveTransforms.getState().get(node.id);
+    mesh.position.x = liveTransform?.position[0] ?? 0;
+    mesh.position.z = liveTransform?.position[2] ?? 0;
+    mesh.position.y = (node.height ?? 2.5) - 0.01 + (liveTransform?.position[1] ?? 0); // Slight offset to avoid z-fighting with upper-level slabs
 }
 /**
- * Generates flat ceiling geometry from polygon (no extrusion)
+ * Generates flat ceiling geometry from polygon (no extrusion).
+ *
+ * `extraHoles` are transient, derived cutouts (e.g. recessed-fixture
+ * footprints) that are cut alongside the node's persisted `holes` but never
+ * stored on the node — they are recomputed on every rebuild.
  */
-export function generateCeilingGeometry(ceilingNode) {
+export function generateCeilingGeometry(ceilingNode, extraHoles = []) {
     const polygon = ceilingNode.polygon;
     if (polygon.length < 3) {
-        return new THREE.BufferGeometry();
+        // A degenerate ceiling (fewer than 3 points, e.g. mid-edit) still gets a
+        // non-empty position buffer — three zero-vertices forming one invisible
+        // triangle. An empty attribute (count 0) would leave WebGPU vertex buffer
+        // slot 0 unbound when this mesh (and its cloned grid overlay) is drawn,
+        // which the validator rejects ("slot 0 … was not set") and which poisons
+        // the whole command encoder.
+        const degenerate = new THREE.BufferGeometry();
+        degenerate.setAttribute('position', new THREE.Float32BufferAttribute(new Float32Array(9), 3));
+        degenerate.setAttribute('normal', new THREE.Float32BufferAttribute(new Float32Array(9), 3));
+        degenerate.setAttribute('uv', new THREE.Float32BufferAttribute(new Float32Array(6), 2));
+        degenerate.setAttribute('uv2', new THREE.Float32BufferAttribute(new Float32Array(6), 2));
+        return degenerate;
     }
     // Create shape from polygon
     // Shape is in X-Y plane, we'll rotate to X-Z plane
@@ -66,8 +117,10 @@ export function generateCeilingGeometry(ceilingNode) {
         shape.lineTo(pt[0], -pt[1]);
     }
     shape.closePath();
-    // Add holes to the shape
-    const holes = ceilingNode.holes || [];
+    // Add holes to the shape: persisted structural openings (stair/elevator/
+    // manual, merged to dissolve overlaps) plus transient recessed-fixture
+    // cutouts. Both are in the same ceiling-local [x, z] space.
+    const holes = [...mergeSurfaceHolePolygons(ceilingNode.holes || []), ...extraHoles];
     for (const holePolygon of holes) {
         if (holePolygon.length < 3)
             continue;

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=door-animation.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"door-animation.test.d.ts","sourceRoot":"","sources":["../../../src/systems/door/door-animation.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,51 @@
+// @ts-expect-error — bun:test is provided by the Bun runtime; viewer does not
+// depend on @types/bun so the import type is unresolved at compile time.
+import { describe, expect, test } from 'bun:test';
+import { DoorNode } from '@pascal-app/core';
+import * as THREE from 'three';
+import { buildDoorPreviewMesh, poseDoorMovingParts } from '../../index';
+// The named moving group each operation-door builder emits at the closed pose.
+const MOVING_GROUP = {
+    sliding: 'door-sliding-active',
+    pocket: 'door-pocket-leaf',
+    barn: 'door-barn-leaf',
+    'garage-tiltup': 'door-tiltup-leaf',
+    folding: 'door-fold-0',
+    'garage-sectional': 'door-sectional-0',
+    'garage-rollup': 'door-rollup-curtain',
+};
+function worldPosition(object) {
+    object.updateMatrixWorld(true);
+    return object.getWorldPosition(new THREE.Vector3());
+}
+describe('operation door open kinematics', () => {
+    // Each operation door builds its moving parts in a named group at the closed
+    // pose; `poseDoorMovingParts` then drives the open motion (the single source
+    // of truth shared by the live system and the GLB exporter). This guards the
+    // build-once + pose-at-t contract: the group exists, rests closed, and moves.
+    for (const doorType of Object.keys(MOVING_GROUP)) {
+        test(`${doorType} builds a moving group that opens`, () => {
+            const node = DoorNode.parse({ id: `door_${doorType}`, doorType, operationState: 0 });
+            const mesh = buildDoorPreviewMesh(node);
+            const group = mesh.getObjectByName(MOVING_GROUP[doorType]);
+            expect(group).toBeDefined();
+            // Closed snapshot.
+            poseDoorMovingParts(node, mesh, 0);
+            const closedPos = worldPosition(group);
+            const closedScaleY = group.scale.y;
+            const closedRotX = group.rotation.x;
+            const closedRotY = group.rotation.y;
+            // Open snapshot — at least one of translation / rotation / scale changes.
+            poseDoorMovingParts(node, mesh, 1);
+            const openPos = worldPosition(group);
+            const moved = closedPos.distanceTo(openPos) > 0.05 ||
+                Math.abs(closedScaleY - group.scale.y) > 0.1 ||
+                Math.abs(closedRotX - group.rotation.x) > 0.05 ||
+                Math.abs(closedRotY - group.rotation.y) > 0.05;
+            expect(moved).toBe(true);
+            // Posing back to closed is the identity of the rest pose.
+            poseDoorMovingParts(node, mesh, 0);
+            expect(worldPosition(group).distanceTo(closedPos)).toBeLessThan(1e-6);
+        });
+    }
+});

package/dist/systems/door/door-floor-alignment.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=door-floor-alignment.test.d.ts.map

package/dist/systems/door/door-floor-alignment.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"door-floor-alignment.test.d.ts","sourceRoot":"","sources":["../../../src/systems/door/door-floor-alignment.test.ts"],"names":[],"mappings":""}

package/dist/systems/door/door-floor-alignment.test.js

@@ -0,0 +1,50 @@
+// @ts-expect-error — bun:test is provided by the Bun runtime; viewer does not
+// depend on @types/bun so the import type is unresolved at compile time.
+import { describe, expect, test } from 'bun:test';
+import { DoorNode } from '@pascal-app/core';
+import * as THREE from 'three';
+import { buildDoorPreviewMesh } from '../../index';
+const DOOR_TYPES = [
+    'hinged',
+    'double',
+    'french',
+    'folding',
+    'pocket',
+    'barn',
+    'sliding',
+    'garage-sectional',
+    'garage-rollup',
+    'garage-tiltup',
+];
+function visibleBounds(mesh) {
+    mesh.updateMatrixWorld(true);
+    const bounds = new THREE.Box3();
+    for (const child of mesh.children) {
+        if (child.name === 'cutout')
+            continue;
+        bounds.expandByObject(child, true);
+    }
+    return bounds;
+}
+describe('door floor alignment', () => {
+    for (const doorType of DOOR_TYPES) {
+        test(`${doorType} does not extend below the opening floor`, () => {
+            const node = DoorNode.parse({
+                id: `door_floor-alignment-${doorType}`,
+                doorType,
+                operationState: 0,
+                threshold: true,
+            });
+            const mesh = buildDoorPreviewMesh(node);
+            const bounds = visibleBounds(mesh);
+            expect(bounds.min.y).toBeGreaterThanOrEqual(-node.height / 2 - 1e-6);
+        });
+    }
+    test('keeps the wall cutout bottom locked to the opening floor', () => {
+        const node = DoorNode.parse({ id: 'door_floor-alignment-cutout' });
+        const mesh = buildDoorPreviewMesh(node);
+        const cutout = mesh.getObjectByName('cutout');
+        cutout.geometry.computeBoundingBox();
+        expect(cutout.geometry.boundingBox?.min.y).toBeCloseTo(-node.height / 2, 6);
+    });
+});

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

@@ -1,2 +1,26 @@
+import { type DoorNode } from '@pascal-app/core';
+import * as THREE from 'three';
 export declare const DoorSystem: () => null;
+/**
+ * Pose an operation door's moving parts (sliding/pocket/barn leaf, tilt-up and
+ * sectional panels, folding chain, roll-up curtain) at `value` (0 = closed,
+ * 1 = open) by transforming the named groups its builder emitted at the closed
+ * pose. Returns true when the door type has a pose path and its groups exist.
+ *
+ * Mirrors `poseWindowMovingParts`: the live door system calls it after a
+ * (re)build so `operationState` is reflected, and the GLB exporter calls it on a
+ * clone to sample keyframes. Swing doors are not handled here — their leaf group
+ * carries a `pascalSwingLeaf` marker the exporter reads directly.
+ *
+ * Roll-up is the one type whose live geometry changes (slats vanish onto a
+ * drum), which a glTF clip can't express; the baked approximation scales the
+ * curtain up into the lintel. The live roll-up animation keeps its full-detail
+ * rebuild and is intentionally NOT routed through this scale.
+ */
+export declare function poseDoorMovingParts(node: DoorNode, mesh: THREE.Object3D | undefined, value: number): boolean;
+/**
+ * Build a fresh door mesh for preview/ghost rendering.
+ * Returns a mesh with an invisible hitbox root and visible children (frame, panels, hardware).
+ */
+export declare function buildDoorPreviewMesh(node: DoorNode): THREE.Mesh;
 //# sourceMappingURL=door-system.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"door-system.d.ts","sourceRoot":"","sources":["../../../src/systems/door/door-system.tsx"],"names":[],"mappings":"AAiBA,eAAO,MAAM,UAAU,YA2BtB,CAAA"}
+{"version":3,"file":"door-system.d.ts","sourceRoot":"","sources":["../../../src/systems/door/door-system.tsx"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,QAAQ,EAYd,MAAM,kBAAkB,CAAA;AAGzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AA0D9B,eAAO,MAAM,UAAU,YA6GtB,CAAA;AAupCD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,KAAK,CAAC,QAAQ,GAAG,SAAS,EAChC,KAAK,EAAE,MAAM,GACZ,OAAO,CA6GT;AAyuCD;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,GAAG,KAAK,CAAC,IAAI,CAI/D"}