@pascal-app/editor 0.9.2 → 1.0.0-beta.2

package/src/components/tools/registry/move-registry-node-tool.tsx

@@ -23,6 +23,7 @@ import {
   resolveAlignment,
   resolveConnectivityUpdates,
   resolveFacingIndicator,
+  resolveSupportSlabPatch,
   sceneRegistry,
   spatialGridManager,
   useLiveNodeOverrides,
@@ -30,6 +31,7 @@ import {
   useScene,
 } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
+import { useThree } from '@react-three/fiber'
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { markToolCancelConsumed } from '../../../hooks/use-keyboard'
 import { commitFreshPlacementSubtree } from '../../../lib/fresh-planar-placement'
@@ -54,6 +56,7 @@ import { DragBoundingBox } from '../shared/drag-bounding-box'
 import { getFloorStackPreviewPosition } from '../shared/floor-stack-preview'
 import { useFreshPlacementVisibility } from '../shared/fresh-placement-visibility'
 import { PlacementBox } from '../shared/placement-box'
+import { resolvePointerSupportSurface } from '../shared/pointer-support-cap'
 
 /** Snap a world-plan coordinate to the editor's active grid step (0.5 / 0.25
  *  / 0.1 / 0.05), read live so changing the step mid-drag takes effect. */
@@ -231,6 +234,15 @@ const CLICK_TRIGGER_KINDS = [
 ] as const
 
 export function MoveRegistryNodeTool({ node }: { node: AnyNode }) {
+  // Live camera ref — the pointer-surface cap reconstructs the cursor world
+  // ray (camera → grid hit) to find which walking surface is aimed at.
+  const camera = useThree((s) => s.camera)
+  const cameraRef = useRef(camera)
+  cameraRef.current = camera
+  // Level-local elevation of the surface the pointer ray points at,
+  // refreshed per grid move. Caps the floor-support election so a deck
+  // hanging above the aimed-at floor never lifts the dragged node.
+  const supportCapRef = useRef<number | null>(null)
   // Kinds whose `position` lives in a host parent's local frame declare
   // `movable.parentFrame` (cabinet module ↔ its run). The tool converts the
   // plan-frame cursor through the capability's hooks and previews via
@@ -356,6 +368,7 @@ export function MoveRegistryNodeTool({ node }: { node: AnyNode }) {
             ? [(r[0] as number) ?? 0, rotationY, (r[2] as number) ?? 0]
             : rotationY
         })(),
+        maxElevation: supportCapRef.current,
       })
     },
     [parentFrame, frameParent, node],
@@ -404,6 +417,9 @@ export function MoveRegistryNodeTool({ node }: { node: AnyNode }) {
     rotationRef.current = originalRotationY
     altRef.current = false
     validRef.current = true
+    // No pointer surface known yet — uncapped election (the node keeps its
+    // persisted host / committed elevation until the first grid move).
+    supportCapRef.current = null
     // Re-sync the box transform to the (possibly new) node. `node` changes
     // without this component remounting whenever a positioned preset re-arms a
     // fresh clone after a drop, or the user picks a different catalog tile —
@@ -591,8 +607,21 @@ export function MoveRegistryNodeTool({ node }: { node: AnyNode }) {
     }
 
     const onGridMove = (event: GridEvent) => {
-      const rawX = event.localPosition[0]
-      const rawZ = event.localPosition[2]
+      // The pointer decides the target surface AND the cursor plan point,
+      // both resolved from the true camera ray in one place. The event's
+      // own hit can't be used directly: its plane rides at the ghost's
+      // last height, so whenever that plane sits on a different storey
+      // than the aimed-at surface the hit XZ is perspective-skewed along
+      // the ray — electing at that skewed point is what made a drag over
+      // a deck-above-a-floor hop between the two surfaces (each hop moved
+      // the plane, which re-skewed the next hit, which flipped the
+      // election back). Cap and XZ from the same ray ∩ pointed-surface
+      // test are plane-height independent, so the elected surface is a
+      // single fixed point per pointer ray.
+      const pointed = resolvePointerSupportSurface(cameraRef.current, event.position)
+      supportCapRef.current = pointed?.elevation ?? null
+      const rawX = pointed?.localPoint?.[0] ?? event.localPosition[0]
+      const rawZ = pointed?.localPoint?.[2] ?? event.localPosition[2]
       revealFreshPlacement()
 
       const resolved = resolvePlanarCursorPosition({
@@ -721,9 +750,12 @@ export function MoveRegistryNodeTool({ node }: { node: AnyNode }) {
       // the absolute world plan position here. Polygon-based kinds
       // (slab / ceiling / fence) follow a different delta contract —
       // their floor-plan move-targets handle the override themselves.
+      // The pointer surface cap rides along so FloorElevationSystem's
+      // per-frame Y agrees with this tool's preview.
       useLiveTransforms.getState().set(node.id, {
         position,
         rotation: rotationRef.current,
+        supportElevationCap: supportCapRef.current ?? undefined,
       })
       syncParentFramePreview(position)
       markMovedNodeDirty()
@@ -781,9 +813,25 @@ export function MoveRegistryNodeTool({ node }: { node: AnyNode }) {
       let committedId = node.id as AnyNodeId
 
       if (useScene.getState().nodes[node.id]) {
+        const effectiveNode = {
+          ...(node as Record<string, unknown>),
+          position,
+          rotation,
+        } as AnyNode
         const data = {
           position,
           rotation,
+          // The pointer cap makes the persisted host reproduce the capped
+          // election — a drop under a deck stores the aimed-at lower slab
+          // (or the ground), not the deck hanging above.
+          ...resolveSupportSlabPatch(
+            effectiveNode,
+            {
+              ...useScene.getState().nodes,
+              [node.id]: effectiveNode,
+            },
+            { maxElevation: supportCapRef.current },
+          ),
           ...(isNew
             ? {
                 metadata: stripPlacementMetadataFlags(node.metadata),
@@ -819,6 +867,16 @@ export function MoveRegistryNodeTool({ node }: { node: AnyNode }) {
             const liveParent = useScene.getState().nodes[frameParent.id as AnyNodeId]
             if (liveNode && liveParent) {
               parentFrame.onCommit(liveNode, liveParent, createSceneApi(useScene))
+              const committedNodes = useScene.getState().nodes
+              const committedParent = committedNodes[frameParent.id as AnyNodeId]
+              if (committedParent) {
+                useScene
+                  .getState()
+                  .updateNode(
+                    committedParent.id,
+                    resolveSupportSlabPatch(committedParent, committedNodes),
+                  )
+              }
             }
           }
           useScene.temporal.getState().pause()
@@ -834,9 +892,21 @@ export function MoveRegistryNodeTool({ node }: { node: AnyNode }) {
             metadata: {},
             position,
             rotation,
-          })
+          }) as AnyNode
+          const committedNode = def.schema.parse({
+            ...reparsed,
+            parentId: node.parentId,
+            ...resolveSupportSlabPatch(
+              { ...reparsed, parentId: node.parentId } as AnyNode,
+              {
+                ...useScene.getState().nodes,
+                [reparsed.id]: reparsed,
+              },
+              { maxElevation: supportCapRef.current },
+            ),
+          }) as AnyNode
           useScene.temporal.getState().resume()
-          useScene.getState().createNode(reparsed as AnyNode, node.parentId as AnyNodeId)
+          useScene.getState().createNode(committedNode, node.parentId as AnyNodeId)
           useScene.temporal.getState().pause()
           committed = true
         }
@@ -901,6 +971,7 @@ export function MoveRegistryNodeTool({ node }: { node: AnyNode }) {
       useLiveTransforms.getState().set(node.id, {
         position,
         rotation: rotationRef.current,
+        supportElevationCap: supportCapRef.current ?? undefined,
       })
       syncParentFramePreview(position)
       markMovedNodeDirty()

package/src/components/tools/roof/roof-tool.tsx

@@ -31,6 +31,7 @@ import { EDITOR_LAYER } from '../../../lib/constants'
 import { sfxEmitter } from '../../../lib/sfx-bus'
 import { snapWorldXZForActiveBuilding } from '../../../lib/world-grid-snap'
 import useEditor, { isGridSnapActive, isMagneticSnapActive } from '../../../store/use-editor'
+import { useFloorplanDraftPreview } from '../../../store/use-floorplan-draft-preview'
 import { CursorSphere } from '../shared/cursor-sphere'
 
 const DEFAULT_WALL_HEIGHT = 0.5
@@ -476,6 +477,9 @@ export const RoofTool: React.FC = () => {
       })
 
       if (corner1Ref.current) {
+        const draftPreview = useFloorplanDraftPreview.getState()
+        draftPreview.setRoofDraftStart([corner1Ref.current[0], corner1Ref.current[2]])
+        draftPreview.setRoofDraftEnd([gridX, gridZ])
         updateOutline(corner1Ref.current, cursorPosition)
       }
     }
@@ -497,11 +501,17 @@ export const RoofTool: React.FC = () => {
         setSelection({ selectedIds: [roofId as AnyNode['id']] })
 
         corner1Ref.current = null
+        const draftPreview = useFloorplanDraftPreview.getState()
+        draftPreview.setRoofDraftStart(null)
+        draftPreview.setRoofDraftEnd(null)
         outlineRef.current.visible = false
         alignmentCandidates = collectRoofAlignmentAnchors(useScene.getState().nodes, currentLevelId)
         clearSurfacePlanSnapFeedback()
       } else {
         corner1Ref.current = [gridX, y, gridZ]
+        const draftPreview = useFloorplanDraftPreview.getState()
+        draftPreview.setRoofDraftStart([gridX, gridZ])
+        draftPreview.setRoofDraftEnd([gridX, gridZ])
         sfxEmitter.emit('sfx:structure-build-start')
         setPreview((prev) => ({
           ...prev,
@@ -514,6 +524,9 @@ export const RoofTool: React.FC = () => {
       if (corner1Ref.current) {
         markToolCancelConsumed()
         corner1Ref.current = null
+        const draftPreview = useFloorplanDraftPreview.getState()
+        draftPreview.setRoofDraftStart(null)
+        draftPreview.setRoofDraftEnd(null)
         outlineRef.current.visible = false
         setPreview((prev) => ({ ...prev, corner1: null }))
       }
@@ -531,6 +544,9 @@ export const RoofTool: React.FC = () => {
       clearSurfacePlanSnapFeedback()
 
       corner1Ref.current = null
+      const draftPreview = useFloorplanDraftPreview.getState()
+      draftPreview.setRoofDraftStart(null)
+      draftPreview.setRoofDraftEnd(null)
     }
   }, [currentLevelId, setSelection])
 

package/src/components/tools/shared/floor-stack-preview.ts

@@ -6,6 +6,8 @@ type FloorStackPreviewArgs = {
   rotation?: unknown
   levelId?: string | null
   nodes?: Record<AnyNodeId, AnyNode>
+  /** Pointer-decided support cap — see `FloorPlacedElevationArgs.maxElevation`. */
+  maxElevation?: number | null
 }
 
 export function getFloorStackPreviewPosition({
@@ -14,6 +16,7 @@ export function getFloorStackPreviewPosition({
   rotation,
   levelId,
   nodes,
+  maxElevation,
 }: FloorStackPreviewArgs): [number, number, number] {
   return getFloorStackedPosition({
     node,
@@ -21,5 +24,6 @@ export function getFloorStackPreviewPosition({
     position,
     rotation,
     levelId,
+    maxElevation,
   })
 }

package/src/components/tools/shared/horizontal-construction-plane.ts

@@ -0,0 +1,123 @@
+import {
+  type AnyNodeId,
+  GROUND_SUPPORT_ID,
+  type GridEvent,
+  sceneRegistry,
+  terrainSupportLift,
+  useScene,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { Vector3 } from 'three'
+import { publishPlacementSurface } from '../../../lib/active-placement-surface'
+import type { PointerSupportSurface } from './pointer-support-cap'
+
+const SURFACE_UP = new Vector3(0, 1, 0)
+const worldScratch = new Vector3()
+const localScratch = new Vector3()
+const surfacePointScratch = new Vector3()
+
+export type HorizontalConstructionPlane = {
+  /** Building-local Y used by the cursor and draft preview. */
+  localY: number
+  /** World Y used by the shared placement grid. */
+  worldY: number
+  /** Level-local base elevation used when the node is committed. */
+  elevation: number | null
+  /** Support source selected at the first click. */
+  supportSlabId: string | null
+  /** Optional scene node from which this frozen plane was derived. */
+  sourceNodeId: AnyNodeId | null
+}
+
+export function resolveEventConstructionPlane(
+  event: GridEvent,
+  pointed: PointerSupportSurface | null,
+): HorizontalConstructionPlane {
+  if (pointed) {
+    return {
+      localY: pointed.localPoint?.[1] ?? event.localPosition[1],
+      worldY: pointed.worldY,
+      elevation: pointed.elevation,
+      supportSlabId: pointed.supportSlabId,
+      sourceNodeId: pointed.sourceNodeId,
+    }
+  }
+
+  let elevation: number | null = null
+  const levelId = useViewer.getState().selection.levelId
+  const levelMesh = levelId ? sceneRegistry.nodes.get(levelId as AnyNodeId) : undefined
+  if (levelMesh) {
+    localScratch.set(event.position[0], event.position[1], event.position[2])
+    levelMesh.worldToLocal(localScratch)
+    elevation = localScratch.y
+  }
+
+  return {
+    localY: event.localPosition[1],
+    worldY: event.position[1],
+    elevation,
+    supportSlabId: null,
+    sourceNodeId: null,
+  }
+}
+
+export function resolveLevelConstructionPlane(): HorizontalConstructionPlane | null {
+  const { buildingId, levelId } = useViewer.getState().selection
+  if (!levelId) return null
+
+  const levelMesh = sceneRegistry.nodes.get(levelId as AnyNodeId)
+  worldScratch.set(0, 0, 0)
+  if (levelMesh) levelMesh.localToWorld(worldScratch)
+
+  const buildingMesh = buildingId ? sceneRegistry.nodes.get(buildingId as AnyNodeId) : undefined
+  localScratch.copy(worldScratch)
+  if (buildingMesh) buildingMesh.worldToLocal(localScratch)
+
+  return {
+    localY: localScratch.y,
+    worldY: worldScratch.y,
+    elevation: 0,
+    supportSlabId: null,
+    sourceNodeId: null,
+  }
+}
+
+export function resampleTerrainConstructionPlane(
+  plane: HorizontalConstructionPlane,
+  point: readonly [number, number],
+): HorizontalConstructionPlane {
+  if (plane.supportSlabId !== GROUND_SUPPORT_ID || plane.sourceNodeId) return plane
+
+  const levelId = useViewer.getState().selection.levelId
+  if (!levelId) return plane
+  const elevation = terrainSupportLift(useScene.getState().nodes, levelId, point[0], point[1])
+  if (elevation == null) return plane
+
+  const levelMesh = sceneRegistry.nodes.get(levelId as AnyNodeId)
+  worldScratch.set(point[0], elevation, point[1])
+  if (levelMesh) levelMesh.localToWorld(worldScratch)
+
+  const buildingId = useViewer.getState().selection.buildingId
+  const buildingMesh = buildingId ? sceneRegistry.nodes.get(buildingId as AnyNodeId) : undefined
+  localScratch.copy(worldScratch)
+  if (buildingMesh) buildingMesh.worldToLocal(localScratch)
+
+  return {
+    localY: localScratch.y,
+    worldY: worldScratch.y,
+    elevation,
+    supportSlabId: GROUND_SUPPORT_ID,
+    sourceNodeId: null,
+  }
+}
+
+export function publishHorizontalConstructionPlane(
+  event: GridEvent,
+  plane: HorizontalConstructionPlane,
+): void {
+  publishPlacementSurface(
+    surfacePointScratch.set(event.position[0], plane.worldY, event.position[2]),
+    SURFACE_UP,
+    'fixed-plane',
+  )
+}

package/src/components/tools/shared/pointer-support-cap.test.ts

@@ -0,0 +1,98 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import {
+  type AnyNode,
+  type AnyNodeId,
+  sceneRegistry,
+  spatialGridManager,
+  useScene,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { BoxGeometry, Mesh, MeshBasicMaterial, PerspectiveCamera } from 'three'
+import { resolvePointerSupportSurface } from './pointer-support-cap'
+
+const LEVEL_ID = 'level_test' as AnyNodeId
+const WALL_ID = 'wall_test' as AnyNodeId
+
+describe('resolvePointerSupportSurface node tops', () => {
+  beforeEach(() => {
+    spatialGridManager.clear()
+    sceneRegistry.clear()
+    useViewer.setState({
+      selection: {
+        buildingId: null,
+        levelId: LEVEL_ID,
+        zoneId: null,
+        selectedIds: [],
+      },
+    } as never)
+    useScene.setState({
+      nodes: {
+        [LEVEL_ID]: {
+          id: LEVEL_ID,
+          type: 'level',
+          object: 'node',
+          parentId: null,
+          visible: true,
+          metadata: {},
+          children: [WALL_ID],
+          level: 0,
+        } as AnyNode,
+        [WALL_ID]: {
+          id: WALL_ID,
+          type: 'wall',
+          object: 'node',
+          parentId: LEVEL_ID,
+          visible: true,
+          metadata: {},
+          children: [],
+          assemblyLayers: [],
+          start: [-1, 0],
+          end: [1, 0],
+          frontSide: 'unknown',
+          backSide: 'unknown',
+        } as AnyNode,
+      },
+    })
+  })
+
+  afterEach(() => {
+    sceneRegistry.clear()
+  })
+
+  test('prefers the nearest upward-facing registered node surface over the ground', () => {
+    const wallMesh = new Mesh(new BoxGeometry(2, 2, 0.2), new MeshBasicMaterial())
+    wallMesh.position.y = 1
+    wallMesh.updateMatrixWorld(true)
+    sceneRegistry.nodes.set(WALL_ID, wallMesh)
+    sceneRegistry.byType.wall!.add(WALL_ID)
+
+    const camera = new PerspectiveCamera()
+    camera.position.set(0, 5, 0)
+    camera.updateMatrixWorld(true)
+
+    const support = resolvePointerSupportSurface(camera, [0, 0, 0], {
+      includeNodeTopSurfaces: true,
+    })
+
+    expect(support?.sourceNodeId).toBe(WALL_ID)
+    expect(support?.elevation).toBeCloseTo(2)
+    expect(support?.worldPoint).toEqual([0, 2, 0])
+  })
+
+  test('keeps the ground result when node-top surfaces are not requested', () => {
+    const wallMesh = new Mesh(new BoxGeometry(2, 2, 0.2), new MeshBasicMaterial())
+    wallMesh.position.y = 1
+    wallMesh.updateMatrixWorld(true)
+    sceneRegistry.nodes.set(WALL_ID, wallMesh)
+    sceneRegistry.byType.wall!.add(WALL_ID)
+
+    const camera = new PerspectiveCamera()
+    camera.position.set(0, 5, 0)
+    camera.updateMatrixWorld(true)
+
+    const support = resolvePointerSupportSurface(camera, [0, 0, 0])
+
+    expect(support?.sourceNodeId).toBeNull()
+    expect(support?.elevation).toBe(0)
+  })
+})