@pascal-app/editor 0.7.0 → 0.9.1

package/src/components/tools/window/move-window-tool.tsx

@@ -1,447 +0,0 @@
-import {
-  type AnyNodeId,
-  emitter,
-  isCurvedWall,
-  sceneRegistry,
-  spatialGridManager,
-  useLiveTransforms,
-  useScene,
-  type WallEvent,
-  WindowNode,
-} from '@pascal-app/core'
-import { useViewer } from '@pascal-app/viewer'
-import { useCallback, useEffect, useMemo, useRef } from 'react'
-import { BoxGeometry, EdgesGeometry, type Group } from 'three'
-import { LineBasicNodeMaterial } from 'three/webgpu'
-import { EDITOR_LAYER } from '../../../lib/constants'
-import { sfxEmitter } from '../../../lib/sfx-bus'
-import useEditor from '../../../store/use-editor'
-import {
-  calculateCursorRotation,
-  calculateItemRotation,
-  getSideFromNormal,
-  isValidWallSideFace,
-  snapToHalf,
-} from '../item/placement-math'
-import { clampToWall, hasWallChildOverlap, wallLocalToWorld } from './window-math'
-
-const edgeMaterial = new LineBasicNodeMaterial({
-  color: 0xef_44_44,
-  linewidth: 3,
-  depthTest: false,
-  depthWrite: false,
-})
-
-/**
- * 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.
- *
- * 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.
- */
-export const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWindowNode }) => {
-  const cursorGroupRef = useRef<Group>(null!)
-
-  const exitMoveMode = useCallback(() => {
-    useEditor.getState().setMovingNode(null)
-  }, [])
-
-  useEffect(() => {
-    useScene.temporal.getState().pause()
-
-    const meta =
-      typeof movingWindowNode.metadata === 'object' && movingWindowNode.metadata !== null
-        ? (movingWindowNode.metadata as Record<string, unknown>)
-        : {}
-    const isNew = !!meta.isNew
-
-    // Save original state (only used in move mode)
-    const original = {
-      position: [...movingWindowNode.position] as [number, number, number],
-      rotation: [...movingWindowNode.rotation] as [number, number, number],
-      side: movingWindowNode.side,
-      parentId: movingWindowNode.parentId,
-      wallId: movingWindowNode.wallId,
-      metadata: movingWindowNode.metadata,
-    }
-
-    if (!isNew) {
-      // Move mode: mark the existing window as transient so it hides while being repositioned
-      useScene.getState().updateNode(movingWindowNode.id, {
-        metadata: { ...meta, isTransient: true },
-      })
-    }
-
-    let currentWallId: string | null = movingWindowNode.parentId
-
-    const markWallDirty = (wallId: string | null) => {
-      if (wallId) useScene.getState().dirtyNodes.add(wallId as AnyNodeId)
-    }
-
-    const getLevelId = () => useViewer.getState().selection.levelId
-    const getLevelYOffset = () => {
-      const id = getLevelId()
-      return id ? (sceneRegistry.nodes.get(id as AnyNodeId)?.position.y ?? 0) : 0
-    }
-    const getSlabElevation = (wallEvent: WallEvent) =>
-      spatialGridManager.getSlabElevationForWall(
-        wallEvent.node.parentId ?? '',
-        wallEvent.node.start,
-        wallEvent.node.end,
-      )
-
-    const hideCursor = () => {
-      if (cursorGroupRef.current) cursorGroupRef.current.visible = false
-    }
-
-    const updateCursor = (
-      worldPosition: [number, number, number],
-      cursorRotationY: number,
-      valid: boolean,
-    ) => {
-      const group = cursorGroupRef.current
-      if (!group) return
-      group.visible = true
-      group.position.set(...worldPosition)
-      group.rotation.y = cursorRotationY
-      edgeMaterial.color.setHex(valid ? 0x22_c5_5e : 0xef_44_44)
-    }
-
-    const onWallEnter = (event: WallEvent) => {
-      if (!isValidWallSideFace(event.normal)) return
-      if (isCurvedWall(event.node)) {
-        hideCursor()
-        return
-      }
-      // Only interact with walls on the current level
-      if (event.node.parentId !== getLevelId()) return
-
-      const side = getSideFromNormal(event.normal)
-      const itemRotation = calculateItemRotation(event.normal)
-      const cursorRotation = calculateCursorRotation(event.normal, event.node.start, event.node.end)
-
-      const localX = snapToHalf(event.localPosition[0])
-      const localY = snapToHalf(event.localPosition[1])
-      const { clampedX, clampedY } = clampToWall(
-        event.node,
-        localX,
-        localY,
-        movingWindowNode.width,
-        movingWindowNode.height,
-      )
-
-      const prevWallId = currentWallId
-      currentWallId = event.node.id
-
-      useScene.getState().updateNode(movingWindowNode.id, {
-        position: [clampedX, clampedY, 0],
-        rotation: [0, itemRotation, 0],
-        side,
-        parentId: event.node.id,
-        wallId: event.node.id,
-      })
-      useLiveTransforms.getState().set(movingWindowNode.id, {
-        position: [clampedX, clampedY, 0],
-        rotation: itemRotation,
-      })
-
-      if (prevWallId && prevWallId !== event.node.id) markWallDirty(prevWallId)
-      markWallDirty(event.node.id)
-
-      const valid = !hasWallChildOverlap(
-        event.node.id,
-        clampedX,
-        clampedY,
-        movingWindowNode.width,
-        movingWindowNode.height,
-        movingWindowNode.id,
-      )
-
-      updateCursor(
-        wallLocalToWorld(
-          event.node,
-          clampedX,
-          clampedY,
-          getLevelYOffset(),
-          getSlabElevation(event),
-        ),
-        cursorRotation,
-        valid,
-      )
-      event.stopPropagation()
-    }
-
-    const onWallMove = (event: WallEvent) => {
-      if (!isValidWallSideFace(event.normal)) return
-      if (isCurvedWall(event.node)) {
-        hideCursor()
-        return
-      }
-      // Only interact with walls on the current level
-      if (event.node.parentId !== getLevelId()) return
-
-      const side = getSideFromNormal(event.normal)
-      const itemRotation = calculateItemRotation(event.normal)
-      const cursorRotation = calculateCursorRotation(event.normal, event.node.start, event.node.end)
-
-      const localX = snapToHalf(event.localPosition[0])
-      const localY = snapToHalf(event.localPosition[1])
-      const { clampedX, clampedY } = clampToWall(
-        event.node,
-        localX,
-        localY,
-        movingWindowNode.width,
-        movingWindowNode.height,
-      )
-
-      if (currentWallId !== event.node.id) {
-        // Wall changed mid-move: must updateNode to reparent
-        useScene.getState().updateNode(movingWindowNode.id, {
-          position: [clampedX, clampedY, 0],
-          rotation: [0, itemRotation, 0],
-          side,
-          parentId: event.node.id,
-          wallId: event.node.id,
-        })
-        markWallDirty(currentWallId)
-        currentWallId = event.node.id
-      } else {
-        // Same wall: update Three.js mesh directly to avoid store churn
-        // collectCutoutBrushes reads cutoutMesh.matrixWorld, not scene store positions
-        const windowMesh = sceneRegistry.nodes.get(movingWindowNode.id as AnyNodeId)
-        if (windowMesh) {
-          windowMesh.position.set(clampedX, clampedY, 0)
-          windowMesh.rotation.set(0, itemRotation, 0)
-          windowMesh.updateMatrixWorld(true)
-        }
-      }
-      useLiveTransforms.getState().set(movingWindowNode.id, {
-        position: [clampedX, clampedY, 0],
-        rotation: itemRotation,
-      })
-      markWallDirty(event.node.id)
-
-      const valid = !hasWallChildOverlap(
-        event.node.id,
-        clampedX,
-        clampedY,
-        movingWindowNode.width,
-        movingWindowNode.height,
-        movingWindowNode.id,
-      )
-
-      updateCursor(
-        wallLocalToWorld(
-          event.node,
-          clampedX,
-          clampedY,
-          getLevelYOffset(),
-          getSlabElevation(event),
-        ),
-        cursorRotation,
-        valid,
-      )
-      event.stopPropagation()
-    }
-
-    const onWallClick = (event: WallEvent) => {
-      if (!isValidWallSideFace(event.normal)) return
-      if (isCurvedWall(event.node)) return
-      // Only interact with walls on the current level
-      if (event.node.parentId !== getLevelId()) return
-
-      const side = getSideFromNormal(event.normal)
-      const itemRotation = calculateItemRotation(event.normal)
-
-      const localX = snapToHalf(event.localPosition[0])
-      const localY = snapToHalf(event.localPosition[1])
-      const { clampedX, clampedY } = clampToWall(
-        event.node,
-        localX,
-        localY,
-        movingWindowNode.width,
-        movingWindowNode.height,
-      )
-
-      const valid = !hasWallChildOverlap(
-        event.node.id,
-        clampedX,
-        clampedY,
-        movingWindowNode.width,
-        movingWindowNode.height,
-        movingWindowNode.id,
-      )
-      if (!valid) return
-
-      let placedId: string
-
-      if (isNew) {
-        // Duplicate mode: delete transient + resume + createNode
-        // Undo will remove the newly created node entirely
-        useScene.getState().deleteNode(movingWindowNode.id)
-        useScene.temporal.getState().resume()
-
-        const node = WindowNode.parse({
-          position: [clampedX, clampedY, 0],
-          rotation: [0, itemRotation, 0],
-          side,
-          wallId: event.node.id,
-          parentId: event.node.id,
-          width: movingWindowNode.width,
-          height: movingWindowNode.height,
-          windowType: movingWindowNode.windowType,
-          operationState: movingWindowNode.operationState,
-          awningDirection: movingWindowNode.awningDirection,
-          casementStyle: movingWindowNode.casementStyle,
-          hingesSide: movingWindowNode.hingesSide,
-          frameThickness: movingWindowNode.frameThickness,
-          frameDepth: movingWindowNode.frameDepth,
-          columnRatios: movingWindowNode.columnRatios,
-          rowRatios: movingWindowNode.rowRatios,
-          columnDividerThickness: movingWindowNode.columnDividerThickness,
-          rowDividerThickness: movingWindowNode.rowDividerThickness,
-          sill: movingWindowNode.sill,
-          sillDepth: movingWindowNode.sillDepth,
-          sillThickness: movingWindowNode.sillThickness,
-        })
-        useScene.getState().createNode(node, event.node.id as AnyNodeId)
-        placedId = node.id
-      } else {
-        // Move mode: restore original (clean baseline) + resume + updateNode
-        // Undo will revert to the original position
-        useScene.getState().updateNode(movingWindowNode.id, {
-          position: original.position,
-          rotation: original.rotation,
-          side: original.side,
-          parentId: original.parentId,
-          wallId: original.wallId,
-          metadata: original.metadata,
-        })
-        useScene.temporal.getState().resume()
-
-        useScene.getState().updateNode(movingWindowNode.id, {
-          position: [clampedX, clampedY, 0],
-          rotation: [0, itemRotation, 0],
-          side,
-          parentId: event.node.id,
-          wallId: event.node.id,
-          metadata: {},
-        })
-
-        if (original.parentId && original.parentId !== event.node.id) {
-          markWallDirty(original.parentId)
-        }
-        placedId = movingWindowNode.id
-      }
-
-      markWallDirty(event.node.id)
-      useLiveTransforms.getState().clear(movingWindowNode.id)
-      useScene.temporal.getState().pause()
-
-      sfxEmitter.emit('sfx:item-place')
-      hideCursor()
-      useViewer.getState().setSelection({ selectedIds: [placedId] })
-      exitMoveMode()
-      event.stopPropagation()
-    }
-
-    const onWallLeave = () => {
-      hideCursor()
-      useLiveTransforms.getState().clear(movingWindowNode.id)
-      if (isNew) return // No original to restore for duplicates
-      // Move mode: restore to original position while off-wall
-      if (currentWallId && currentWallId !== original.parentId) {
-        markWallDirty(currentWallId)
-      }
-      currentWallId = original.parentId
-      useScene.getState().updateNode(movingWindowNode.id, {
-        position: original.position,
-        rotation: original.rotation,
-        side: original.side,
-        parentId: original.parentId,
-        wallId: original.wallId,
-      })
-      if (original.parentId) markWallDirty(original.parentId)
-    }
-
-    const onCancel = () => {
-      useLiveTransforms.getState().clear(movingWindowNode.id)
-      if (isNew) {
-        useScene.getState().deleteNode(movingWindowNode.id)
-        if (currentWallId) markWallDirty(currentWallId)
-      } else {
-        useScene.getState().updateNode(movingWindowNode.id, {
-          position: original.position,
-          rotation: original.rotation,
-          side: original.side,
-          parentId: original.parentId,
-          wallId: original.wallId,
-          metadata: original.metadata,
-        })
-        if (original.parentId) markWallDirty(original.parentId)
-      }
-      useScene.temporal.getState().resume()
-      hideCursor()
-      exitMoveMode()
-    }
-
-    emitter.on('wall:enter', onWallEnter)
-    emitter.on('wall:move', onWallMove)
-    emitter.on('wall:click', onWallClick)
-    emitter.on('wall:leave', onWallLeave)
-    emitter.on('tool:cancel', onCancel)
-
-    return () => {
-      // Safety cleanup: if still transient on unmount (e.g. phase switch mid-move)
-      const current = useScene.getState().nodes[movingWindowNode.id as AnyNodeId] as
-        | WindowNode
-        | undefined
-      const currentMeta = current?.metadata as Record<string, unknown> | undefined
-      if (currentMeta?.isTransient) {
-        if (isNew) {
-          useScene.getState().deleteNode(movingWindowNode.id)
-          if (currentWallId) markWallDirty(currentWallId)
-        } else {
-          useScene.getState().updateNode(movingWindowNode.id, {
-            position: original.position,
-            rotation: original.rotation,
-            side: original.side,
-            parentId: original.parentId,
-            wallId: original.wallId,
-            metadata: original.metadata,
-          })
-          if (original.parentId) markWallDirty(original.parentId)
-        }
-      }
-      useLiveTransforms.getState().clear(movingWindowNode.id)
-      useScene.temporal.getState().resume()
-      emitter.off('wall:enter', onWallEnter)
-      emitter.off('wall:move', onWallMove)
-      emitter.off('wall:click', onWallClick)
-      emitter.off('wall:leave', onWallLeave)
-      emitter.off('tool:cancel', onCancel)
-    }
-  }, [movingWindowNode, exitMoveMode])
-
-  const edgesGeo = useMemo(() => {
-    const boxGeo = new BoxGeometry(
-      movingWindowNode.width,
-      movingWindowNode.height,
-      movingWindowNode.frameDepth ?? 0.07,
-    )
-    const geo = new EdgesGeometry(boxGeo)
-    boxGeo.dispose()
-    return geo
-  }, [movingWindowNode])
-
-  return (
-    <group ref={cursorGroupRef} visible={false}>
-      <lineSegments geometry={edgesGeo} layers={EDITOR_LAYER} material={edgeMaterial} />
-    </group>
-  )
-}

package/src/components/tools/window/window-math.ts

@@ -1,117 +0,0 @@
-import {
-  type AnyNodeId,
-  type DoorNode,
-  getScaledDimensions,
-  type ItemNode,
-  useScene,
-  type WallNode,
-  type WindowNode,
-} from '@pascal-app/core'
-
-/**
- * Converts wall-local (X along wall, Y = height above wall base) to world XYZ.
- * Wall XZ uses level-local coordinates (levels only offset in Y, not XZ).
- * Pass levelYOffset (the level group's current world Y) and slabElevation (the
- * wall mesh's Y within the level group) so the cursor lands at the correct world
- * height — matching how WallSystem positions the wall mesh at slabElevation.
- */
-export function wallLocalToWorld(
-  wallNode: WallNode,
-  localX: number,
-  localY: number,
-  levelYOffset = 0,
-  slabElevation = 0,
-): [number, number, number] {
-  const wallAngle = Math.atan2(
-    wallNode.end[1] - wallNode.start[1],
-    wallNode.end[0] - wallNode.start[0],
-  )
-  return [
-    wallNode.start[0] + localX * Math.cos(wallAngle),
-    slabElevation + localY + levelYOffset,
-    wallNode.start[1] + localX * Math.sin(wallAngle),
-  ]
-}
-
-/**
- * Clamps window center position so it stays fully within wall bounds.
- */
-export function clampToWall(
-  wallNode: WallNode,
-  localX: number,
-  localY: number,
-  width: number,
-  height: number,
-): { clampedX: number; clampedY: number } {
-  const dx = wallNode.end[0] - wallNode.start[0]
-  const dz = wallNode.end[1] - wallNode.start[1]
-  const wallLength = Math.sqrt(dx * dx + dz * dz)
-  const wallHeight = wallNode.height ?? 2.5
-
-  const clampedX = Math.max(width / 2, Math.min(wallLength - width / 2, localX))
-  const clampedY = Math.max(height / 2, Math.min(wallHeight - height / 2, localY))
-  return { clampedX, clampedY }
-}
-
-/**
- * Directly checks the wall's children for bounding-box overlap with a proposed window.
- * Works for both `item` type (position[1] = bottom) and `window` type (position[1] = center).
- * The spatial grid only tracks `item` nodes, so windows must be checked this way.
- * Reads the wall's latest children from the store (not the event node) to avoid stale data.
- */
-export function hasWallChildOverlap(
-  wallId: string,
-  clampedX: number,
-  clampedY: number,
-  width: number,
-  height: number,
-  ignoreId?: string,
-): boolean {
-  const nodes = useScene.getState().nodes
-  const wallNode = nodes[wallId as AnyNodeId] as WallNode | undefined
-  if (!wallNode) return true // Block if wall not found
-  const halfW = width / 2
-  const halfH = height / 2
-  const newBottom = clampedY - halfH
-  const newTop = clampedY + halfH
-  const newLeft = clampedX - halfW
-  const newRight = clampedX + halfW
-
-  for (const childId of Array.isArray(wallNode.children) ? wallNode.children : []) {
-    if (childId === ignoreId) continue
-    const child = nodes[childId as AnyNodeId]
-    if (!child) continue
-
-    let childLeft: number, childRight: number, childBottom: number, childTop: number
-
-    if (child.type === 'item') {
-      const item = child as ItemNode
-      if (item.asset.attachTo !== 'wall' && item.asset.attachTo !== 'wall-side') continue
-      const [w, h] = getScaledDimensions(item)
-      childLeft = item.position[0] - w / 2
-      childRight = item.position[0] + w / 2
-      childBottom = item.position[1] // items store bottom Y
-      childTop = item.position[1] + h
-    } else if (child.type === 'window') {
-      const win = child as WindowNode
-      childLeft = win.position[0] - win.width / 2
-      childRight = win.position[0] + win.width / 2
-      childBottom = win.position[1] - win.height / 2 // windows store center Y
-      childTop = win.position[1] + win.height / 2
-    } else if (child.type === 'door') {
-      const door = child as DoorNode
-      childLeft = door.position[0] - door.width / 2
-      childRight = door.position[0] + door.width / 2
-      childBottom = door.position[1] - door.height / 2 // doors store center Y
-      childTop = door.position[1] + door.height / 2
-    } else {
-      continue
-    }
-
-    const xOverlap = newLeft < childRight && newRight > childLeft
-    const yOverlap = newBottom < childTop && newTop > childBottom
-    if (xOverlap && yOverlap) return true
-  }
-
-  return false
-}