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

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/item-surface-placement.test.ts

@@ -0,0 +1,175 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import {
+  type ItemEvent,
+  ItemNode,
+  nodeRegistry,
+  registerNode,
+  sceneRegistry,
+  useScene,
+} from '@pascal-app/core'
+import { Group, Vector3 } from 'three'
+import useEditor from '../../../store/use-editor'
+import useInteractionScope from '../../../store/use-interaction-scope'
+import { itemSurfaceStrategy } from './placement-strategies'
+import type { PlacementContext } from './placement-types'
+
+const asset = {
+  id: 'table',
+  name: 'Table',
+  category: 'furniture',
+  thumbnail: '',
+  src: '/table.glb',
+  dimensions: [2, 1, 3],
+}
+let restoreRegistry: () => void
+const editorState = useEditor.getState()
+const scopeState = useInteractionScope.getState()
+
+beforeEach(() => {
+  restoreRegistry = nodeRegistry._snapshot()
+  nodeRegistry._reset()
+  registerNode({
+    kind: 'item',
+    schemaVersion: 1,
+    schema: ItemNode,
+    category: 'furnish',
+    snapProfile: 'item',
+    defaults: () => ({}),
+    capabilities: {},
+  })
+  useInteractionScope.setState({ scope: { kind: 'idle' } })
+  useEditor.setState({ mode: 'build', tool: 'item', gridSnapStep: 0.5 })
+  useEditor.getState().setSnappingMode('item', 'grid')
+})
+
+afterEach(() => {
+  restoreRegistry()
+  sceneRegistry.nodes.delete('item_surface-test')
+  useEditor.setState(editorState)
+  useInteractionScope.setState(scopeState)
+})
+
+function surface(overrides: Partial<ItemNode> = {}) {
+  const host = ItemNode.parse({ id: 'item_surface-test', asset, ...overrides })
+  const mesh = new Group()
+  mesh.position.set(4, 2, -3)
+  mesh.rotation.y = Math.PI / 3
+  mesh.updateMatrixWorld(true)
+  sceneRegistry.nodes.set(host.id, mesh)
+  const world = mesh.localToWorld(new Vector3(0.37, 0.81, -0.39))
+  const event = {
+    node: host,
+    object: mesh,
+    position: world.toArray(),
+    localPosition: [0.37, 0.81, -0.39],
+    normal: [0, 1, 0],
+    stopPropagation: () => {},
+    nativeEvent: {} as ItemEvent['nativeEvent'],
+  } as ItemEvent
+  return { host, mesh, event }
+}
+
+function enterSurface(
+  event: ItemEvent,
+  dimensions: [number, number, number],
+  yaw = 0,
+  draftId?: ItemNode['id'],
+) {
+  const draft = ItemNode.parse({ id: draftId, asset: { ...asset, dimensions } })
+  return itemSurfaceStrategy.enter(
+    {
+      asset: draft.asset,
+      draftItem: draft,
+      state: { surface: 'floor' },
+      currentCursorRotationY: yaw,
+    } as PlacementContext,
+    event,
+  )
+}
+
+describe('itemSurfaceStrategy production placement', () => {
+  test('scaled host accepts centred rotated and oversized footprints', () => {
+    const { event } = surface({ scale: [2, 1, 0.5] })
+    expect(enterSurface(event, [4, 5, 1.5], 0)).not.toBeNull()
+    expect(enterSurface(event, [4, 5, 1.5], Math.PI / 3)).not.toBeNull()
+    expect(enterSurface(event, [4.01, 1, 1.5], 0)).not.toBeNull()
+    expect(enterSurface(event, [4, 1, 1.51], 0)).not.toBeNull()
+  })
+
+  test('rejects ceiling hosts, low profiles, side hits, and absent normals', () => {
+    for (const overrides of [
+      { asset: { ...asset, attachTo: 'ceiling' } },
+      { asset: { ...asset, dimensions: [2, 0.05, 3] } },
+    ]) {
+      const { event } = surface(overrides as Partial<ItemNode>)
+      expect(enterSurface(event, [0.5, 1, 0.5], 0)).toBeNull()
+    }
+    const { event } = surface()
+    for (const normal of [[1, 0, 0], [0, -1, 0], undefined]) {
+      expect(enterSurface({ ...event, normal } as ItemEvent, [0.5, 1, 0.5], 0)).toBeNull()
+    }
+  })
+
+  test('uses scaled asset surface height, snapped host-local XZ, and continuous world yaw', () => {
+    const { mesh, event } = surface({
+      asset: { ...asset, surface: { height: 0.7 } } as ItemNode['asset'],
+      scale: [1, 2, 1],
+    })
+    const pose = enterSurface(event, [0.5, 1, 0.5], Math.PI / 4)!
+    expect(pose.nodeUpdate.position!).toEqual([0.25, 1.4, -0.25])
+    expect(pose.nodeUpdate.rotation![1]! + Math.PI / 3).toBeCloseTo(Math.PI / 4)
+    expect(pose.cursorPosition).toEqual(
+      mesh.localToWorld(new Vector3(...pose.nodeUpdate.position!)).toArray(),
+    )
+  })
+
+  test('uses local hit Y without surface metadata and honors snapping off', () => {
+    useEditor.getState().setSnappingMode('item', 'off')
+    const { event } = surface()
+    const pose = enterSurface(event, [0.5, 1, 0.5], 0)!
+    expect(pose.nodeUpdate.position![0]).toBeCloseTo(0.37)
+    expect(pose.nodeUpdate.position![1]).toBeCloseTo(0.81)
+    expect(pose.nodeUpdate.position![2]).toBeCloseTo(-0.39)
+  })
+
+  test('rejects the moving node and its descendants', () => {
+    const { host, event } = surface({ parentId: 'item_moving' })
+    expect(enterSurface(event, [0.5, 1, 0.5], 0, host.id)).toBeNull()
+    expect(enterSurface(event, [0.5, 1, 0.5], 0, 'item_moving')).toBeNull()
+  })
+
+  test('catalog strategy keeps its enter pose and position-only move contract', () => {
+    const { host, event } = surface()
+    const draft = ItemNode.parse({ asset: { ...asset, dimensions: [0.5, 1, 0.5] } })
+    const ctx = {
+      asset: draft.asset,
+      draftItem: draft,
+      state: {
+        surface: 'floor',
+        wallId: null,
+        roofSegmentId: null,
+        ceilingId: null,
+        surfaceItemId: null,
+        shelfId: null,
+      },
+      currentCursorRotationY: 0.2,
+      gridPosition: new Vector3(),
+      levelId: 'level_test',
+    } as PlacementContext
+    const enter = itemSurfaceStrategy.enter(ctx, event)!
+    expect(enter.nodeUpdate.parentId).toBe(host.id)
+    expect(enter.nodeUpdate.rotation?.[1]).toBeCloseTo(0.2 - Math.PI / 3)
+    const oldNodes = useScene.getState().nodes
+    useScene.setState({ nodes: { ...oldNodes, [host.id]: host } })
+    try {
+      const move = itemSurfaceStrategy.move(
+        { ...ctx, state: { ...ctx.state, surface: 'item-surface', surfaceItemId: host.id } },
+        event,
+      )!
+      expect(move.nodeUpdate).toEqual({ position: enter.gridPosition })
+      expect(move.cursorRotationY).toBe(0.2)
+    } finally {
+      useScene.setState({ nodes: oldNodes })
+    }
+  })
+})

package/src/components/tools/item/item-surface-strategy-resolver.test.ts

@@ -0,0 +1,210 @@
+import { afterEach, beforeEach, expect, spyOn, test } from 'bun:test'
+import * as core from '@pascal-app/core'
+import {
+  type ItemEvent,
+  ItemNode,
+  nodeRegistry,
+  registerNode,
+  sceneRegistry,
+  useScene,
+} from '@pascal-app/core'
+import { Group, Vector3 } from 'three'
+import useEditor from '../../../store/use-editor'
+import useInteractionScope from '../../../store/use-interaction-scope'
+import { itemSurfaceStrategy } from './placement-strategies'
+import type { PlacementContext } from './placement-types'
+
+const asset = {
+  id: 'table',
+  name: 'Table',
+  category: 'furniture',
+  thumbnail: '',
+  src: '/table.glb',
+  dimensions: [2, 1, 3],
+}
+const host = ItemNode.parse({ id: 'item_strategy-resolver-host', asset, scale: [2, 1, 0.5] })
+const child = ItemNode.parse({
+  id: 'item_strategy-resolver-child',
+  asset: { ...asset, dimensions: [0.5, 1, 0.5] },
+  rotation: [0.1, 0.2, 0.3],
+})
+let restoreRegistry: () => void
+let savedNodes: ReturnType<typeof useScene.getState>['nodes']
+let savedEditor: ReturnType<typeof useEditor.getState>
+let savedScope: ReturnType<typeof useInteractionScope.getState>
+let resolver: ReturnType<typeof spyOn<typeof core, 'resolveSurfacePlacement'>>
+
+beforeEach(() => {
+  restoreRegistry = nodeRegistry._snapshot()
+  nodeRegistry._reset()
+  registerNode({
+    kind: 'item',
+    schemaVersion: 1,
+    schema: ItemNode,
+    category: 'furnish',
+    snapProfile: 'item',
+    defaults: () => ({}),
+    capabilities: {},
+  })
+  savedNodes = useScene.getState().nodes
+  savedEditor = useEditor.getState()
+  savedScope = useInteractionScope.getState()
+  useScene.setState({ nodes: { [host.id]: host, [child.id]: child } })
+  useInteractionScope.setState({ scope: { kind: 'idle' } })
+  useEditor.setState({ mode: 'build', tool: 'item', gridSnapStep: 0.5 })
+  useEditor.getState().setSnappingMode('item', 'grid')
+  const mesh = new Group()
+  mesh.position.set(4, 2, -3)
+  mesh.rotation.set(0.1, Math.PI / 3, -0.1)
+  mesh.scale.set(2, 1, 0.5)
+  mesh.updateMatrixWorld(true)
+  sceneRegistry.nodes.set(host.id, mesh)
+  resolver = spyOn(core, 'resolveSurfacePlacement')
+})
+
+afterEach(() => {
+  resolver.mockRestore()
+  restoreRegistry()
+  sceneRegistry.nodes.delete(host.id)
+  useScene.setState({ nodes: savedNodes })
+  useEditor.setState(savedEditor)
+  useInteractionScope.setState(savedScope)
+})
+
+function context(draftItem = child): PlacementContext {
+  return {
+    asset: draftItem.asset,
+    draftItem,
+    state: {
+      surface: 'floor',
+      wallId: null,
+      roofSegmentId: null,
+      ceilingId: null,
+      surfaceItemId: null,
+      shelfId: null,
+    },
+    currentCursorRotationY: 0.2,
+    gridPosition: new Vector3(),
+    levelId: 'level_test',
+  } as PlacementContext
+}
+
+function hit(): ItemEvent {
+  const object = sceneRegistry.nodes.get(host.id)!
+  return {
+    node: host,
+    object,
+    normal: [0, 1, 0],
+    position: object.localToWorld(new Vector3(0.37, 0.81, -0.39)).toArray(),
+    localPosition: [0.37, 0.81, -0.39],
+    nativeEvent: {},
+    stopPropagation() {},
+  } as ItemEvent
+}
+
+function onHost(ctx: PlacementContext): PlacementContext {
+  return { ...ctx, state: { ...ctx.state, surface: 'item-surface', surfaceItemId: host.id } }
+}
+
+// Expected poses were captured from resolveItemSurfacePlacement at ad2a57b8 before its removal.
+test.each([
+  [4.01, 1, 1.5],
+  [4, 1, 1.51],
+] as [
+  number,
+  number,
+  number,
+][])('enter and move accept oversized objects with their centres on the host: %j', (width, height, depth) => {
+  const draft = ItemNode.parse({
+    ...child,
+    asset: { ...asset, dimensions: [width, height, depth] },
+  })
+  const ctx = context(draft)
+  const event = hit()
+  const before = useScene.getState().nodes
+  expect(itemSurfaceStrategy.enter(ctx, event)).not.toBeNull()
+  const expected: {
+    position: [number, number, number]
+    worldPosition: [number, number, number]
+  } =
+    width === 4.01
+      ? {
+          position: [0.5049999999999999, 0.8099999999999996, -0.25],
+          worldPosition: [4.434656461734313, 2.8017166019018256, -3.927442316539199],
+        }
+      : {
+          position: [0.5, 0.8099999999999996, -0.245],
+          worldPosition: [4.4318465044173845, 2.8017248933478855, -3.9175249544338326],
+        }
+  const moved = itemSurfaceStrategy.move(onHost(ctx), event)!
+  expect(moved.nodeUpdate).toEqual({ position: expected.position })
+  expect(moved.cursorPosition).toEqual(expected.worldPosition)
+  expect(moved.cursorRotationY).toBe(ctx.currentCursorRotationY)
+  expect(resolver.mock.calls.map(([args]) => args.checkFootprint)).toEqual([true, true])
+  expect(useScene.getState().nodes).toBe(before)
+})
+
+test.each([
+  'grid',
+  'off',
+] as const)('accepted poses match the frozen live capture with snapping %s', (mode) => {
+  useEditor.getState().setSnappingMode('item', mode)
+  const ctx = context()
+  const event = hit()
+  const expected: {
+    position: [number, number, number]
+    worldPosition: [number, number, number]
+    rotationY: number
+  } = {
+    ...(mode === 'grid'
+      ? {
+          position: [0.25, 0.8099999999999996, -0.25],
+          worldPosition: [4.180930399588417, 2.808503845962115, -3.4850883647019826],
+        }
+      : {
+          position: [0.36999999999999966, 0.8099999999999996, -0.39000000000000146],
+          worldPosition: [4.239709121156868, 2.808804018339912, -3.728080076057168],
+        }),
+    rotationY: -0.84936351290154,
+  }
+  const entered = itemSurfaceStrategy.enter(ctx, event)!
+  expect(entered.nodeUpdate).toEqual({
+    position: expected.position,
+    parentId: host.id,
+    rotation: [0.1, expected.rotationY, 0.3],
+  })
+  expect(entered.cursorPosition).toEqual(expected.worldPosition)
+  expect(itemSurfaceStrategy.move(onHost(ctx), event)!.nodeUpdate).toEqual({
+    position: expected.position,
+  })
+  expect(resolver).toHaveBeenCalledTimes(2)
+})
+
+test('resolver rejection leaves both enter and move drafts alone', () => {
+  resolver.mockReturnValue(null)
+  const ctx = context()
+  const before = useScene.getState().nodes
+  expect(itemSurfaceStrategy.enter(ctx, hit())).toBeNull()
+  expect(itemSurfaceStrategy.move(onHost(ctx), hit())).toBeNull()
+  expect(useScene.getState().nodes).toBe(before)
+  expect(ctx.draftItem).toBe(child)
+})
+
+test('move still rejects side hits and missing normals', () => {
+  for (const normal of [[1, 0, 0], [0, -1, 0], undefined] as ItemEvent['normal'][]) {
+    const event = { ...hit(), normal }
+    expect(itemSurfaceStrategy.enter(context(), event)).toBeNull()
+    expect(itemSurfaceStrategy.move(onHost(context()), event)).toBeNull()
+  }
+})
+
+test('enter rejects itself and indirect descendants before asking the resolver', () => {
+  expect(itemSurfaceStrategy.enter(context(host), hit())).toBeNull()
+  const middle = ItemNode.parse({ id: 'item_strategy-middle', parentId: child.id, asset })
+  const descendant = { ...host, parentId: middle.id }
+  useScene.setState({
+    nodes: { ...useScene.getState().nodes, [middle.id]: middle, [host.id]: descendant },
+  })
+  expect(itemSurfaceStrategy.enter(context(), { ...hit(), node: descendant })).toBeNull()
+  expect(resolver).not.toHaveBeenCalled()
+})

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.