@pascal-app/editor 0.4.0

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

@@ -0,0 +1,90 @@
+import type {
+  DoorNode,
+  ItemNode,
+  RoofNode,
+  RoofSegmentNode,
+  StairNode,
+  StairSegmentNode,
+  WindowNode,
+} from '@pascal-app/core'
+import { Vector3 } from 'three'
+import { sfxEmitter } from '../../../lib/sfx-bus'
+import useEditor from '../../../store/use-editor'
+import { MoveDoorTool } from '../door/move-door-tool'
+import { MoveRoofTool } from '../roof/move-roof-tool'
+import { MoveWindowTool } from '../window/move-window-tool'
+import type { PlacementState } from './placement-types'
+import { useDraftNode } from './use-draft-node'
+import { usePlacementCoordinator } from './use-placement-coordinator'
+
+function getInitialState(node: {
+  asset: { attachTo?: string }
+  parentId: string | null
+}): PlacementState {
+  const attachTo = node.asset.attachTo
+  if (attachTo === 'wall' || attachTo === 'wall-side') {
+    return { surface: 'wall', wallId: node.parentId, ceilingId: null, surfaceItemId: null }
+  }
+  if (attachTo === 'ceiling') {
+    return { surface: 'ceiling', wallId: null, ceilingId: node.parentId, surfaceItemId: null }
+  }
+  return { surface: 'floor', wallId: null, ceilingId: null, surfaceItemId: null }
+}
+
+function MoveItemContent({ movingNode }: { movingNode: ItemNode }) {
+  const draftNode = useDraftNode()
+
+  const meta =
+    typeof movingNode.metadata === 'object' && movingNode.metadata !== null
+      ? (movingNode.metadata as Record<string, unknown>)
+      : {}
+  const isNew = !!meta.isNew
+
+  const cursor = usePlacementCoordinator({
+    asset: movingNode.asset,
+    draftNode,
+    // Duplicates start fresh in floor mode; wall/ceiling draft is created lazily by ensureDraft
+    initialState: isNew
+      ? { surface: 'floor', wallId: null, ceilingId: null, surfaceItemId: null }
+      : getInitialState(movingNode),
+    // Preserve the original item's scale so Y-position calculations use the correct height
+    defaultScale: isNew ? movingNode.scale : undefined,
+    initDraft: (gridPosition) => {
+      if (isNew) {
+        // Duplicate: use the same create() path as ItemTool so ghost rendering works correctly.
+        // Floor items get a draft immediately; wall/ceiling items are created lazily on surface entry.
+        gridPosition.copy(new Vector3(...movingNode.position))
+        if (!movingNode.asset.attachTo) {
+          draftNode.create(gridPosition, movingNode.asset, movingNode.rotation, movingNode.scale)
+        }
+      } else {
+        draftNode.adopt(movingNode)
+        gridPosition.copy(new Vector3(...movingNode.position))
+      }
+    },
+    onCommitted: () => {
+      sfxEmitter.emit('sfx:item-place')
+      useEditor.getState().setMovingNode(null)
+      return false
+    },
+    onCancel: () => {
+      draftNode.destroy()
+      useEditor.getState().setMovingNode(null)
+    },
+  })
+
+  return <>{cursor}</>
+}
+
+export const MoveTool: React.FC = () => {
+  const movingNode = useEditor((state) => state.movingNode)
+
+  if (!movingNode) return null
+  if (movingNode.type === 'door') return <MoveDoorTool node={movingNode as DoorNode} />
+  if (movingNode.type === 'window') return <MoveWindowTool node={movingNode as WindowNode} />
+  if (movingNode.type === 'roof' || movingNode.type === 'roof-segment')
+    return <MoveRoofTool node={movingNode as RoofNode | RoofSegmentNode} />
+  if (movingNode.type === 'stair' || movingNode.type === 'stair-segment')
+    return <MoveRoofTool node={movingNode as StairNode | StairSegmentNode} />
+  return <MoveItemContent movingNode={movingNode as ItemNode} />
+}

package/src/components/tools/item/placement-math.ts

@@ -0,0 +1,85 @@
+import { isObject } from '@pascal-app/core'
+
+/**
+ * Snaps a position to 0.5 grid, with an offset to align item edges to grid lines.
+ * For items with dimensions like 2.5, the center would be at 1.25 from the edge,
+ * which doesn't align with 0.5 grid. This adds an offset so edges align instead.
+ */
+export function snapToGrid(position: number, dimension: number): number {
+  const halfDim = dimension / 2
+  const needsOffset = Math.abs(((halfDim * 2) % 1) - 0.5) < 0.01
+  const offset = needsOffset ? 0.25 : 0
+  return Math.round((position - offset) * 2) / 2 + offset
+}
+
+/**
+ * Snap a value to 0.5 increments (used for wall-local positions).
+ */
+export function snapToHalf(value: number): number {
+  return Math.round(value * 2) / 2
+}
+
+/**
+ * Calculate cursor rotation in WORLD space from wall normal and orientation.
+ */
+export function calculateCursorRotation(
+  normal: [number, number, number] | undefined,
+  wallStart: [number, number],
+  wallEnd: [number, number],
+): number {
+  if (!normal) return 0
+
+  // Wall direction angle in world XZ plane
+  const wallAngle = Math.atan2(wallEnd[1] - wallStart[1], wallEnd[0] - wallStart[0])
+
+  // In local wall space, front face has normal.z < 0, back face has normal.z > 0
+  if (normal[2] < 0) {
+    return -wallAngle
+  }
+  return Math.PI - wallAngle
+}
+
+/**
+ * Calculate item rotation in WALL-LOCAL space from normal.
+ * Items are children of the wall mesh, so their rotation is relative to wall's local space.
+ */
+export function calculateItemRotation(normal: [number, number, number] | undefined): number {
+  if (!normal) return 0
+
+  return normal[2] > 0 ? 0 : Math.PI
+}
+
+/**
+ * Determine which side of the wall based on the normal vector.
+ * In wall-local space, the wall runs along X-axis, so the normal points along Z-axis.
+ * Positive Z normal = 'front', Negative Z normal = 'back'
+ */
+export function getSideFromNormal(normal: [number, number, number] | undefined): 'front' | 'back' {
+  if (!normal) return 'front'
+  return normal[2] >= 0 ? 'front' : 'back'
+}
+
+/**
+ * Check if the normal indicates a valid wall side face (front or back).
+ * Filters out top face and thickness edges.
+ *
+ * In wall-local geometry space (after ExtrudeGeometry + rotateX):
+ * - X axis: along wall direction
+ * - Y axis: up (height)
+ * - Z axis: perpendicular to wall (thickness direction)
+ *
+ * So valid side faces have normals pointing in ±Z direction (local space).
+ */
+export function isValidWallSideFace(normal: [number, number, number] | undefined): boolean {
+  if (!normal) return false
+  return Math.abs(normal[2]) > 0.7
+}
+
+/**
+ * Strip the `isTransient` flag from node metadata before committing.
+ */
+export function stripTransient(meta: any): any {
+  if (!isObject(meta)) return meta
+  const { isTransient, ...rest } = meta as Record<string, any>
+  return rest
+}