@pascal-app/nodes 1.0.0-beta.4 → 1.0.0

package/dist/wall/wall-batch.js

@@ -0,0 +1,169 @@
+import { hideFromScene, showInScene } from '@pascal-app/viewer';
+import * as THREE from 'three';
+const BATCH_ATTRIBUTES = ['position', 'normal', 'uv', 'uv2'];
+const ATTRIBUTE_ITEM_SIZE = {
+    position: 3,
+    normal: 3,
+    uv: 2,
+    uv2: 2,
+};
+function planSource(source) {
+    const position = source.geometry.getAttribute('position');
+    if (!position || position.count === 0)
+        return null;
+    const declared = source.geometry.groups.length > 0
+        ? source.geometry.groups
+        : [{ start: 0, count: position.count, materialIndex: 0 }];
+    const groups = [];
+    for (const group of declared) {
+        const start = Math.max(0, group.start);
+        const count = Math.min(group.count, position.count - start);
+        if (count <= 0)
+            continue;
+        groups.push({ materialIndex: group.materialIndex ?? 0, start, count });
+    }
+    return groups.length > 0 ? { source, groups } : null;
+}
+/**
+ * Concatenates wall geometries into one buffer laid out material-major,
+ * wall-minor: every triangle sharing a material index ends up in a single
+ * contiguous run, so the merged mesh costs one draw call per material
+ * instead of one per wall per material.
+ *
+ * Vertices are baked into the batch root's frame, so the merged mesh needs
+ * no transform of its own. Each wall's slice of every run is recorded, which
+ * is what lets a single wall be pulled back out later without touching the
+ * buffers — see `applyWallBatchGroups`.
+ *
+ * Sources must be non-indexed (the wall pipeline's `applyWorldPlanarWallUVs`
+ * already de-indexes) and are skipped if they carry no positions.
+ */
+export function buildWallBatch(sources) {
+    const planned = [];
+    const totals = new Map();
+    for (const source of sources) {
+        const entry = planSource(source);
+        if (!entry)
+            continue;
+        planned.push(entry);
+        for (const group of entry.groups) {
+            totals.set(group.materialIndex, (totals.get(group.materialIndex) ?? 0) + group.count);
+        }
+    }
+    if (planned.length === 0)
+        return null;
+    const names = BATCH_ATTRIBUTES.filter((name) => planned.every((entry) => entry.source.geometry.getAttribute(name)));
+    if (!names.includes('position'))
+        return null;
+    let totalVertices = 0;
+    for (const count of totals.values())
+        totalVertices += count;
+    const buffers = new Map(names.map((name) => [name, new Float32Array(totalVertices * ATTRIBUTE_ITEM_SIZE[name])]));
+    const normalMatrix = new THREE.Matrix3();
+    const vector = new THREE.Vector3();
+    const runs = [];
+    let cursor = 0;
+    for (const materialIndex of [...totals.keys()].sort((left, right) => left - right)) {
+        const runStart = cursor;
+        const slices = [];
+        for (const entry of planned) {
+            const sliceStart = cursor;
+            normalMatrix.getNormalMatrix(entry.source.matrix);
+            for (const group of entry.groups) {
+                if (group.materialIndex !== materialIndex)
+                    continue;
+                copyGroup(entry.source, group, names, buffers, cursor, normalMatrix, vector);
+                cursor += group.count;
+            }
+            if (cursor > sliceStart) {
+                slices.push({ nodeId: entry.source.nodeId, start: sliceStart, count: cursor - sliceStart });
+            }
+        }
+        runs.push({ materialIndex, start: runStart, count: cursor - runStart, slices });
+    }
+    const geometry = new THREE.BufferGeometry();
+    for (const name of names) {
+        geometry.setAttribute(name, new THREE.BufferAttribute(buffers.get(name), ATTRIBUTE_ITEM_SIZE[name]));
+    }
+    geometry.computeBoundingSphere();
+    geometry.computeBoundingBox();
+    const batch = { geometry, runs };
+    applyWallBatchGroups(batch, EMPTY_HIDDEN);
+    return batch;
+}
+const EMPTY_HIDDEN = new Set();
+function copyGroup(source, group, names, buffers, writeAt, normalMatrix, vector) {
+    for (const name of names) {
+        const attribute = source.geometry.getAttribute(name);
+        const target = buffers.get(name);
+        const itemSize = ATTRIBUTE_ITEM_SIZE[name];
+        for (let offset = 0; offset < group.count; offset += 1) {
+            const from = group.start + offset;
+            const to = (writeAt + offset) * itemSize;
+            if (name === 'position') {
+                vector.fromBufferAttribute(attribute, from).applyMatrix4(source.matrix);
+                target[to] = vector.x;
+                target[to + 1] = vector.y;
+                target[to + 2] = vector.z;
+            }
+            else if (name === 'normal') {
+                vector.fromBufferAttribute(attribute, from).applyMatrix3(normalMatrix).normalize();
+                target[to] = vector.x;
+                target[to + 1] = vector.y;
+                target[to + 2] = vector.z;
+            }
+            else {
+                target[to] = attribute.getX(from);
+                target[to + 1] = attribute.getY(from);
+            }
+        }
+    }
+}
+/**
+ * Rewrites the merged geometry's draw groups so the listed walls are skipped.
+ *
+ * Pulling a wall out of the batch is what happens while it is being dragged:
+ * it goes back to drawing itself, and the merged mesh has to stop drawing it
+ * or the two would overlap. Because each wall owns a contiguous slice of each
+ * run, skipping it is a matter of splitting that run around the hole — no
+ * vertex data moves and nothing is re-uploaded to the GPU, so a drag costs a
+ * handful of group objects rather than a rebuild of the floor.
+ *
+ * Each hidden wall adds at most one extra group (one extra draw call) per run,
+ * so callers should re-merge once the holes stop being temporary.
+ */
+export function applyWallBatchGroups(batch, hidden) {
+    batch.geometry.clearGroups();
+    for (const run of batch.runs) {
+        let cursor = run.start;
+        if (hidden.size > 0) {
+            for (const slice of run.slices) {
+                if (!hidden.has(slice.nodeId))
+                    continue;
+                if (slice.start > cursor) {
+                    batch.geometry.addGroup(cursor, slice.start - cursor, run.materialIndex);
+                }
+                cursor = slice.start + slice.count;
+            }
+        }
+        const end = run.start + run.count;
+        if (end > cursor)
+            batch.geometry.addGroup(cursor, end - cursor, run.materialIndex);
+    }
+}
+/**
+ * Silences a wall the batch now draws.
+ *
+ * Emptying the draw range is not enough — three.js still submits a zero-count
+ * group, so 1000 muted walls cost 1000 draw calls. `visible = false` would
+ * cost nothing but takes the wall's children (cutters, treatments) down with
+ * it. Moving the mesh alone off the scene layer skips it in every pass while
+ * its subtree keeps rendering and picking.
+ */
+export function hideBatchedWall(mesh) {
+    hideFromScene(mesh, 'wall-batched');
+}
+/** Hands a wall back its own draw call — unless solo or isolation still hide it. */
+export function revealBatchedWall(mesh) {
+    showInScene(mesh, 'wall-batched');
+}

package/dist/window/definition.d.ts

@@ -1,5 +1,6 @@
-import type { NodeDefinition } from '@pascal-app/core';
+import type { AnyNodeId, NodeDefinition, SceneApi, WindowNode as WindowNodeType } from '@pascal-app/core';
 import { WindowNode } from './schema';
+export declare function resolveWindowHandlePortalTarget(window: WindowNodeType, scene: Pick<SceneApi, 'get'>): AnyNodeId | null;
 /**
  * Window — Phase 5 batch kind. Mirrors door's shape: hosted on walls,
  * cuts holes in them, animated open/close state for opening windows.

package/dist/window/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/window/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,cAAc,EAIf,MAAM,kBAAkB,CAAA;AAiBzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAkIrC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CAqG9D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/window/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EAGT,cAAc,EAEd,QAAQ,EAER,UAAU,IAAI,cAAc,EAC7B,MAAM,kBAAkB,CAAA;AAqBzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAQrC,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,cAAc,EACtB,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,GAC3B,SAAS,GAAG,IAAI,CAWlB;AA0JD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CAqG9D,CAAA"}

package/dist/window/definition.js

@@ -1,3 +1,4 @@
+import { getDormerWallHorizontalBoundsAtHeight, getDormerWallOpeningVerticalBounds, } from '@pascal-app/core';
 import { buildWindowFloorplanSchedule, computeWindowFloorplanLevelData, } from '../shared/opening-documentation';
 import { publishOpeningResizeGuides } from '../shared/opening-guides-runtime';
 import { readRoofFaceHeightMax, readRoofFaceWidthMax } from '../shared/roof-opening-host';
@@ -16,9 +17,19 @@ const SIDE_HANDLE_OFFSET = 0.24;
 const HEIGHT_HANDLE_OFFSET = 0.24;
 const MIN_WINDOW_HEIGHT = 0.3;
 const MIN_WINDOW_WIDTH = 0.3;
-// How far the move cross floats off the wall face (+Z, the window's facing
-// normal) so it's grabbable instead of buried in the sash/frame.
-const MOVE_HANDLE_LIFT = 0.12;
+export function resolveWindowHandlePortalTarget(window, scene) {
+    const parentId = window.parentId;
+    if (!parentId)
+        return null;
+    const grandparentId = scene.get(parentId)
+        ?.parentId;
+    if (!grandparentId)
+        return null;
+    if (window.dormerId !== parentId)
+        return grandparentId;
+    return (scene.get(grandparentId)?.parentId ??
+        grandparentId);
+}
 function readWallLength(w, scene) {
     if (!w.wallId)
         return Number.POSITIVE_INFINITY;
@@ -27,6 +38,30 @@ function readWallLength(w, scene) {
         return Number.POSITIVE_INFINITY;
     return Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
 }
+function resolveDormerHost(window, scene) {
+    const dormerId = window.dormerId ?? window.parentId;
+    if (!dormerId)
+        return null;
+    const dormer = scene.get(dormerId);
+    return dormer?.type === 'dormer' ? dormer : null;
+}
+function readDormerFaceWidthMax(window, scene, localGrowSign) {
+    const dormer = resolveDormerHost(window, scene);
+    if (!dormer)
+        return null;
+    const bounds = getDormerWallHorizontalBoundsAtHeight(dormer, window.dormerFace ?? 'front', window.position[1] + window.height / 2);
+    const faceGrowSign = Math.cos(window.rotation[1]) >= 0 ? localGrowSign : -localGrowSign;
+    const anchorX = window.position[0] - (faceGrowSign * window.width) / 2;
+    return faceGrowSign > 0 ? bounds.max - anchorX : anchorX - bounds.min;
+}
+function readDormerFaceHeightMax(window, scene, growSign) {
+    const dormer = resolveDormerHost(window, scene);
+    if (!dormer)
+        return null;
+    const bounds = getDormerWallOpeningVerticalBounds(dormer, window.dormerFace ?? 'front', window.position[0], window.width);
+    const anchorY = window.position[1] - (growSign * window.height) / 2;
+    return growSign > 0 ? bounds.max - anchorY : anchorY - bounds.min;
+}
 function windowWidthHandle(side) {
     const sign = side === 'right' ? 1 : -1;
     return {
@@ -36,8 +71,12 @@ function windowWidthHandle(side) {
         // front instead of edge-on (the window sits on a vertical wall).
         faceNormal: true,
         anchor: side === 'right' ? 'min' : 'max',
+        gridSnap: true,
         min: MIN_WINDOW_WIDTH,
         max: (n, scene) => {
+            const dormerMax = readDormerFaceWidthMax(n, scene, sign);
+            if (dormerMax !== null)
+                return Math.max(MIN_WINDOW_WIDTH, dormerMax);
             // Roof-hosted windows clamp against the face profile (the
             // wall-based limits read Infinity when wallId is unset).
             const roofMax = readRoofFaceWidthMax(n, scene, sign);
@@ -67,6 +106,7 @@ function windowWidthHandle(side) {
             rotationY: () => (side === 'right' ? 0 : Math.PI),
         },
         portal: 'grandparent',
+        portalTarget: resolveWindowHandlePortalTarget,
     };
 }
 // Window height has two arrows (top + bottom edge) — each anchors at the
@@ -79,8 +119,12 @@ function windowHeightHandle(edge) {
         axis: 'y',
         // top arrow anchors at -Y (bottom stays fixed); bottom at +Y (top stays).
         anchor: edge === 'top' ? 'min' : 'max',
+        gridSnap: true,
         min: MIN_WINDOW_HEIGHT,
         max: (n, scene) => {
+            const dormerMax = readDormerFaceHeightMax(n, scene, sign);
+            if (dormerMax !== null)
+                return Math.max(MIN_WINDOW_HEIGHT, dormerMax);
             const roofMax = readRoofFaceHeightMax(n, scene, sign);
             if (roofMax !== null)
                 return Math.max(MIN_WINDOW_HEIGHT, roofMax);
@@ -110,27 +154,10 @@ function windowHeightHandle(edge) {
             position: (n) => [0, sign * (n.height / 2 + HEIGHT_HANDLE_OFFSET), 0],
         },
         portal: 'grandparent',
-    };
-}
-// Press-drag move grip at the window centre, standing in the wall face. Routes
-// through the same move tool as the floating Move button (3D
-// `affordanceTools.move`, 2D `floorplanMoveTarget`) — slide within the wall
-// plane + re-host onto another wall — committing on release, no second click.
-function windowMoveHandle() {
-    return {
-        kind: 'tap-action',
-        shape: 'move-cross',
-        plane: 'node-normal',
-        portal: 'grandparent',
-        cursor: 'move',
-        onActivate: (node, _scene, editor) => editor.engageMoveDrag(node),
-        placement: {
-            position: () => [0, 0, MOVE_HANDLE_LIFT],
-        },
+        portalTarget: resolveWindowHandlePortalTarget,
     };
 }
 const windowHandles = [
-    windowMoveHandle(),
     windowWidthHandle('left'),
     windowWidthHandle('right'),
     windowHeightHandle('top'),
@@ -151,7 +178,7 @@ export const windowDefinition = {
     kind: 'window',
     snapProfile: 'item',
     facingIndicator: true,
-    schemaVersion: 2,
+    schemaVersion: 3,
     schema: WindowNode,
     category: 'structure',
     extensions: {
@@ -180,9 +207,9 @@ export const windowDefinition = {
             cutScope: 'wall',
             dirtyHandledByOwnSystem: true,
         },
-        // `wallId` / `roofSegmentId` are re-derived from the surface under
+        // `wallId` / `roofSegmentId` / `dormerId` are re-derived from the surface under
         // the cursor at preset placement time — see door for the pattern.
-        hostRefFields: ['wallId', 'roofSegmentId', 'roofFace'],
+        hostRefFields: ['wallId', 'roofSegmentId', 'roofFace', 'dormerId', 'dormerFace'],
         // Frame / glass slots painted through the registry. The window system tags
         // each mesh with its `userData.slotId`; paint writes `node.slots`.
         slots: () => windowSlots(),

package/dist/window/floorplan-move.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/window/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EAOxB,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAmBzB;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,yBAAyB,EAAE,mBAAmB,CAAC,UAAU,CAiPrE,CAAA"}
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/window/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EAOxB,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAmBzB;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,yBAAyB,EAAE,mBAAmB,CAAC,UAAU,CAkPrE,CAAA"}

package/dist/window/floorplan-move.js

@@ -198,7 +198,7 @@ export const windowFloorplanMoveTarget = ({ node }) => {
                 return false;
             // Block on overlap UNLESS Alt force-places — same `placeable` rule as
             // the 3D move + the shared `resolveOpeningPlacement`.
-            const collides = hasWallChildOverlap(lastValid.parentId, lastValid.position[0], lastValid.position[1], live.width, live.height, live.id);
+            const collides = hasWallChildOverlap(lastValid.parentId, useScene.getState().nodes, lastValid.position[0], lastValid.position[1], live.width, live.height, live.id);
             return resolveOpeningPlacement({ collides, forcePlace }).placeable;
         },
         commit() {

package/dist/window/move-tool.d.ts

@@ -3,13 +3,15 @@ import { WindowNode } from '@pascal-app/core';
  * Move/duplicate tool for WindowNodes — wall-only, same guardrails as WindowTool.
  *
  * Move mode (metadata.isNew falsy):
- *   Adopts the existing window, pauses temporal. On commit: restores original state
- *   (clean undo baseline) then resumes + updateNode (undo reverts to original position).
- *   On cancel: restores original state.
+ *   Adopts the existing window and holds a refcounted history pause for the
+ *   gesture. On commit: restores original state (clean undo baseline) then runs
+ *   updateNode as the gesture's single tracked write (undo reverts to the
+ *   original position). On cancel: restores original state, never tracked.
  *
  * Duplicate mode (metadata.isNew = true):
- *   The node is a freshly created transient copy. On commit: deletes transient + resumes
- *   + createNode (undo removes the new window entirely). On cancel: deletes the node.
+ *   The node is a freshly created transient copy. On commit: deletes the
+ *   transient paused + createNode as the single tracked write (undo removes the
+ *   new window entirely). On cancel: deletes the node.
  */
 declare const MoveWindowTool: React.FC<{
     node: WindowNode;

package/dist/window/move-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/window/move-tool.tsx"],"names":[],"mappings":"AAAA,OAAO,EAYL,UAAU,EACX,MAAM,kBAAkB,CAAA;AAqDzB;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAigClD,CAAA;AAED,eAAe,cAAc,CAAA"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/window/move-tool.tsx"],"names":[],"mappings":"AAAA,OAAO,EAiBL,UAAU,EACX,MAAM,kBAAkB,CAAA;AAiEzB;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAoyClD,CAAA;AAED,eAAe,cAAc,CAAA"}