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

package/src/components/tools/item/face-host-preview.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, test } from 'bun:test'
+import { Group } from 'three'
+import {
+  applyFaceHostPreviewPose,
+  clampFaceHostCenterPosition,
+  clampFaceHostPosition,
+  resolveFaceHostSwitch,
+  shouldDetachFaceHostOnLeave,
+} from './face-host-preview'
+
+describe('applyFaceHostPreviewPose', () => {
+  test('moves the rendered draft synchronously with the pointer result', () => {
+    const mesh = new Group()
+    mesh.position.set(8, 8, 8)
+    mesh.rotation.set(1, 1, 1)
+
+    applyFaceHostPreviewPose(mesh, [1.25, -0.5, 0], [0, 0, 0])
+
+    expect(mesh.position.toArray()).toEqual([1.25, -0.5, 0])
+    expect(mesh.rotation.toArray().slice(0, 3)).toEqual([0, 0, 0])
+  })
+})
+
+describe('resolveFaceHostSwitch', () => {
+  test('ignores a single adjacent-face hit and accepts a repeated hit', () => {
+    const first = resolveFaceHostSwitch('face-a', 'face-b', null)
+    expect(first).toEqual({ accept: false, pendingFaceId: 'face-b' })
+
+    const second = resolveFaceHostSwitch('face-a', 'face-b', first.pendingFaceId)
+    expect(second).toEqual({ accept: true, pendingFaceId: null })
+  })
+
+  test('clears a pending switch when the pointer returns to the current face', () => {
+    expect(resolveFaceHostSwitch('face-a', 'face-a', 'face-b')).toEqual({
+      accept: true,
+      pendingFaceId: null,
+    })
+  })
+})
+
+describe('shouldDetachFaceHostOnLeave', () => {
+  test('detaches attached items when they leave a block face', () => {
+    expect(shouldDetachFaceHostOnLeave('wall')).toBe(true)
+    expect(shouldDetachFaceHostOnLeave('wall-side')).toBe(true)
+    expect(shouldDetachFaceHostOnLeave('ceiling')).toBe(true)
+  })
+
+  test('allows free floor items to leave a block face', () => {
+    expect(shouldDetachFaceHostOnLeave(undefined)).toBe(true)
+  })
+})
+
+describe('clampFaceHostPosition', () => {
+  test('keeps the complete wall item inside the face after snapping', () => {
+    expect(
+      clampFaceHostPosition([1.9, 2.8, 0], { minU: -2, maxU: 2, minV: 0, maxV: 3 }, [1, 1]),
+    ).toEqual([1.5, 2, 0])
+  })
+
+  test('rejects a face that is smaller than the item', () => {
+    expect(
+      clampFaceHostPosition([0, 0, 0], { minU: -0.25, maxU: 0.25, minV: 0, maxV: 0.5 }, [1, 1]),
+    ).toBeNull()
+  })
+})
+
+describe('clampFaceHostCenterPosition', () => {
+  test('keeps a ceiling fixture footprint inside the face on both axes', () => {
+    expect(
+      clampFaceHostCenterPosition(
+        [1.9, 1.9, 0.25],
+        { minU: -2, maxU: 2, minV: -2, maxV: 2 },
+        [1, 1],
+      ),
+    ).toEqual([1.5, 1.5, 0.25])
+  })
+})

package/src/components/tools/item/face-host-preview.ts

@@ -0,0 +1,82 @@
+import type { Object3D } from 'three'
+
+type Vector3Tuple = readonly [number, number, number]
+
+type FaceBounds = {
+  minU: number
+  maxU: number
+  minV: number
+  maxV: number
+}
+
+export function applyFaceHostPreviewPose(
+  mesh: Object3D,
+  position: Vector3Tuple,
+  rotation: Vector3Tuple,
+): void {
+  mesh.position.set(position[0], position[1], position[2])
+  mesh.rotation.set(rotation[0], rotation[1], rotation[2])
+}
+
+export function resolveFaceHostSwitch(
+  currentFaceId: string | null | undefined,
+  nextFaceId: string | null | undefined,
+  pendingFaceId: string | null,
+): { accept: boolean; pendingFaceId: string | null } {
+  if (!currentFaceId || !nextFaceId || currentFaceId === nextFaceId) {
+    return { accept: true, pendingFaceId: null }
+  }
+
+  if (pendingFaceId === nextFaceId) {
+    return { accept: true, pendingFaceId: null }
+  }
+
+  return { accept: false, pendingFaceId: nextFaceId }
+}
+
+export function shouldDetachFaceHostOnLeave(attachTo: string | undefined): boolean {
+  return (
+    attachTo === undefined ||
+    attachTo === 'wall' ||
+    attachTo === 'wall-side' ||
+    attachTo === 'ceiling'
+  )
+}
+
+export function clampFaceHostPosition(
+  position: Vector3Tuple,
+  bounds: FaceBounds,
+  dimensions: readonly [width: number, height: number],
+): [number, number, number] | null {
+  const [width, height] = dimensions
+  const minU = bounds.minU + width / 2
+  const maxU = bounds.maxU - width / 2
+  const minV = bounds.minV
+  const maxV = bounds.maxV - height
+  if (minU > maxU || minV > maxV) return null
+
+  return [
+    Math.min(maxU, Math.max(minU, position[0])),
+    Math.min(maxV, Math.max(minV, position[1])),
+    position[2],
+  ]
+}
+
+export function clampFaceHostCenterPosition(
+  position: Vector3Tuple,
+  bounds: FaceBounds,
+  dimensions: readonly [width: number, depth: number],
+): [number, number, number] | null {
+  const [width, depth] = dimensions
+  const minU = bounds.minU + width / 2
+  const maxU = bounds.maxU - width / 2
+  const minV = bounds.minV + depth / 2
+  const maxV = bounds.maxV - depth / 2
+  if (minU > maxU || minV > maxV) return null
+
+  return [
+    Math.min(maxU, Math.max(minU, position[0])),
+    Math.min(maxV, Math.max(minV, position[1])),
+    position[2],
+  ]
+}

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

@@ -1,6 +1,6 @@
 import type { AnyNodeId, ElevatorNode, SpawnNode } from '@pascal-app/core'
-import { nodeRegistry } from '@pascal-app/core'
-import { Suspense } from 'react'
+import { createSceneApi, nodeRegistry, useScene } from '@pascal-app/core'
+import { Suspense, useMemo } from 'react'
 import { useMovingNode } from '../../../store/use-interaction-scope'
 import { MoveElevatorTool } from '../elevator/move-elevator-tool'
 import { MoveRegistryNodeTool } from '../registry/move-registry-node-tool'
@@ -28,6 +28,7 @@ export const MoveTool: React.FC<{
   onSpawnMoved?: (nodeId: SpawnNode['id']) => void
 }> = ({ onNodeMoved }) => {
   const movingNode = useMovingNode()
+  const sceneApi = useMemo(() => createSceneApi(useScene), [])
 
   if (!movingNode) return null
 
@@ -37,7 +38,7 @@ export const MoveTool: React.FC<{
   if (RegistryMove) {
     return (
       <Suspense fallback={null}>
-        <RegistryMove node={movingNode} />
+        <RegistryMove node={movingNode} sceneApi={sceneApi} />
       </Suspense>
     )
   }

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

@@ -1,5 +1,15 @@
 import { describe, expect, test } from 'bun:test'
-import { getDetachedAttachmentPreviewLift, stripTransient } from './placement-math'
+import { getDetachedAttachmentPreviewLift, steppedRotation, stripTransient } from './placement-math'
+
+describe('steppedRotation', () => {
+  test('rotates a placement clockwise to the next 45 degree increment', () => {
+    expect(steppedRotation(Math.PI / 15, 1)).toBeCloseTo(Math.PI / 4)
+  })
+
+  test('rotates a placement counter-clockwise to the previous 45 degree increment', () => {
+    expect(steppedRotation(Math.PI / 15, -1)).toBeCloseTo(-Math.PI / 4)
+  })
+})
 
 describe('stripTransient', () => {
   test('removes placement-only metadata flags before commit', () => {

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

@@ -81,26 +81,6 @@ export function getDetachedAttachmentPreviewLift(
   return attachTo ? 0.45 : 0
 }
 
-/**
- * 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.

package/src/components/tools/item/placement-strategies.test.ts

@@ -1,8 +1,299 @@
-import { describe, expect, test } from 'bun:test'
-import type { ItemNode, WallEvent, WallNode } from '@pascal-app/core'
-import { Mesh, type Object3D, Vector3 } from 'three'
-import { wallStrategy } from './placement-strategies'
+import { beforeEach, describe, expect, test } from 'bun:test'
+import {
+  BlockNode,
+  type GridEvent,
+  ItemNode,
+  type LevelNode,
+  type NodeEvent,
+  useScene,
+  type WallEvent,
+  type WallNode,
+} from '@pascal-app/core'
+import { BufferGeometry, Mesh, MeshBasicMaterial, type Object3D, Vector3 } from 'three'
+import { faceHostStrategy, floorStrategy, wallStrategy } from './placement-strategies'
 import type { PlacementContext, SpatialValidators } from './placement-types'
+import { registerTestBlockFaceHost } from './test-face-host'
+
+const BLOCK_ID = 'block_ceiling-host'
+const LEVEL_ID = 'level_ceiling-host' as LevelNode['id']
+
+beforeEach(() => {
+  registerTestBlockFaceHost()
+  useScene.setState((state) => ({
+    ...state,
+    nodes: {
+      ...state.nodes,
+      [BLOCK_ID]: BlockNode.parse({ id: BLOCK_ID, parentId: LEVEL_ID }),
+    },
+  }))
+})
+
+function ceilingContext(): PlacementContext {
+  return {
+    asset: {
+      id: 'ceiling-light',
+      category: 'lighting',
+      name: 'Ceiling light',
+      thumbnail: '/ceiling-light.png',
+      src: '/ceiling-light.glb',
+      dimensions: [1, 0.25, 1],
+      attachTo: 'ceiling',
+    },
+    levelId: LEVEL_ID,
+    draftItem: null,
+    gridPosition: new Vector3(),
+    state: {
+      surface: 'floor',
+      wallId: null,
+      roofSegmentId: null,
+      blockId: null,
+      ceilingId: null,
+      surfaceItemId: null,
+      shelfId: null,
+    },
+    currentCursorRotationY: 0,
+  }
+}
+
+function floorItemContext(): PlacementContext {
+  return {
+    ...ceilingContext(),
+    asset: {
+      id: 'potted-plant',
+      category: 'decor',
+      name: 'Potted plant',
+      thumbnail: '/potted-plant.png',
+      src: '/potted-plant.glb',
+      dimensions: [0.5, 0.39, 0.5],
+    },
+  }
+}
+
+function wallItemContext(): PlacementContext {
+  return {
+    ...ceilingContext(),
+    asset: {
+      id: 'wall-light',
+      category: 'lighting',
+      name: 'Wall light',
+      thumbnail: '/wall-light.png',
+      src: '/wall-light.glb',
+      dimensions: [0.5, 0.5, 0.25],
+      attachTo: 'wall-side',
+    },
+  }
+}
+
+function frontFaceEvent(slopeTopEdge = false): NodeEvent {
+  const box = BlockNode.parse({ id: BLOCK_ID, parentId: LEVEL_ID })
+  const node = slopeTopEdge
+    ? {
+        ...box,
+        topology: {
+          ...box.topology,
+          vertices: box.topology.vertices.map((vertex) =>
+            vertex.id === 'v4' || vertex.id === 'v5'
+              ? {
+                  ...vertex,
+                  position: [vertex.position[0], vertex.position[1], 0] satisfies [
+                    number,
+                    number,
+                    number,
+                  ],
+                }
+              : vertex,
+          ),
+        },
+      }
+    : box
+  const geometry = new BufferGeometry()
+  geometry.userData.blockFaces = [{ faceId: 'f-front', start: 0, count: 6 }]
+  const object = new Mesh(geometry, new MeshBasicMaterial())
+  object.updateMatrixWorld(true)
+
+  return {
+    node,
+    object,
+    faceIndex: 0,
+    position: [0, 1.2, slopeTopEdge ? -0.5 : -1],
+    localPosition: [0, 1.2, slopeTopEdge ? -0.5 : -1],
+    normal: [0, 0, -1],
+    stopPropagation: () => {},
+    nativeEvent: {} as NodeEvent['nativeEvent'],
+  }
+}
+
+function adjacentRightFaceEventOnFrontSurface(): NodeEvent {
+  const node = BlockNode.parse({ id: BLOCK_ID, parentId: LEVEL_ID })
+  const geometry = new BufferGeometry()
+  geometry.userData.blockFaces = [
+    { faceId: 'f-front', start: 0, count: 6 },
+    { faceId: 'f-right', start: 6, count: 6 },
+  ]
+  const object = new Mesh(geometry, new MeshBasicMaterial())
+  object.updateMatrixWorld(true)
+
+  return {
+    node,
+    object,
+    faceIndex: 2,
+    position: [0.5, 1.2, -1],
+    localPosition: [0.5, 1.2, -1],
+    normal: [1, 0, 0],
+    stopPropagation: () => {},
+    nativeEvent: {} as NodeEvent['nativeEvent'],
+  }
+}
+
+function bottomFaceEvent(): NodeEvent {
+  const node = BlockNode.parse({ id: BLOCK_ID, parentId: LEVEL_ID })
+  const geometry = new BufferGeometry()
+  geometry.userData.blockFaces = [{ faceId: 'f-bottom', start: 0, count: 6 }]
+  const object = new Mesh(geometry, new MeshBasicMaterial())
+  object.updateMatrixWorld(true)
+
+  return {
+    node,
+    object,
+    faceIndex: 0,
+    position: [0, 0, 0],
+    localPosition: [0, 0, 0],
+    normal: [0, -1, 0],
+    stopPropagation: () => {},
+    nativeEvent: {} as NodeEvent['nativeEvent'],
+  }
+}
+
+function topFaceEvent(): NodeEvent {
+  const node = BlockNode.parse({ id: BLOCK_ID, parentId: LEVEL_ID })
+  const geometry = new BufferGeometry()
+  geometry.userData.blockFaces = [{ faceId: 'f-top', start: 0, count: 6 }]
+  const object = new Mesh(geometry, new MeshBasicMaterial())
+  object.updateMatrixWorld(true)
+
+  return {
+    node,
+    object,
+    faceIndex: 0,
+    position: [0, 2.4, 0],
+    localPosition: [0, 2.4, 0],
+    normal: [0, 1, 0],
+    stopPropagation: () => {},
+    nativeEvent: {} as NodeEvent['nativeEvent'],
+  }
+}
+
+describe('faceHostStrategy', () => {
+  test('hosts a wall-mounted item on a vertical block face', () => {
+    expect(faceHostStrategy.enter(wallItemContext(), frontFaceEvent())).not.toBeNull()
+  })
+
+  test('does not host a wall-mounted item after the block face is edited into a slope', () => {
+    expect(faceHostStrategy.enter(wallItemContext(), frontFaceEvent(true))).toBeNull()
+  })
+
+  test('keeps a wall-mounted item on the active face during adjacent triangle hits', () => {
+    const context = wallItemContext()
+    const enter = faceHostStrategy.enter(context, frontFaceEvent())
+    expect(enter).not.toBeNull()
+
+    context.state.surface = 'block-face'
+    context.state.blockId = BLOCK_ID
+    context.draftItem = ItemNode.parse({
+      id: 'item_wall-light',
+      parentId: BLOCK_ID,
+      asset: context.asset,
+      ...enter?.nodeUpdate,
+    })
+    context.gridPosition.set(...enter!.gridPosition)
+
+    const move = faceHostStrategy.move(context, adjacentRightFaceEventOnFrontSurface())
+
+    expect(move?.nodeUpdate).toMatchObject({
+      blockFaceId: 'f-front',
+    } satisfies Partial<ItemNode>)
+    expect(move?.cursorPosition[2]).toBe(-1)
+  })
+
+  test('hosts a ceiling item on a downward-facing block face', () => {
+    const result = faceHostStrategy.enter(ceilingContext(), bottomFaceEvent())
+
+    expect(result).not.toBeNull()
+    expect(result?.stateUpdate).toMatchObject({
+      surface: 'block-face',
+      blockId: BLOCK_ID,
+    })
+    expect(result?.nodeUpdate).toMatchObject({
+      parentId: BLOCK_ID,
+      blockFaceId: 'f-bottom',
+      position: [0, 0, 0.25],
+      rotation: [-Math.PI / 2, 0, 0],
+    } satisfies Partial<ItemNode>)
+    expect(result?.cursorPosition).toEqual([0, -0.25, 0])
+  })
+
+  test('hosts a floor item on an upward-facing block face', () => {
+    const context = floorItemContext()
+    const event = topFaceEvent()
+    const result = faceHostStrategy.enter(context, event)
+
+    expect(result).not.toBeNull()
+    expect(result?.stateUpdate).toMatchObject({
+      surface: 'block-face',
+      blockId: BLOCK_ID,
+    })
+    expect(result?.nodeUpdate).toMatchObject({
+      parentId: BLOCK_ID,
+      blockFaceId: 'f-top',
+      position: [0, 0, 0],
+      rotation: [Math.PI / 2, 0, 0],
+    } satisfies Partial<ItemNode>)
+    expect(result?.cursorPosition).toEqual([0, 2.4, 0])
+
+    context.draftItem = ItemNode.parse({
+      id: 'item_potted-plant',
+      parentId: BLOCK_ID,
+      asset: context.asset,
+      ...result?.nodeUpdate,
+    })
+    Object.assign(context.state, result?.stateUpdate)
+    context.gridPosition.set(...result!.gridPosition)
+
+    expect(faceHostStrategy.click(context, event)?.nodeUpdate).toMatchObject({
+      parentId: BLOCK_ID,
+      blockFaceId: 'f-top',
+      position: [0, 0, 0],
+      rotation: [Math.PI / 2, 0, 0],
+    } satisfies Partial<ItemNode>)
+  })
+
+  test('restores floor-local position and rotation when an item leaves a block face', () => {
+    const context = floorItemContext()
+    context.state.surface = 'block-face'
+    context.state.blockId = BLOCK_ID
+    context.currentCursorRotationY = Math.PI / 4
+    context.gridPosition.set(1, -0.5, 2)
+    context.draftItem = ItemNode.parse({
+      id: 'item_moving-potted-plant',
+      parentId: BLOCK_ID,
+      asset: context.asset,
+      position: [0, 0, 0],
+      rotation: [Math.PI / 2, Math.PI / 4, 0],
+      blockFaceId: 'f-top',
+    })
+
+    expect(faceHostStrategy.leave(context)).toMatchObject({
+      nodeUpdate: {
+        parentId: LEVEL_ID,
+        blockFaceId: undefined,
+        position: [1, 0, 2],
+        rotation: [0, Math.PI / 4, 0],
+      } satisfies Partial<ItemNode>,
+      gridPosition: [1, 0, 2],
+      cursorPosition: [1, 0, 2],
+    })
+  })
+})
 
 /**
  * The wall frame the runtime builds in `updateWallGeometry`: origin at
@@ -165,3 +456,39 @@ describe('wallStrategy.move', () => {
     expect(result.cursorPosition[1]).toBeCloseTo(0.4 + 0.05, 6)
   })
 })
+
+describe('floorStrategy.move', () => {
+  function makeGridEvent(x: number, y: number, z: number): GridEvent {
+    return {
+      position: [x, y, z],
+      localPosition: [x, y, z],
+      nativeEvent: {} as GridEvent['nativeEvent'],
+    }
+  }
+
+  test('follows the live grid Y so a raised placement keeps its height', () => {
+    const context = floorItemContext()
+    context.gridPosition.set(0, 0.9, 0)
+
+    const result = floorStrategy.move(context, makeGridEvent(1.25, 0.9, 2.25))
+    if (!result) throw new Error('expected a placement result')
+
+    expect(result.gridPosition[1]).toBe(0.9)
+    expect(result.cursorPosition[1]).toBe(0.9)
+  })
+
+  // `detachItemSurfaceToFloor` zeroes the grid Y when an item is taken off a
+  // host; the floor path must honour that instead of a Y frozen at drag start,
+  // or the item commits floating at the shelf's height.
+  test('drops to the level plane once un-hosting zeroes the grid Y', () => {
+    const context = floorItemContext()
+    context.gridPosition.set(0, 0, 0)
+
+    const result = floorStrategy.move(context, makeGridEvent(1.25, 0.9, 2.25))
+    if (!result) throw new Error('expected a placement result')
+
+    expect(result.gridPosition[1]).toBe(0)
+    expect(result.cursorPosition[1]).toBe(0)
+    expect(result.nodeUpdate?.position?.[1]).toBe(0)
+  })
+})