@pascal-app/editor 1.0.1 → 1.0.3

package/src/lib/spatial-drag-plane.ts

@@ -0,0 +1,19 @@
+import { type Matrix4, Plane, type Ray, Vector3 } from 'three'
+
+export function createSpatialDragPlane(point: Vector3, ray: Ray, localToWorld?: Matrix4) {
+  const normal = new Vector3(0, 1, 0)
+  if (localToWorld) normal.transformDirection(localToWorld)
+  // A nearly horizontal controller ray cannot reliably intersect a floor plane.
+  if (Math.abs(normal.dot(ray.direction)) < 0.2) normal.copy(ray.direction)
+  return new Plane().setFromNormalAndCoplanarPoint(normal, point)
+}
+
+export function intersectSpatialDragPlane(ray: Ray, plane: Plane, target: Vector3) {
+  if (Math.abs(plane.normal.dot(ray.direction)) < 0.05) return null
+  return ray.intersectPlane(plane, target)
+}
+
+// Freeze this frame at grab time; world metres differ from model metres in God view.
+export function spatialDragLocalY(worldPoint: Vector3, worldToLocal: Matrix4) {
+  return worldPoint.clone().applyMatrix4(worldToLocal).y
+}

package/src/lib/spatial-pointer-input.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, test } from 'bun:test'
+import { Ray, Vector3 } from 'three'
+import { getSpatialPointerId, SpatialPointerInput } from './spatial-pointer-input'
+
+describe('SpatialPointerInput', () => {
+  test('recognizes current and legacy XR native event shapes', () => {
+    const source = {}
+    expect(getSpatialPointerId({ inputSource: source })).toBe(source)
+    expect(getSpatialPointerId({ pointerState: { inputSource: source } })).toBe(source)
+    expect(getSpatialPointerId({ pointerType: 'mouse' })).toBeNull()
+  })
+
+  test('keeps move and release bound to the pointer that captured a handle', () => {
+    const input = new SpatialPointerInput()
+    const moves: Ray[] = []
+    let releases = 0
+    input.capture(42, {
+      onMove: (ray) => moves.push(ray.clone()),
+      onRelease: () => releases++,
+      onCancel: () => undefined,
+    })
+    const ray = new Ray(new Vector3(1, 2, 3), new Vector3(0, 1, 0))
+    expect(input.move(7, ray)).toBe(false)
+    expect(input.move(42, ray)).toBe(true)
+    expect(input.release(7)).toBe(false)
+    expect(input.release(42)).toBe(true)
+    expect(moves).toHaveLength(1)
+    expect(moves[0]?.origin.toArray()).toEqual([1, 2, 3])
+    expect(releases).toBe(1)
+    expect(input.move(42, ray)).toBe(false)
+  })
+
+  test('cancels a captured handle without releasing it', () => {
+    const input = new SpatialPointerInput()
+    let cancels = 0
+    let releases = 0
+
+    input.capture(9, {
+      onMove: () => undefined,
+      onRelease: () => releases++,
+      onCancel: () => cancels++,
+    })
+
+    expect(input.cancel(9)).toBe(true)
+    expect(cancels).toBe(1)
+    expect(releases).toBe(0)
+  })
+
+  test('cleans up a replaced capture without letting its stale disposer clear the replacement', () => {
+    const input = new SpatialPointerInput()
+    const ray = new Ray(new Vector3(), new Vector3(0, 0, -1))
+    let replacements = 0
+    let replacementMoves = 0
+
+    const disposeOriginal = input.capture(12, {
+      onMove: () => undefined,
+      onRelease: () => undefined,
+      onCancel: () => undefined,
+      onReplace: () => replacements++,
+    })
+    input.capture(12, {
+      onMove: () => replacementMoves++,
+      onRelease: () => undefined,
+      onCancel: () => undefined,
+    })
+
+    expect(replacements).toBe(1)
+    disposeOriginal()
+    expect(input.move(12, ray)).toBe(true)
+    expect(replacementMoves).toBe(1)
+  })
+})

package/src/lib/spatial-pointer-input.ts

@@ -0,0 +1,62 @@
+import type { Ray } from 'three'
+
+type SpatialPointerCapture = {
+  onMove: (ray: Ray) => void
+  onRelease: () => void
+  onCancel: () => void
+  onReplace?: () => void
+}
+
+export type SpatialPointerId = object | number | string
+
+export function getSpatialPointerId(nativeEvent: unknown): SpatialPointerId | null {
+  if (!nativeEvent || typeof nativeEvent !== 'object') return null
+  const event = nativeEvent as {
+    inputSource?: object
+    pointerState?: { inputSource?: object }
+  }
+  return event.inputSource ?? event.pointerState?.inputSource ?? null
+}
+
+export class SpatialPointerInput {
+  private readonly captures = new Map<SpatialPointerId, SpatialPointerCapture>()
+
+  capture(pointerId: SpatialPointerId, capture: SpatialPointerCapture): () => void {
+    const previous = this.captures.get(pointerId)
+    if (previous && previous !== capture) {
+      this.captures.delete(pointerId)
+      ;(previous.onReplace ?? previous.onCancel)()
+    }
+    this.captures.set(pointerId, capture)
+    return () => {
+      if (this.captures.get(pointerId) === capture) {
+        this.captures.delete(pointerId)
+      }
+    }
+  }
+
+  move(pointerId: SpatialPointerId, ray: Ray): boolean {
+    const capture = this.captures.get(pointerId)
+    if (!capture) return false
+    capture.onMove(ray)
+    return true
+  }
+
+  release(pointerId: SpatialPointerId): boolean {
+    const capture = this.captures.get(pointerId)
+    if (!capture) return false
+    this.captures.delete(pointerId)
+    capture.onRelease()
+    return true
+  }
+
+  cancel(pointerId: SpatialPointerId): boolean {
+    const capture = this.captures.get(pointerId)
+    if (!capture) return false
+    this.captures.delete(pointerId)
+    capture.onCancel()
+    return true
+  }
+}
+
+export const spatialPointerInput = new SpatialPointerInput()

package/src/lib/spatial-snap.test.ts

@@ -0,0 +1,47 @@
+import { test } from 'bun:test'
+import assert from 'node:assert/strict'
+import { snapLocalXZInWorld } from '@pascal-app/core'
+import { Group, Vector3 } from 'three'
+
+const close = (a: number, b: number) => assert.ok(Math.abs(a - b) < 1e-8)
+
+test('free placement stays under the same hit through God-mode zoom and rotation', () => {
+  const pose = { position: [5, 0, -3] as [number, number, number], rotationY: 0.7 }
+  const world = new Group()
+  const building = new Group()
+  building.position.fromArray(pose.position)
+  building.rotation.y = pose.rotationY
+  world.add(building)
+  for (const scale of [0.01, 0.1, 1, 4]) {
+    world.scale.setScalar(scale)
+    world.position.set(8, 1, -4)
+    world.rotation.y = 1.2
+    world.updateWorldMatrix(true, true)
+    const hit = building.localToWorld(new Vector3(2, 0, -6))
+    const local = building.worldToLocal(hit.clone())
+    const snapped = snapLocalXZInWorld([local.x, local.z], pose, (value) => value)
+    const placed = building.localToWorld(new Vector3(snapped[0], 0, snapped[1]))
+    close(placed.distanceTo(hit), 0)
+  }
+})
+
+test('grid snapping still uses model units and the item footprint', () => {
+  const dimensions: number[] = []
+  const result = snapLocalXZInWorld([1.23, -2.16], null, (value, axis) => {
+    dimensions.push([1.8, 0.6][axis]!)
+    return Math.round(value / 0.1) * 0.1
+  })
+  close(result[0], 1.2)
+  close(result[1], -2.2)
+  assert.deepEqual(dimensions, [1.8, 0.6])
+})
+
+test('rotated buildings snap in model-world axes then return building-local coordinates', () => {
+  const result = snapLocalXZInWorld(
+    [1.2, 2.3],
+    { position: [10, 0, 20], rotationY: Math.PI / 2 },
+    Math.round,
+  )
+  close(result[0], 1)
+  close(result[1], 2)
+})

package/src/lib/terrain-panel-model.ts

@@ -0,0 +1,117 @@
+'use client'
+
+import { type SiteNode, type TerrainVerb, useScene } from '@pascal-app/core'
+import useEditor from '../store/use-editor'
+import type { PanelRow } from './panel-rows'
+import { brushRadiusRange, flattenSite, resetSiteTerrain } from './terrain-sculpt'
+
+const TERRAIN_VERBS: TerrainVerb[] = ['raise', 'lower', 'flatten', 'smooth']
+
+export function useTerrainPanelRows(): PanelRow[] {
+  const verb = useEditor((state) => state.terrainVerb)
+  const setVerb = useEditor((state) => state.setTerrainVerb)
+  const brush = useEditor((state) => state.terrainBrush)
+  const setBrush = useEditor((state) => state.setTerrainBrush)
+  const flattenTarget = useEditor((state) => state.terrainFlattenTarget)
+  const setFlattenTarget = useEditor((state) => state.setTerrainFlattenTarget)
+  const sampling = useEditor((state) => state.terrainSampling)
+  const setSampling = useEditor((state) => state.setTerrainSampling)
+  const site = useScene((state) => {
+    const root = state.rootNodeIds[0]
+    const node = root ? state.nodes[root] : undefined
+    return node?.type === 'site' ? (node as SiteNode) : null
+  })
+  const [minRadius, maxRadius] = brushRadiusRange(site)
+  const verbIndex = TERRAIN_VERBS.indexOf(verb)
+  const cycleVerb = (direction: -1 | 1) => {
+    const next =
+      TERRAIN_VERBS[(verbIndex + direction + TERRAIN_VERBS.length) % TERRAIN_VERBS.length]
+    if (next) setVerb(next)
+  }
+
+  const rows: PanelRow[] = [
+    {
+      id: 'terrain-verb',
+      kind: 'cycle',
+      label: 'Brush',
+      next: () => cycleVerb(1),
+      previous: () => cycleVerb(-1),
+      value: verb.charAt(0).toUpperCase() + verb.slice(1),
+    },
+    {
+      id: 'terrain-radius',
+      kind: 'stepper',
+      label: 'Size',
+      max: maxRadius,
+      min: minRadius,
+      onChange: (radius) => setBrush({ radius }),
+      step: 0.5,
+      unit: 'm',
+      value: Math.max(minRadius, Math.min(maxRadius, brush.radius)),
+    },
+    {
+      id: 'terrain-strength',
+      kind: 'stepper',
+      label: 'Strength',
+      max: 1,
+      min: 0.05,
+      onChange: (strength) => setBrush({ strength }),
+      step: 0.05,
+      value: brush.strength,
+    },
+    {
+      id: 'terrain-softness',
+      kind: 'stepper',
+      label: 'Softness',
+      max: 1,
+      min: 0,
+      onChange: (falloff) => setBrush({ falloff }),
+      step: 0.05,
+      value: brush.falloff,
+    },
+    {
+      id: 'terrain-shape',
+      kind: 'choice',
+      label: 'Shape',
+      onSelect: () => setBrush({ shape: brush.shape === 'round' ? 'square' : 'round' }),
+      value: brush.shape === 'round' ? 'Round' : 'Square',
+    },
+    ...(verb === 'flatten'
+      ? ([
+          {
+            id: 'terrain-target',
+            kind: 'stepper',
+            label: 'Target',
+            max: 50,
+            min: -50,
+            onChange: setFlattenTarget,
+            step: 0.1,
+            unit: 'm',
+            value: flattenTarget ?? 0,
+          },
+          {
+            id: 'terrain-sampling',
+            kind: 'choice',
+            label: 'Pick height',
+            onSelect: () => setSampling(!sampling),
+            value: sampling ? 'Armed' : 'Off',
+          },
+        ] satisfies PanelRow[])
+      : []),
+    {
+      id: 'terrain-level-lot',
+      kind: 'choice',
+      label: 'Whole lot',
+      onSelect: site ? () => flattenSite(site, flattenTarget ?? 0) : undefined,
+      value: 'Level',
+    },
+    {
+      id: 'terrain-clear',
+      kind: 'choice',
+      label: 'Terrain',
+      onSelect: site?.terrain ? () => resetSiteTerrain(site) : undefined,
+      value: site?.terrain ? 'Clear' : 'Empty',
+    },
+  ]
+  return rows
+}

package/src/lib/world-grid-snap.test.ts

@@ -0,0 +1,48 @@
+import { afterEach, describe, expect, test } from 'bun:test'
+import { BuildingNode, LevelNode, useScene } from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { getActiveBuildingId } from './world-grid-snap'
+
+const originalNodes = useScene.getState().nodes
+const originalSelection = useViewer.getState().selection
+
+afterEach(() => {
+  useScene.setState({ nodes: originalNodes } as never)
+  useViewer.setState({ selection: originalSelection } as never)
+})
+
+describe('getActiveBuildingId', () => {
+  test('prefers the active level owner over a stale selected building', () => {
+    const staleBuilding = BuildingNode.parse({})
+    const activeBuilding = BuildingNode.parse({})
+    const level = LevelNode.parse({ parentId: activeBuilding.id })
+    useScene.setState({
+      nodes: {
+        [staleBuilding.id]: staleBuilding,
+        [activeBuilding.id]: activeBuilding,
+        [level.id]: level,
+      },
+    } as never)
+    useViewer.setState({
+      selection: {
+        buildingId: staleBuilding.id,
+        levelId: level.id,
+        zoneId: null,
+        selectedIds: [],
+      },
+    } as never)
+
+    expect(getActiveBuildingId()).toBe(activeBuilding.id)
+  })
+
+  test('resolves legacy level ownership from the building children list', () => {
+    const level = LevelNode.parse({})
+    const building = BuildingNode.parse({ children: [level.id] })
+    useScene.setState({ nodes: { [building.id]: building, [level.id]: level } } as never)
+    useViewer.setState({
+      selection: { buildingId: null, levelId: level.id, zoneId: null, selectedIds: [] },
+    } as never)
+
+    expect(getActiveBuildingId()).toBe(building.id)
+  })
+})

package/src/lib/world-grid-snap.ts

@@ -15,6 +15,7 @@ import {
   type BuildingPose,
   type ResolveAlignmentInBuildingResult,
   resolveAlignmentInBuildingWorld,
+  resolveBuildingForLevel,
   snapWorldXZToBuildingLocal,
   useLiveTransforms,
   useScene,
@@ -39,7 +40,7 @@ import { useViewer } from '@pascal-app/viewer'
  * guides drift off the visible grid mid-drag (and through any post-drag
  * frame where the live override is still set).
  */
-export function getActiveBuildingPose(): BuildingPose | null {
+export function getActiveBuildingId(): AnyNodeId | null {
   const sel = useViewer.getState().selection
   const nodes = useScene.getState().nodes
   // Match `use-floorplan-scene-data.ts`: prefer the active level's
@@ -48,12 +49,15 @@ export function getActiveBuildingPose(): BuildingPose | null {
   // different level, the level path is the authoritative one.
   let buildingId: AnyNodeId | null = null
   if (sel.levelId) {
-    const level = nodes[sel.levelId]
-    if (level && level.type === 'level' && level.parentId) {
-      buildingId = level.parentId as AnyNodeId
-    }
+    buildingId = resolveBuildingForLevel(sel.levelId as AnyNodeId, nodes)
   }
   if (!buildingId) buildingId = sel.buildingId ?? null
+  return buildingId
+}
+
+export function getActiveBuildingPose(): BuildingPose | null {
+  const buildingId = getActiveBuildingId()
+  const nodes = useScene.getState().nodes
   const building = buildingId ? nodes[buildingId] : null
   if (building?.type !== 'building') return null
   const live = useLiveTransforms.getState().transforms.get(buildingId as string)

package/src/store/rotation-snapping.test.ts

@@ -0,0 +1,53 @@
+import { afterEach, expect, test } from 'bun:test'
+import { GROUP_ROTATE_DRAG_LABEL, ROTATE_HANDLE_DRAG_LABEL } from '../lib/contextual-help'
+import useEditor, {
+  getActiveSnapContext,
+  isAngleSnapActive,
+  normalizePersistedEditorLayoutState,
+} from './use-editor'
+import useInteractionScope from './use-interaction-scope'
+
+const initialEditor = useEditor.getState()
+const initialScope = useInteractionScope.getState()
+afterEach(() => {
+  useEditor.setState(initialEditor)
+  useInteractionScope.setState(initialScope)
+})
+
+for (const handle of [ROTATE_HANDLE_DRAG_LABEL, GROUP_ROTATE_DRAG_LABEL]) {
+  test(`${handle} reads and cycles the shared mode without changing placement modes`, () => {
+    useInteractionScope.getState().begin({ kind: 'handle-drag', nodeId: 'item_test', handle })
+    const placementModes = useEditor.getState().snappingModeByContext
+    expect(getActiveSnapContext()).toBe('rotation')
+    expect(isAngleSnapActive()).toBe(true)
+    expect(useEditor.getState().cycleSnappingMode()).toBe('off')
+    expect(isAngleSnapActive()).toBe(false)
+    expect(useEditor.getState().snappingModeByContext.wall).toBe(placementModes.wall)
+    expect(useEditor.getState().snappingModeByContext.item).toBe(placementModes.item)
+    expect(useEditor.getState().cycleSnappingMode()).toBe('angles')
+    expect(isAngleSnapActive()).toBe(true)
+  })
+}
+
+test('older persisted preferences receive the rotation default and retain other modes', () => {
+  const merged = normalizePersistedEditorLayoutState({
+    snappingModeByContext: { wall: 'off', item: 'lines', polygon: 'grid' },
+  })
+  expect(merged?.snappingModeByContext).toEqual({
+    wall: 'off',
+    item: 'lines',
+    polygon: 'grid',
+    rotation: 'angles',
+  })
+})
+
+test('persisted rotation mode is retained when valid and reset when invalid', () => {
+  expect(
+    normalizePersistedEditorLayoutState({ snappingModeByContext: { rotation: 'off' } })
+      .snappingModeByContext.rotation,
+  ).toBe('off')
+  expect(
+    normalizePersistedEditorLayoutState({ snappingModeByContext: { rotation: 'grid' } })
+      .snappingModeByContext.rotation,
+  ).toBe('angles')
+})

package/src/store/use-editor.tsx

@@ -570,6 +570,7 @@ export const DEFAULT_PERSISTED_EDITOR_LAYOUT_STATE: PersistedEditorLayoutState =
     wall: defaultSnappingModeFor('wall'),
     item: defaultSnappingModeFor('item'),
     polygon: defaultSnappingModeFor('polygon'),
+    rotation: defaultSnappingModeFor('rotation'),
   },
   continuationByContext: {
     wall: CONTINUATION_PROFILES.wall.default,
@@ -800,8 +801,14 @@ function normalizeContinuationByContext(
   }
 }
 
-function normalizePersistedEditorLayoutState(
-  state: (Partial<PersistedEditorLayoutState> & LegacyContinuationState) | null | undefined,
+export function normalizePersistedEditorLayoutState(
+  state:
+    | (Omit<Partial<PersistedEditorLayoutState>, 'snappingModeByContext'> &
+        LegacyContinuationState & {
+          snappingModeByContext?: Partial<Record<SnapContext, unknown>>
+        })
+    | null
+    | undefined,
 ): PersistedEditorLayoutState {
   return {
     activeSidebarPanel:
@@ -821,6 +828,7 @@ function normalizePersistedEditorLayoutState(
       wall: migrateSnappingMode(state?.snappingModeByContext?.wall, 'wall'),
       item: migrateSnappingMode(state?.snappingModeByContext?.item, 'item'),
       polygon: migrateSnappingMode(state?.snappingModeByContext?.polygon, 'polygon'),
+      rotation: migrateSnappingMode(state?.snappingModeByContext?.rotation, 'rotation'),
     },
     continuationByContext: normalizeContinuationByContext(state),
     showReferenceFloor: state?.showReferenceFloor === true,

package/src/store/use-floorplan-draft-preview.ts

@@ -40,6 +40,9 @@ type FloorplanDraftPreviewState = {
   wallDraftStart: WallPlanPoint | null
   fenceDraftStart: WallPlanPoint | null
   roofDraftStart: WallPlanPoint | null
+  /** First corner of an open rectangle-wall draft; the live cursor is the
+   *  opposite corner, so the rectangle tool publishes only per click. */
+  wallRectangleDraftStart: WallPlanPoint | null
   roofDraftQuarterTurn: boolean
   polygonDraftType: FloorplanPolygonDraftType | null
   polygonDraftPoints: WallPlanPoint[]
@@ -55,6 +58,7 @@ type FloorplanDraftPreviewState = {
   setWallDraftStart(point: WallPlanPoint | null): void
   setFenceDraftStart(point: WallPlanPoint | null): void
   setRoofDraftStart(point: WallPlanPoint | null): void
+  setWallRectangleDraftStart(point: WallPlanPoint | null): void
   setRoofDraftQuarterTurn(quarterTurn: boolean): void
   setPolygonDraft(type: FloorplanPolygonDraftType | null, points: readonly WallPlanPoint[]): void
   reset(): void
@@ -74,7 +78,8 @@ function setPlanPointField(
     | 'roofDraftEnd'
     | 'roofDraftStart'
     | 'wallDraftEnd'
-    | 'wallDraftStart',
+    | 'wallDraftStart'
+    | 'wallRectangleDraftStart',
   point: WallPlanPoint | null,
 ) {
   return (
@@ -96,6 +101,7 @@ export const useFloorplanDraftPreview = create<FloorplanDraftPreviewState>((set)
   wallDraftStart: null,
   fenceDraftStart: null,
   roofDraftStart: null,
+  wallRectangleDraftStart: null,
   roofDraftQuarterTurn: false,
   polygonDraftType: null,
   polygonDraftPoints: [],
@@ -119,6 +125,7 @@ export const useFloorplanDraftPreview = create<FloorplanDraftPreviewState>((set)
   setWallDraftStart: (point) => set(setPlanPointField('wallDraftStart', point)),
   setFenceDraftStart: (point) => set(setPlanPointField('fenceDraftStart', point)),
   setRoofDraftStart: (point) => set(setPlanPointField('roofDraftStart', point)),
+  setWallRectangleDraftStart: (point) => set(setPlanPointField('wallRectangleDraftStart', point)),
   setRoofDraftQuarterTurn: (quarterTurn) =>
     set((state) =>
       state.roofDraftQuarterTurn === quarterTurn ? state : { roofDraftQuarterTurn: quarterTurn },
@@ -139,6 +146,7 @@ export const useFloorplanDraftPreview = create<FloorplanDraftPreviewState>((set)
       state.wallDraftStart === null &&
       state.fenceDraftStart === null &&
       state.roofDraftStart === null &&
+      state.wallRectangleDraftStart === null &&
       state.roofDraftQuarterTurn === false &&
       state.polygonDraftType === null &&
       state.polygonDraftPoints.length === 0
@@ -152,6 +160,7 @@ export const useFloorplanDraftPreview = create<FloorplanDraftPreviewState>((set)
             wallDraftStart: null,
             fenceDraftStart: null,
             roofDraftStart: null,
+            wallRectangleDraftStart: null,
             roofDraftQuarterTurn: false,
             polygonDraftType: null,
             polygonDraftPoints: [],