@pascal-app/editor 0.6.0 → 0.7.0

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

@@ -9,11 +9,17 @@ import type {
   WallEvent,
   WallNode,
 } from '@pascal-app/core'
-import { getScaledDimensions, sceneRegistry, useScene } from '@pascal-app/core'
-import { Vector3 } from 'three'
+import {
+  getScaledDimensions,
+  isLowProfileItemSurface,
+  sceneRegistry,
+  useScene,
+} from '@pascal-app/core'
+import { Euler, Matrix3, Quaternion, Vector3 } from 'three'
 import {
   calculateCursorRotation,
   calculateItemRotation,
+  getGridAlignedDimensions,
   getSideFromNormal,
   isValidWallSideFace,
   snapToGrid,
@@ -30,6 +36,46 @@ import type {
 } from './placement-types'
 
 const DEFAULT_DIMENSIONS: [number, number, number] = [1, 1, 1]
+const UPWARD_SURFACE_NORMAL_MIN_Y = 0.75
+
+function getWorldNormalY(event: ItemEvent): number | null {
+  if (!event.normal) return null
+
+  const normal = new Vector3(event.normal[0], event.normal[1], event.normal[2])
+  normal.applyNormalMatrix(new Matrix3().getNormalMatrix(event.object.matrixWorld)).normalize()
+  return normal.y
+}
+
+function isUpwardItemSurfaceHit(event: ItemEvent): boolean {
+  const normalY = getWorldNormalY(event)
+  return normalY !== null && normalY >= UPWARD_SURFACE_NORMAL_MIN_Y
+}
+
+function getSurfacePlacementHeight(surfaceItem: ItemNode, event: ItemEvent, localPos: Vector3) {
+  if (isLowProfileItemSurface(surfaceItem)) return null
+  if (!isUpwardItemSurfaceHit(event)) return null
+
+  if (surfaceItem.asset.surface) {
+    return surfaceItem.asset.surface.height * surfaceItem.scale[1]
+  }
+
+  if (!Number.isFinite(localPos.y)) return null
+  return localPos.y
+}
+
+function isDescendantOfItem(
+  candidate: ItemNode,
+  ancestor: ItemNode,
+  nodes: Record<string, AnyNode>,
+): boolean {
+  let parentId = candidate.parentId
+  while (parentId) {
+    if (parentId === ancestor.id) return true
+    const parent = nodes[parentId as AnyNodeId]
+    parentId = parent?.parentId ?? null
+  }
+  return false
+}
 
 // ============================================================================
 // FLOOR STRATEGY
@@ -43,9 +89,10 @@ export const floorStrategy = {
   move(ctx: PlacementContext, event: GridEvent): PlacementResult | null {
     if (ctx.state.surface !== 'floor') return null
 
-    const dims = ctx.draftItem
+    const rawDims = ctx.draftItem
       ? getScaledDimensions(ctx.draftItem)
       : (ctx.asset.dimensions ?? DEFAULT_DIMENSIONS)
+    const dims = getGridAlignedDimensions(rawDims, ctx.asset.attachTo)
     const [dimX, , dimZ] = dims
     const rotY = ctx.draftItem?.rotation?.[1] ?? 0
     const swapDims = Math.abs(Math.sin(rotY)) > 0.9
@@ -80,7 +127,7 @@ export const floorStrategy = {
     const valid = validators.canPlaceOnFloor(
       ctx.levelId,
       pos,
-      getScaledDimensions(ctx.draftItem),
+      getGridAlignedDimensions(getScaledDimensions(ctx.draftItem), ctx.draftItem.asset.attachTo),
       ctx.draftItem.rotation,
       [ctx.draftItem.id],
     ).valid
@@ -133,14 +180,15 @@ export const wallStrategy = {
     const z = snapToHalf(event.localPosition[2])
 
     // Get auto-adjusted Y position from validator
+    const rawDims = ctx.draftItem
+      ? getScaledDimensions(ctx.draftItem)
+      : (ctx.asset.dimensions ?? DEFAULT_DIMENSIONS)
     const validation = validators.canPlaceOnWall(
       ctx.levelId,
       event.node.id,
       x,
       y,
-      ctx.draftItem
-        ? getScaledDimensions(ctx.draftItem)
-        : (ctx.asset.dimensions ?? DEFAULT_DIMENSIONS),
+      getGridAlignedDimensions(rawDims, attachTo),
       attachTo,
       side,
       [],
@@ -195,7 +243,7 @@ export const wallStrategy = {
       event.node.id,
       snappedX,
       snappedY,
-      getScaledDimensions(ctx.draftItem),
+      getGridAlignedDimensions(getScaledDimensions(ctx.draftItem), ctx.draftItem.asset.attachTo),
       ctx.draftItem.asset.attachTo as 'wall' | 'wall-side',
       side,
       [ctx.draftItem.id],
@@ -239,7 +287,7 @@ export const wallStrategy = {
       ctx.state.wallId as WallNode['id'],
       ctx.gridPosition.x,
       ctx.gridPosition.y,
-      getScaledDimensions(ctx.draftItem),
+      getGridAlignedDimensions(getScaledDimensions(ctx.draftItem), ctx.draftItem.asset.attachTo),
       ctx.draftItem.asset.attachTo as 'wall' | 'wall-side',
       ctx.draftItem.side,
       [ctx.draftItem.id],
@@ -301,16 +349,20 @@ export const ceilingStrategy = {
     const ceilingLevelId = resolveLevelId(event.node, nodes)
     if (ctx.levelId !== ceilingLevelId) return null
 
-    const dims = ctx.draftItem
+    const rawDims = ctx.draftItem
       ? getScaledDimensions(ctx.draftItem)
       : (ctx.asset.dimensions ?? DEFAULT_DIMENSIONS)
+    const dims = getGridAlignedDimensions(rawDims, ctx.asset.attachTo)
     const [dimX, , dimZ] = dims
-    const itemHeight = dims[1]
+    const itemHeight = rawDims[1]
     const rotY = ctx.draftItem?.rotation?.[1] ?? 0
     const swapDims = Math.abs(Math.sin(rotY)) > 0.9
 
-    const x = snapToGrid(event.position[0], swapDims ? dimZ : dimX)
-    const z = snapToGrid(event.position[2], swapDims ? dimX : dimZ)
+    // Ceiling items are stored in ceiling-local coordinates, so snapping must
+    // use the ceiling hit's local position rather than world position.
+    const x = snapToGrid(event.localPosition[0], swapDims ? dimZ : dimX)
+    const z = snapToGrid(event.localPosition[2], swapDims ? dimX : dimZ)
+    const worldSnapped = event.object.localToWorld(new Vector3(x, -itemHeight, z))
 
     return {
       stateUpdate: { surface: 'ceiling', ceilingId: event.node.id },
@@ -320,7 +372,7 @@ export const ceilingStrategy = {
       },
       cursorRotationY: 0,
       gridPosition: [x, -itemHeight, z],
-      cursorPosition: [x, event.position[1] - itemHeight, z],
+      cursorPosition: [worldSnapped.x, worldSnapped.y, worldSnapped.z],
       stopPropagation: true,
     }
   },
@@ -332,18 +384,20 @@ export const ceilingStrategy = {
     if (ctx.state.surface !== 'ceiling') return null
     if (!ctx.draftItem) return null
 
-    const dims = getScaledDimensions(ctx.draftItem)
+    const rawDims = getScaledDimensions(ctx.draftItem)
+    const dims = getGridAlignedDimensions(rawDims, ctx.draftItem.asset.attachTo)
     const [dimX, , dimZ] = dims
-    const itemHeight = dims[1]
+    const itemHeight = rawDims[1]
     const rotY = ctx.draftItem.rotation?.[1] ?? 0
     const swapDims = Math.abs(Math.sin(rotY)) > 0.9
 
-    const x = snapToGrid(event.position[0], swapDims ? dimZ : dimX)
-    const z = snapToGrid(event.position[2], swapDims ? dimX : dimZ)
+    const x = snapToGrid(event.localPosition[0], swapDims ? dimZ : dimX)
+    const z = snapToGrid(event.localPosition[2], swapDims ? dimX : dimZ)
+    const worldSnapped = event.object.localToWorld(new Vector3(x, -itemHeight, z))
 
     return {
       gridPosition: [x, -itemHeight, z],
-      cursorPosition: [x, event.position[1] - itemHeight, z],
+      cursorPosition: [worldSnapped.x, worldSnapped.y, worldSnapped.z],
       cursorRotationY: 0,
       nodeUpdate: null,
       stopPropagation: true,
@@ -371,7 +425,7 @@ export const ceilingStrategy = {
     const valid = validators.canPlaceOnCeiling(
       ctx.state.ceilingId as CeilingNode['id'],
       pos,
-      getScaledDimensions(ctx.draftItem),
+      getGridAlignedDimensions(getScaledDimensions(ctx.draftItem), ctx.draftItem.asset.attachTo),
       ctx.draftItem.rotation,
       [ctx.draftItem.id],
     ).valid
@@ -425,8 +479,11 @@ export const itemSurfaceStrategy = {
     const surfaceItem = event.node as ItemNode
     // Don't surface-place on the draft itself
     if (surfaceItem.id === ctx.draftItem?.id) return null
-    // Surface item must declare a surface
-    if (!surfaceItem.asset.surface) return null
+    if (ctx.state.surface === 'item-surface' && ctx.state.surfaceItemId === surfaceItem.id) {
+      return null
+    }
+    const nodes = useScene.getState().nodes
+    if (ctx.draftItem && isDescendantOfItem(surfaceItem, ctx.draftItem, nodes)) return null
 
     // Size check: our footprint must fit on surface item's footprint
     const ourDims = ctx.draftItem
@@ -440,17 +497,32 @@ export const itemSurfaceStrategy = {
 
     const worldPos = new Vector3(event.position[0], event.position[1], event.position[2])
     const localPos = surfaceMesh.worldToLocal(worldPos)
+    const surfaceHeight = getSurfacePlacementHeight(surfaceItem, event, localPos)
+    if (surfaceHeight === null) return null
 
     const x = snapToGrid(localPos.x, ourDims[0])
     const z = snapToGrid(localPos.z, ourDims[2])
-    const y = surfaceItem.asset.surface.height * surfaceItem.scale[1]
+    const y = surfaceHeight
 
     const worldSnapped = surfaceMesh.localToWorld(new Vector3(x, y, z))
 
     return {
       stateUpdate: { surface: 'item-surface', surfaceItemId: surfaceItem.id },
-      nodeUpdate: { position: [x, y, z], parentId: surfaceItem.id },
-      cursorRotationY: 0,
+      nodeUpdate: {
+        position: [x, y, z],
+        parentId: surfaceItem.id,
+        rotation: [
+          (ctx.draftItem?.rotation ?? [0, 0, 0])[0],
+          (() => {
+            const surfaceQuat = new Quaternion()
+            surfaceMesh.getWorldQuaternion(surfaceQuat)
+            const surfaceWorldY = new Euler().setFromQuaternion(surfaceQuat, 'YXZ').y
+            return ctx.currentCursorRotationY - surfaceWorldY
+          })(),
+          (ctx.draftItem?.rotation ?? [0, 0, 0])[2],
+        ] as [number, number, number],
+      },
+      cursorRotationY: ctx.currentCursorRotationY,
       gridPosition: [x, y, z],
       cursorPosition: [worldSnapped.x, worldSnapped.y, worldSnapped.z],
       stopPropagation: true,
@@ -463,10 +535,11 @@ export const itemSurfaceStrategy = {
   move(ctx: PlacementContext, event: ItemEvent): PlacementResult | null {
     if (ctx.state.surface !== 'item-surface') return null
     if (!(ctx.state.surfaceItemId && ctx.draftItem)) return null
+    if (event.node.id !== ctx.state.surfaceItemId) return null
 
     const nodes = useScene.getState().nodes
     const surfaceItem = nodes[ctx.state.surfaceItemId as AnyNodeId] as ItemNode | undefined
-    if (!surfaceItem?.asset.surface) return null
+    if (!surfaceItem) return null
 
     const surfaceMesh = sceneRegistry.nodes.get(ctx.state.surfaceItemId)
     if (!surfaceMesh) return null
@@ -474,17 +547,19 @@ export const itemSurfaceStrategy = {
     const ourDims = getScaledDimensions(ctx.draftItem)
     const worldPos = new Vector3(event.position[0], event.position[1], event.position[2])
     const localPos = surfaceMesh.worldToLocal(worldPos)
+    const surfaceHeight = getSurfacePlacementHeight(surfaceItem, event, localPos)
+    if (surfaceHeight === null) return null
 
     const x = snapToGrid(localPos.x, ourDims[0])
     const z = snapToGrid(localPos.z, ourDims[2])
-    const y = surfaceItem.asset.surface.height * surfaceItem.scale[1]
+    const y = surfaceHeight
 
     const worldSnapped = surfaceMesh.localToWorld(new Vector3(x, y, z))
 
     return {
       gridPosition: [x, y, z],
       cursorPosition: [worldSnapped.x, worldSnapped.y, worldSnapped.z],
-      cursorRotationY: 0,
+      cursorRotationY: ctx.currentCursorRotationY,
       nodeUpdate: { position: [x, y, z] },
       stopPropagation: true,
       dirtyNodeId: null,
@@ -497,6 +572,7 @@ export const itemSurfaceStrategy = {
   click(ctx: PlacementContext, _event: ItemEvent): CommitResult | null {
     if (ctx.state.surface !== 'item-surface') return null
     if (!(ctx.draftItem && ctx.state.surfaceItemId)) return null
+    if (_event.node.id !== ctx.state.surfaceItemId) return null
 
     return {
       nodeUpdate: {
@@ -528,12 +604,14 @@ export function checkCanPlace(ctx: PlacementContext, validators: SpatialValidato
 
   const attachTo = ctx.draftItem.asset.attachTo
 
+  const alignedDims = getGridAlignedDimensions(getScaledDimensions(ctx.draftItem), attachTo)
+
   if (attachTo === 'ceiling') {
     if (ctx.state.surface !== 'ceiling' || !ctx.state.ceilingId) return false
     return validators.canPlaceOnCeiling(
       ctx.state.ceilingId as CeilingNode['id'],
       [ctx.gridPosition.x, ctx.gridPosition.y, ctx.gridPosition.z],
-      getScaledDimensions(ctx.draftItem),
+      alignedDims,
       ctx.draftItem.rotation,
       [ctx.draftItem.id],
     ).valid
@@ -546,7 +624,7 @@ export function checkCanPlace(ctx: PlacementContext, validators: SpatialValidato
       ctx.state.wallId as WallNode['id'],
       ctx.gridPosition.x,
       ctx.gridPosition.y,
-      getScaledDimensions(ctx.draftItem),
+      alignedDims,
       attachTo,
       ctx.draftItem.side,
       [ctx.draftItem.id],
@@ -557,7 +635,7 @@ export function checkCanPlace(ctx: PlacementContext, validators: SpatialValidato
   return validators.canPlaceOnFloor(
     ctx.levelId,
     [ctx.gridPosition.x, 0, ctx.gridPosition.z],
-    getScaledDimensions(ctx.draftItem),
+    alignedDims,
     ctx.draftItem.rotation,
     [ctx.draftItem.id],
   ).valid

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

@@ -38,6 +38,13 @@ export interface PlacementContext {
   draftItem: ItemNode | null
   gridPosition: Vector3
   state: PlacementState
+  /**
+   * Current world Y rotation of the placement cursor — the user's intended
+   * orientation, preserved across surface transitions. Strategies that
+   * re-parent the draft (e.g. floor → item-surface) read this to compute the
+   * matching parent-local rotation so the world orientation doesn't jump.
+   */
+  currentCursorRotationY: number
 }
 
 // ============================================================================

package/src/components/tools/item/use-draft-node.ts

@@ -130,6 +130,7 @@ export function useDraftNode(): DraftNodeHandle {
       useScene.getState().updateNode(draft.id, {
         position: updateProps.position ?? draft.position,
         rotation: updateProps.rotation ?? draft.rotation,
+        scale: updateProps.scale ?? draft.scale,
         side: updateProps.side ?? draft.side,
         metadata: updateProps.metadata ?? stripTransient(draft.metadata),
         parentId: parentId as string,
@@ -161,6 +162,7 @@ export function useDraftNode(): DraftNodeHandle {
       asset: draft.asset,
       position: updateProps.position ?? draft.position,
       rotation: updateProps.rotation ?? draft.rotation,
+      scale: updateProps.scale ?? draft.scale,
       side: updateProps.side ?? draft.side,
       metadata: updateProps.metadata ?? stripTransient(draft.metadata),
     })