@pascal-app/editor 1.0.0-beta.4 → 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.