@pascal-app/editor 1.0.0-beta.5 → 1.0.1

package/src/hooks/use-grid-events.ts

@@ -3,14 +3,26 @@ import {
   type EventSuffix,
   emitter,
   type GridEvent,
+  nodeRegistry,
   sceneRegistry,
+  useScene,
 } from '@pascal-app/core'
-import { useViewer } from '@pascal-app/viewer'
+import { setSurfaceRaycastLayers, timeSpan, useViewer } from '@pascal-app/viewer'
 import { useThree } from '@react-three/fiber'
 import { useEffect, useRef } from 'react'
-import { Plane, Raycaster, Vector2, Vector3 } from 'three'
+import { Matrix3, type Object3D, Plane, Raycaster, Vector2, Vector3 } from 'three'
 import { getPlacementSurface } from '../lib/active-placement-surface'
+import { raycastCeilingUnderside } from '../lib/ceiling-surface-raycast'
 import { resolveTerrainGroundHit } from '../lib/ground-surface'
+import {
+  type DraftingSurfaceExtension,
+  registeredDraftingConfig,
+  registeredDraftingSurface,
+} from '../lib/interaction/registered-drafting'
+import useInteractionScope from '../store/use-interaction-scope'
+
+// Keep tool previews tracking camera navigation at 10 Hz without querying every move.
+const CAMERA_DRAG_MOVE_INTERVAL_MS = 100
 
 /**
  * Custom grid events hook that uses manual raycasting instead of mesh events.
@@ -18,11 +30,28 @@ import { resolveTerrainGroundHit } from '../lib/ground-surface'
  */
 export function useGridEvents(gridY: number) {
   const { camera, gl } = useThree()
+  const interactionScope = useInteractionScope((state) => state.scope)
+  const semanticSurfaceQueryRef = useRef(false)
+  semanticSurfaceQueryRef.current =
+    interactionScope.kind === 'placing' ||
+    interactionScope.kind === 'moving' ||
+    registeredDraftingConfig(interactionScope)?.surfaceQuery === true
   const raycaster = useRef(new Raycaster())
   const pointer = useRef(new Vector2())
   const groundPlane = useRef(new Plane(new Vector3(0, 1, 0), 0))
   const intersectionPoint = useRef(new Vector3())
 
+  type GridIntersection = {
+    point: Vector3
+    surface?: {
+      point: Vector3
+      object: Object3D
+      hostId: AnyNodeId
+      descriptor: DraftingSurfaceExtension
+      worldNormal?: Vector3
+    }
+  }
+
   // Update ground plane when grid Y changes
   useEffect(() => {
     groundPlane.current.constant = -gridY
@@ -30,8 +59,64 @@ export function useGridEvents(gridY: number) {
 
   useEffect(() => {
     const canvas = gl.domElement
+    setSurfaceRaycastLayers(raycaster.current.layers)
+
+    const getSurfaceIntersection = (): GridIntersection | null => {
+      let closest: GridIntersection | null = null
+      let closestDistance = Number.POSITIVE_INFINITY
+
+      for (const [type, definition] of nodeRegistry.entries()) {
+        const descriptor = registeredDraftingSurface(definition)
+        if (!descriptor) continue
+        for (const id of sceneRegistry.byType[type] ?? []) {
+          const root = sceneRegistry.nodes.get(id)
+          if (!root) continue
+          const scope = useInteractionScope.getState().scope
+          const surfaceDraft = registeredDraftingConfig(scope)?.surfaceQuery === true
+          if (surfaceDraft && useScene.getState().nodes[id as AnyNodeId]?.visible === false)
+            continue
+          if (surfaceDraft && !root.visible) continue
+          const intersections =
+            surfaceDraft && descriptor.raycast === 'underside'
+              ? raycastCeilingUnderside(raycaster.current, root)
+              : raycaster.current.intersectObject(root, true)
+          const hit = intersections.find((candidate) => {
+            if (!surfaceDraft) return true
+            if (useScene.getState().nodes[id as AnyNodeId]?.visible === false) return false
+            let object: Object3D | null = candidate.object
+            while (object) {
+              if (!object.visible || object.userData.wallHidden === true) return false
+              object = object.parent
+            }
+            return true
+          })
+          if (!hit || hit.distance >= closestDistance) continue
+          closestDistance = hit.distance
+          const worldNormal = hit.face
+            ? hit.face.normal
+                .clone()
+                .applyNormalMatrix(new Matrix3().getNormalMatrix(hit.object.matrixWorld))
+                .normalize()
+            : undefined
+          if (surfaceDraft && worldNormal && worldNormal.dot(raycaster.current.ray.direction) > 0)
+            worldNormal.negate()
+          closest = {
+            point: hit.point.clone(),
+            surface: {
+              point: hit.point.clone(),
+              object: hit.object,
+              hostId: id as AnyNodeId,
+              descriptor,
+              worldNormal,
+            },
+          }
+        }
+      }
+
+      return closest
+    }
 
-    const getIntersection = (nativeEvent: MouseEvent | PointerEvent): Vector3 | null => {
+    const getIntersection = (nativeEvent: MouseEvent | PointerEvent): GridIntersection | null => {
       // Convert mouse position to normalized device coordinates (-1 to +1)
       const rect = canvas.getBoundingClientRect()
       pointer.current.x = ((nativeEvent.clientX - rect.left) / rect.width) * 2 - 1
@@ -40,6 +125,33 @@ export function useGridEvents(gridY: number) {
       // Update raycaster
       raycaster.current.setFromCamera(pointer.current, camera)
 
+      // R3F node events can be stopped by another mesh, so this canvas-level
+      // raycast is the reliable architectural-surface source for placement and
+      // drawing tools. Keep it separate from the ordinary grid point so tools
+      // that intentionally place on the floor retain their existing behavior.
+      // Architectural meshes are expensive to raycast and are meaningful only
+      // to an active placement/drafting interaction. Floor tools retain the
+      // ordinary terrain/grid intersection without scanning every wall.
+      const surfaceHit = semanticSurfaceQueryRef.current ? getSurfaceIntersection() : null
+
+      // A semantic architectural hit is the authoritative cursor position.
+      // Do not replace it with the terrain/grid intersection below: that would
+      // make a wall hit carry wall metadata while still placing at the ground
+      // floor, especially in perspective views.
+      if (surfaceHit) return surfaceHit
+
+      const scope = useInteractionScope.getState().scope
+      const surfaceDraft = registeredDraftingConfig(scope)?.surfaceQuery === true
+      const workingSurface = getPlacementSurface()
+      if (surfaceDraft && workingSurface) {
+        const plane = new Plane().setFromNormalAndCoplanarPoint(
+          workingSurface.normal,
+          workingSurface.point,
+        )
+        const projected = raycaster.current.ray.intersectPlane(plane, intersectionPoint.current)
+        return { point: (projected ?? workingSurface.point).clone() }
+      }
+
       // Sculpted ground wins over the plane, but only while the plane IS the
       // ground (see `isSiteGroundPlane`): a plane riding a storey base or a slab
       // top is a real flat surface and must stay planar. The march is what removes
@@ -60,14 +172,18 @@ export function useGridEvents(gridY: number) {
             [direction.x, direction.y, direction.z],
             -groundPlane.current.constant,
           )
-      if (hit) return intersectionPoint.current.set(hit.x, hit.y, hit.z).clone()
+      if (hit) {
+        return {
+          point: intersectionPoint.current.set(hit.x, hit.y, hit.z).clone(),
+        }
+      }
 
       // Intersect with ground plane
       if (raycaster.current.ray.intersectPlane(groundPlane.current, intersectionPoint.current)) {
-        return intersectionPoint.current.clone()
+        return { point: intersectionPoint.current.clone() }
       }
 
-      return null
+      return surfaceHit
     }
 
     const emit = (suffix: EventSuffix, nativeEvent: MouseEvent | PointerEvent) => {
@@ -75,14 +191,69 @@ export function useGridEvents(gridY: number) {
       if (!point) return
 
       // Convert world-space point to building-local for tools that live inside a building.
-      const buildingId = useViewer.getState().selection.buildingId
+      const scope = useInteractionScope.getState().scope
+      const surfaceDraft = registeredDraftingConfig(scope)?.surfaceQuery === true
+      const buildingId = surfaceDraft
+        ? useViewer.getState().selection.levelId
+        : useViewer.getState().selection.buildingId
       const buildingMesh = buildingId ? sceneRegistry.nodes.get(buildingId as AnyNodeId) : null
-      const localPoint = buildingMesh ? buildingMesh.worldToLocal(point.clone()) : point
+      const localPoint = buildingMesh ? buildingMesh.worldToLocal(point.point.clone()) : point.point
+      const surfaceLocalPoint = point.surface
+        ? buildingMesh
+          ? buildingMesh.worldToLocal(point.surface.point.clone())
+          : point.surface.point.clone()
+        : undefined
+      const localNormal = point.surface?.worldNormal
+        ? buildingMesh
+          ? buildingMesh
+              .worldToLocal(point.surface.point.clone().add(point.surface.worldNormal))
+              .sub(surfaceLocalPoint ?? localPoint)
+              .normalize()
+          : point.surface.worldNormal
+        : undefined
+      const surfaceNode = point.surface
+        ? useScene.getState().nodes[point.surface.hostId]
+        : undefined
+      const classifiedFace =
+        point.surface && localNormal
+          ? point.surface.descriptor.classifyFace?.(surfaceNode, [
+              localNormal.x,
+              localNormal.y,
+              localNormal.z,
+            ])
+          : null
+      const { origin, direction } = raycaster.current.ray
+      const localRayOrigin = buildingMesh
+        ? buildingMesh.worldToLocal(origin.clone())
+        : origin.clone()
+      const localRayDirection = buildingMesh
+        ? buildingMesh.worldToLocal(origin.clone().add(direction)).sub(localRayOrigin).normalize()
+        : direction.clone()
 
       const eventKey = `grid:${suffix}` as `grid:${EventSuffix}`
       const payload: GridEvent = {
-        position: [point.x, point.y, point.z],
+        localFrameId: buildingId ?? undefined,
+        position: [point.point.x, point.point.y, point.point.z],
         localPosition: [localPoint.x, localPoint.y, localPoint.z],
+        localRay: {
+          origin: [localRayOrigin.x, localRayOrigin.y, localRayOrigin.z],
+          direction: [localRayDirection.x, localRayDirection.y, localRayDirection.z],
+        },
+        surfaceLocalPosition: surfaceLocalPoint
+          ? [surfaceLocalPoint.x, surfaceLocalPoint.y, surfaceLocalPoint.z]
+          : undefined,
+        surfaceNormal: localNormal ? [localNormal.x, localNormal.y, localNormal.z] : undefined,
+        surfaceObject: point.surface?.object,
+        surfaceHit:
+          semanticSurfaceQueryRef.current && point.surface
+            ? {
+                kind: point.surface.descriptor.kind,
+                hostId: point.surface.hostId,
+                face: classifiedFace?.face ?? 'unknown',
+                levelId: useViewer.getState().selection.levelId ?? undefined,
+                side: classifiedFace?.side,
+              }
+            : undefined,
         nativeEvent: nativeEvent as any, // Type compatibility with ThreeEvent
       }
 
@@ -107,9 +278,17 @@ export function useGridEvents(gridY: number) {
       emit('click', e)
     }
 
+    let lastCameraDragMove = Number.NEGATIVE_INFINITY
     const handlePointerMove = (e: PointerEvent) => {
-      // Emit move even if camera is dragging, so tools like PolygonEditor still work
-      emit('move', e)
+      // Moves keep tool cursor snapshots current, including wheel zoom during a tool gesture.
+      if (useViewer.getState().cameraDragging) {
+        const now = performance.now()
+        if (now - lastCameraDragMove < CAMERA_DRAG_MOVE_INTERVAL_MS) return
+        lastCameraDragMove = now
+      } else {
+        lastCameraDragMove = Number.NEGATIVE_INFINITY
+      }
+      timeSpan('pointer', () => emit('move', e))
     }
 
     const handleDoubleClick = (e: MouseEvent) => {

package/src/hooks/use-keyboard.test.ts

@@ -0,0 +1,244 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import {
+  type AnyNode,
+  type AnyNodeId,
+  BlockNode,
+  clearSceneHistory,
+  DuctFittingNode,
+  DuctSegmentNode,
+  emitter,
+  nodeRegistry,
+  PipeFittingNode,
+  PipeSegmentNode,
+  useScene,
+} from '@pascal-app/core'
+import { runRedo, runUndo } from '../lib/history'
+import { meshEditScope } from '../lib/interaction/scope'
+import useEditor from '../store/use-editor'
+import useInteractionScope from '../store/use-interaction-scope'
+import {
+  blocksSnappingShortcut,
+  canCycleSnappingModeShortcut,
+  canRunGlobalRotationShortcut,
+  isToolOwnedCanopyForm,
+  isToolOwnedRotation,
+  markToolCancelConsumed,
+  runHistoryShortcut,
+} from './use-keyboard'
+
+type RafFn = (callback: (time: number) => void) => number
+;(globalThis as unknown as { requestAnimationFrame?: RafFn }).requestAnimationFrame ??= (
+  callback,
+) => {
+  callback(0)
+  return 0
+}
+;(globalThis as unknown as { cancelAnimationFrame?: (id: number) => void }).cancelAnimationFrame ??=
+  () => {}
+
+const NODE_ID = 'block_history' as AnyNodeId
+
+describe('snapping shortcuts while entering a run length', () => {
+  test('allows snap mode and spacing shortcuts in the duct and pipe length field', () => {
+    expect(
+      blocksSnappingShortcut({
+        tagName: 'INPUT',
+        isContentEditable: false,
+        hasAttribute: (name) => name === 'data-run-length-input',
+      }),
+    ).toBe(false)
+  })
+
+  test('continues to protect ordinary text fields and editable content', () => {
+    for (const tagName of ['INPUT', 'TEXTAREA', 'DIV']) {
+      expect(
+        blocksSnappingShortcut({
+          tagName,
+          isContentEditable: tagName === 'DIV',
+          hasAttribute: () => false,
+        }),
+      ).toBe(true)
+    }
+    expect(blocksSnappingShortcut(null)).toBe(false)
+  })
+})
+
+beforeEach(() => {
+  const node = BlockNode.parse({ id: NODE_ID, position: [0, 0, 0] })
+  useScene.setState({
+    nodes: { [NODE_ID]: node },
+    rootNodeIds: [NODE_ID],
+    dirtyNodes: new Set<AnyNodeId>(),
+    collections: {},
+    materials: {},
+    readOnly: false,
+  } as never)
+  clearSceneHistory()
+  useScene.getState().updateNode(NODE_ID, { position: [1, 2, 3] } as Partial<AnyNode>)
+})
+
+afterEach(() => {
+  useInteractionScope.getState().end()
+  useEditor.getState().armToolMode({ mode: 'select' })
+  useEditor.setState({ selectedItem: null })
+  clearSceneHistory()
+})
+
+describe('rotation shortcut ownership', () => {
+  test('does not reserve R and T for an armed item tool without a placement item', () => {
+    useEditor.getState().armToolMode({ mode: 'build', tool: 'item' })
+
+    expect(isToolOwnedRotation()).toBe(false)
+  })
+
+  test('leaves R and T to the active item placement tool', () => {
+    useEditor.getState().setSelectedItem({
+      asset: { id: 'asset:test' },
+    } as never)
+    useEditor.getState().armToolMode({ mode: 'build', tool: 'item' })
+
+    expect(isToolOwnedRotation()).toBe(true)
+  })
+
+  test('leaves R and T to the active lean-to placement tool', () => {
+    useEditor.getState().armToolMode({ mode: 'build', tool: 'lean-to-extension' })
+
+    expect(isToolOwnedRotation()).toBe(true)
+  })
+
+  test('leaves R and T to a moving lean-to extension', () => {
+    const leanTo = { id: 'lean_to_moving', type: 'lean-to-extension' } as unknown as AnyNode
+    useInteractionScope.getState().begin({
+      kind: 'moving',
+      node: leanTo,
+      nodeId: leanTo.id,
+      nodeType: leanTo.type,
+      view: '3d',
+    })
+
+    expect(isToolOwnedRotation()).toBe(true)
+  })
+
+  test('leaves F to the active lean-to placement tool', () => {
+    useEditor.getState().armToolMode({ mode: 'build', tool: 'lean-to-extension' })
+
+    expect(isToolOwnedCanopyForm()).toBe(true)
+    useEditor.getState().armToolMode({ mode: 'build', tool: 'wall' })
+    expect(isToolOwnedCanopyForm()).toBe(false)
+  })
+})
+
+describe('history shortcuts during block editing', () => {
+  test('reserves global rotation shortcuts for the active mesh editor', () => {
+    expect(canRunGlobalRotationShortcut()).toBe(true)
+    useInteractionScope.getState().begin(meshEditScope(NODE_ID))
+    expect(canRunGlobalRotationShortcut()).toBe(false)
+  })
+
+  test('keeps Shift available to cycle snapping while a mesh operation is active', () => {
+    useInteractionScope.getState().begin(meshEditScope(NODE_ID))
+    expect(canCycleSnappingModeShortcut(true)).toBe(true)
+
+    useInteractionScope.getState().begin(meshEditScope(NODE_ID, 'operating', 'translate'))
+    expect(canCycleSnappingModeShortcut(true)).toBe(true)
+  })
+
+  test('undoes and redoes mesh changes without leaving component selection mode', () => {
+    useInteractionScope.getState().begin(meshEditScope(NODE_ID))
+
+    expect(runHistoryShortcut('undo')).toBe(true)
+    expect((useScene.getState().nodes[NODE_ID] as BlockNode).position).toEqual([0, 0, 0])
+    expect(useInteractionScope.getState().scope).toEqual({
+      kind: 'mesh-editing',
+      nodeId: NODE_ID,
+      phase: 'selecting',
+    })
+
+    expect(runHistoryShortcut('redo')).toBe(true)
+    expect((useScene.getState().nodes[NODE_ID] as BlockNode).position).toEqual([1, 2, 3])
+    expect(useInteractionScope.getState().scope).toEqual({
+      kind: 'mesh-editing',
+      nodeId: NODE_ID,
+      phase: 'selecting',
+    })
+  })
+})
+
+describe('history while drawing distribution runs', () => {
+  let restoreRegistry = () => {}
+
+  beforeEach(() => {
+    restoreRegistry = nodeRegistry._snapshot()
+    nodeRegistry._reset()
+    for (const kind of ['duct-segment', 'pipe-segment']) {
+      nodeRegistry._register({
+        kind,
+        schemaVersion: 1,
+        drafting: { cancelOnHistoryJump: true },
+      } as never)
+    }
+  })
+
+  afterEach(() => {
+    restoreRegistry()
+    restoreRegistry = () => {}
+  })
+
+  for (const [kind, schema, fittingSchema] of [
+    ['duct', DuctSegmentNode, DuctFittingNode],
+    ['pipe', PipeSegmentNode, PipeFittingNode],
+  ] as const) {
+    test(`undoes and redoes individual ${kind} commits while drafting`, () => {
+      clearSceneHistory()
+      const first = schema.parse({
+        path: [
+          [0, 1, 0],
+          [1, 1, 0],
+        ],
+      })
+      const second = schema.parse({
+        path: [
+          [1, 1, 0],
+          [2, 1, 0],
+        ],
+      })
+      useScene.getState().applyNodeChanges({ create: [{ node: first }] })
+      const fitting = fittingSchema.parse({ position: [1, 1, 0] })
+      const trimmedPath: [number, number, number][] = [
+        [0, 1, 0],
+        [0.8, 1, 0],
+      ]
+      useScene.getState().applyNodeChanges({
+        create: [{ node: second }, { node: fitting }],
+        update: [{ id: first.id, data: { path: trimmedPath } }],
+      })
+      expect(useScene.temporal.getState().pastStates).toHaveLength(2)
+      useInteractionScope.getState().begin({ kind: 'drafting', tool: first.type })
+      let cancellations = 0
+      const cancel = () => {
+        cancellations += 1
+        markToolCancelConsumed()
+      }
+      emitter.on('tool:cancel', cancel)
+      try {
+        expect(runHistoryShortcut('undo')).toBe(true)
+        expect(useScene.getState().nodes[second.id]).toBeUndefined()
+        expect(useScene.getState().nodes[fitting.id]).toBeUndefined()
+        expect(useScene.getState().nodes[first.id]).toMatchObject({ path: first.path })
+        expect(runUndo().kind).toBe('applied')
+        expect(useScene.getState().nodes[first.id]).toBeUndefined()
+        expect(runRedo().kind).toBe('applied')
+        expect(useScene.getState().nodes[first.id]).toBeDefined()
+        expect(useScene.getState().nodes[second.id]).toBeUndefined()
+        expect(runHistoryShortcut('redo')).toBe(true)
+        expect(useScene.getState().nodes[second.id]).toBeDefined()
+        expect(useScene.getState().nodes[fitting.id]).toBeDefined()
+        expect(useScene.getState().nodes[first.id]).toMatchObject({ path: trimmedPath })
+        expect(cancellations).toBe(4)
+        expect(useInteractionScope.getState().scope).toEqual({ kind: 'drafting', tool: first.type })
+      } finally {
+        emitter.off('tool:cancel', cancel)
+      }
+    })
+  }
+})