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

package/src/components/tools/item/use-placement-coordinator.tsx

@@ -295,6 +295,7 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
   const { canPlaceOnFloor, canPlaceOnWall, canPlaceOnCeiling } = useSpatialQuery()
   const { asset, draftNode } = config
   const unit = useViewer((state) => state.unit)
+  const metricNotation = useViewer((state) => state.metricNotation)
   const gridSnapStep = useEditor((s) => s.gridSnapStep)
   const updatePreviewGeometry = useCallback((bounds: PreviewBounds) => {
     const [width, height, depth] = bounds.dimensions
@@ -1129,19 +1130,9 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
         }
         const correctedX = wallDragAnchor.startX + (rawX - wallDragAnchor.rawX)
         const correctedY = wallDragAnchor.startY + (rawY - wallDragAnchor.rawY)
-        const wallMesh = sceneRegistry.nodes.get(event.node.id)
-        // Derive the world cursor from the corrected wall-local point so the
-        // visual cursor (world) and the stored position (wall-local) agree; if
-        // the wall mesh is somehow absent, keep the raw world hit unchanged.
-        const correctedWorld = wallMesh
-          ? wallMesh.localToWorld(new Vector3(correctedX, correctedY, event.localPosition[2]))
-          : null
         wallMoveEvent = {
           ...event,
           localPosition: [correctedX, correctedY, event.localPosition[2]],
-          position: correctedWorld
-            ? [correctedWorld.x, correctedWorld.y, correctedWorld.z]
-            : event.position,
         }
       }
       const result = wallStrategy.move(ctx, wallMoveEvent, getActiveValidators())
@@ -1203,22 +1194,11 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
 
         // Publish live transform for the 2D floorplan. The floorplan resolves a
         // wall item's footprint (and its wall-side depth offset) from this
-        // rotation as a PLAN-space yaw. `cursorRotationY` is the 3D world cursor
-        // yaw, which is π off from the plan rotation on a wall face — feeding it
-        // raw flips the footprint to the far side of the wall during placement.
-        // Publish the plan rotation (wall angle + the item's wall-local yaw) so
-        // the preview matches what the committed node resolves to.
-        let liveRotation = result.cursorRotationY
-        const liveWallId = placementState.current.wallId
-        const liveWall = liveWallId ? useScene.getState().nodes[liveWallId as AnyNodeId] : undefined
-        if (liveWall?.type === 'wall') {
-          const w = liveWall as WallNode
-          const wallPlanRotation = -Math.atan2(w.end[1] - w.start[1], w.end[0] - w.start[0])
-          liveRotation = wallPlanRotation + (draft.rotation[1] ?? 0)
-        }
+        // rotation as a PLAN-space yaw — which is exactly what the wall strategy
+        // composes `cursorRotationY` as (wall yaw + the item's wall-local yaw).
         useLiveTransforms.getState().set(draft.id, {
           position: result.cursorPosition,
-          rotation: liveRotation,
+          rotation: result.cursorRotationY,
         })
       }
     }
@@ -2558,9 +2538,21 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
     depth: currentDimensionBounds.dimensions[2],
     center: [currentDimensionBounds.center[0], currentDimensionBounds.center[2]],
   }
-  const widthLabel = formatLinearMeasurement(currentDimensionBounds.dimensions[0], unit)
-  const depthLabel = formatLinearMeasurement(currentDimensionBounds.dimensions[2], unit)
-  const heightLabel = formatLinearMeasurement(currentDimensionBounds.dimensions[1], unit)
+  const widthLabel = formatLinearMeasurement(
+    currentDimensionBounds.dimensions[0],
+    unit,
+    metricNotation,
+  )
+  const depthLabel = formatLinearMeasurement(
+    currentDimensionBounds.dimensions[2],
+    unit,
+    metricNotation,
+  )
+  const heightLabel = formatLinearMeasurement(
+    currentDimensionBounds.dimensions[1],
+    unit,
+    metricNotation,
+  )
   const widthLabelPosition: [number, number, number] = [
     currentDimensionBounds.center[0],
     0.04,

package/src/components/tools/shared/placement-box.tsx

@@ -8,7 +8,11 @@ import { PlaneGeometry } from 'three'
 import { distance, smoothstep, uv, vec2 } from 'three/tsl'
 import { LineBasicNodeMaterial, MeshBasicNodeMaterial } from 'three/webgpu'
 import { EDITOR_LAYER } from '../../../lib/constants'
-import { formatLinearMeasurement, type LinearUnit } from '../../../lib/measurements'
+import {
+  formatLinearMeasurement,
+  type LinearUnit,
+  type MetricNotation,
+} from '../../../lib/measurements'
 import { createLineGeometry, getBoxEdgePoints } from './placement-box-geometry'
 
 const VALID_COLOR = 0x22_c5_5e // green-500
@@ -17,6 +21,7 @@ const MEASUREMENT_COLOR = 0x0f_17_2a
 
 type PlacementBoxMeasurements = {
   unit: LinearUnit
+  metricNotation?: MetricNotation
 }
 
 function getMeasurementGuidePoints(width: number, height: number, depth: number) {
@@ -271,15 +276,15 @@ export function PlacementBox({
         renderOrder={998}
       />
       <MeasurementPill
-        label={formatLinearMeasurement(width, measurements.unit)}
+        label={formatLinearMeasurement(width, measurements.unit, measurements.metricNotation)}
         position={[0, 0.04, depth / 2 + 0.24]}
       />
       <MeasurementPill
-        label={formatLinearMeasurement(depth, measurements.unit)}
+        label={formatLinearMeasurement(depth, measurements.unit, measurements.metricNotation)}
         position={[width / 2 + 0.24, 0.04, 0]}
       />
       <MeasurementPill
-        label={formatLinearMeasurement(height, measurements.unit)}
+        label={formatLinearMeasurement(height, measurements.unit, measurements.metricNotation)}
         position={[-width / 2 - 0.24, height / 2, -depth / 2]}
       />
     </>

package/src/components/tools/site/terrain-brush-cursor.tsx

@@ -79,6 +79,7 @@ export const TerrainBrushCursor: React.FC<{
   const sampling = useEditor((state) => state.terrainSampling)
   const color = brushRingColor(verb, sampling)
   const unit = useViewer((state) => state.unit)
+  const metricNotation = useViewer((state) => state.metricNotation)
 
   const lineRef = useRef<Line>(null)
   const centerRef = useRef<Group>(null)
@@ -195,7 +196,7 @@ export const TerrainBrushCursor: React.FC<{
 
     const centerHeight = surfaceHeightAt(surface, hit.x, hit.z)
     center.position.set(hit.x, centerHeight + RING_LIFT, hit.z)
-    const heightLabel = `H ${formatMeasurement(centerHeight, unit)}`
+    const heightLabel = `H ${formatMeasurement(centerHeight, unit, metricNotation)}`
     if (heightRef.current) {
       heightRef.current.style.display = ''
       if (heightLabel !== lastHeightLabelRef.current) {

package/src/components/tools/wall/wall-drafting.test.ts

@@ -3,12 +3,15 @@ import {
   type AnyNode,
   type AnyNodeId,
   applyHeightPatch,
+  CeilingNode,
   createTerrainField,
   DoorNode as DoorSchema,
   encodeTerrainField,
   flattenPatch,
   GROUND_SUPPORT_ID,
+  initSpaceDetectionSync,
   runAsSingleSceneHistoryStep,
+  SlabNode,
   spatialGridManager,
   useScene,
   type WallNode,
@@ -56,7 +59,7 @@ function seedLevel(walls: WallNode[], extraNodes: AnyNode[] = []) {
           parentId: null,
           visible: true,
           metadata: {},
-          children: walls.map((wall) => wall.id),
+          children: [...walls.map((wall) => wall.id), ...extraNodes.map((node) => node.id)],
           level: 0,
         } as AnyNode,
       ],
@@ -69,6 +72,66 @@ function seedLevel(walls: WallNode[], extraNodes: AnyNode[] = []) {
   } as never)
 }
 
+// Seeds a site/building/level chain whose terrain field carries a sculpted
+// patch raised to `liftTo` in the far corner — enough for ground drafts to be
+// terrain chains, while the walls under test stand where the ground is 0.
+function seedTerrainLevel(walls: WallNode[], liftTo: number) {
+  const field = createTerrainField({ cols: 9, rows: 9, spacing: 1, origin: [-4, -4] })
+  const patch = flattenPatch(field, { maxX: -2, maxZ: -2, minX: -4, minZ: -4 }, liftTo)
+  if (!patch) throw new Error('Expected terrain patch')
+  const terrain = applyHeightPatch(field, patch)
+  useScene.setState({
+    nodes: Object.fromEntries([
+      [
+        'site_test',
+        {
+          id: 'site_test',
+          type: 'site',
+          object: 'node',
+          parentId: null,
+          visible: true,
+          metadata: {},
+          children: ['building_test'],
+          terrain: encodeTerrainField(terrain),
+        } as unknown as AnyNode,
+      ],
+      [
+        'building_test',
+        {
+          id: 'building_test',
+          type: 'building',
+          object: 'node',
+          parentId: 'site_test',
+          visible: true,
+          metadata: {},
+          children: [LEVEL_ID],
+          position: [0, 0, 0],
+          rotation: [0, 0, 0],
+        } as AnyNode,
+      ],
+      [
+        LEVEL_ID,
+        {
+          id: LEVEL_ID,
+          type: 'level',
+          object: 'node',
+          parentId: 'building_test',
+          visible: true,
+          metadata: {},
+          children: walls.map((wall) => wall.id),
+          level: 0,
+          baseElevation: 0,
+          height: 2.5,
+        } as AnyNode,
+      ],
+      ...walls.map((wall) => [wall.id, wall] as const),
+    ]),
+    rootNodeIds: ['site_test' as AnyNodeId],
+    dirtyNodes: new Set(),
+    collections: {},
+  } as never)
+}
+
 function levelWalls(): WallNode[] {
   return Object.values(useScene.getState().nodes).filter(
     (node): node is WallNode => node?.type === 'wall',
@@ -109,7 +172,9 @@ describe('createWallOnCurrentLevel', () => {
     expect(levelWalls()).toHaveLength(2)
   })
 
-  test('committed wall preserves the ghost construction elevation on ground', () => {
+  test('committed wall preserves the ghost construction elevation on terrain', () => {
+    seedTerrainLevel([makeWall([0, 0], [4, 0], 'wall_a')], 1.75)
+
     const created = createWallOnCurrentLevel([2, 2], [3, 2], {
       supportCap: 1.75,
       preferredSupportSlabId: GROUND_SUPPORT_ID,
@@ -133,6 +198,69 @@ describe('createWallOnCurrentLevel', () => {
     expect(support.elevation).toBe(1.75)
   })
 
+  test('a flat-ground draft (no sculpted terrain) commits plane-bound', () => {
+    // Pointing at bare ground freezes a GROUND construction plane at 0. With
+    // no terrain field in the scene that plane is just the backdrop — none of
+    // the draft options may reach the committed node: no stamped height, no
+    // persisted ground host (a slab drawn later must lift the wall), no
+    // election cap.
+    const created = createWallOnCurrentLevel([2, 2], [3, 2], {
+      supportCap: 0,
+      preferredSupportSlabId: GROUND_SUPPORT_ID,
+      constructionElevation: 0,
+      constructionHeight: 2.5,
+    })
+
+    expect(created).not.toBeNull()
+    expect(created?.height).toBeUndefined()
+    expect(created?.supportOffset).toBeUndefined()
+    expect(created?.supportSlabId).toBeUndefined()
+  })
+
+  test('a wall started on a slab stays plane-bound (no stamped height or offset)', () => {
+    const slab = SlabNode.parse({
+      id: 'slab_floor',
+      parentId: LEVEL_ID,
+      polygon: [
+        [-1, -1],
+        [5, -1],
+        [5, 5],
+        [-1, 5],
+      ],
+      elevation: 0.05,
+      thickness: 0.05,
+    })
+    seedLevel([makeWall([0, 0], [4, 0], 'wall_a')], [slab])
+
+    // Mirrors the 3D tool's first click on the slab top: frozen plane at the
+    // slab elevation, ghost drawn at the level height. None of it may reach
+    // the committed node — plane-bound is the default.
+    const created = createWallOnCurrentLevel([2, 2], [3, 2], {
+      supportCap: 0.05,
+      preferredSupportSlabId: slab.id,
+      constructionElevation: 0.05,
+      constructionHeight: 2.55,
+    })
+
+    expect(created).not.toBeNull()
+    expect(created?.height).toBeUndefined()
+    expect(created?.supportOffset).toBeUndefined()
+    expect(created?.supportSlabId).not.toBe(GROUND_SUPPORT_ID)
+  })
+
+  test('a non-ground draft never freezes the ghost height, even at a raised plane', () => {
+    const created = createWallOnCurrentLevel([2, 2], [3, 2], {
+      supportCap: 1.2,
+      preferredSupportSlabId: null,
+      constructionElevation: 1.2,
+      constructionHeight: 2.5,
+    })
+
+    expect(created).not.toBeNull()
+    expect(created?.height).toBeUndefined()
+    expect(created?.supportOffset).toBeUndefined()
+  })
+
   test('2D terrain construction options freeze the first-point elevation and wall height', () => {
     const field = createTerrainField({ cols: 5, rows: 5, spacing: 1, origin: [-2, -2] })
     const patch = flattenPatch(field, { minX: -2, minZ: -2, maxX: 2, maxZ: 2 }, 1.5)
@@ -168,6 +296,7 @@ describe('createWallOnCurrentLevel', () => {
       metadata: {},
       children: [],
       level: 0,
+      baseElevation: 0,
       height: 3,
     } as AnyNode
     const nodes = Object.fromEntries([site, building, level].map((node) => [node.id, node]))
@@ -261,6 +390,82 @@ describe('createWallOnCurrentLevel', () => {
     expect(created).not.toBeNull()
     expect(useScene.temporal.getState().pastStates.length - before).toBe(1)
   })
+
+  test('a crossing splits both the host and the inserted wall in one undo step', () => {
+    const before = useScene.temporal.getState().pastStates.length
+
+    const created = createWallOnCurrentLevel([2, -2], [2, 2])
+
+    expect(created?.start).toEqual([2, 0])
+    expect(created?.end).toEqual([2, 2])
+    expect(useScene.getState().nodes['wall_a' as AnyNodeId]).toBeUndefined()
+    expect(levelWalls()).toHaveLength(4)
+    expect(useScene.temporal.getState().pastStates.length - before).toBe(1)
+  })
+
+  test('a room divider splits customized auto slabs and ceilings', () => {
+    const walls = [
+      makeWall([0, 0], [8, 0], 'wall_bottom'),
+      makeWall([8, 0], [8, 6], 'wall_right'),
+      makeWall([8, 6], [0, 6], 'wall_top'),
+      makeWall([0, 6], [0, 0], 'wall_left'),
+    ]
+    const slab = SlabNode.parse({
+      id: 'slab_auto',
+      parentId: LEVEL_ID,
+      polygon: [
+        [0, 0],
+        [8, 0],
+        [8, 6],
+        [0, 6],
+      ],
+      elevation: 0.18,
+      thickness: 0.32,
+      autoFromWalls: true,
+    })
+    const ceiling = CeilingNode.parse({
+      id: 'ceiling_auto',
+      parentId: LEVEL_ID,
+      polygon: slab.polygon,
+      autoFromWalls: true,
+    })
+    seedLevel(walls, [slab, ceiling])
+    const stopDetection = initSpaceDetectionSync(useScene, useEditor)
+
+    try {
+      expect(createWallOnCurrentLevel([4, 0], [4, 6])).not.toBeNull()
+
+      const nodes = Object.values(useScene.getState().nodes)
+      const slabs = nodes.filter((node) => node.type === 'slab')
+      const ceilings = nodes.filter((node) => node.type === 'ceiling')
+      expect(slabs).toHaveLength(2)
+      expect(ceilings).toHaveLength(2)
+      expect(
+        slabs.every(
+          (node) => node.autoFromWalls && node.elevation === 0.18 && node.thickness === 0.32,
+        ),
+      ).toBe(true)
+      expect(ceilings.every((node) => node.autoFromWalls)).toBe(true)
+    } finally {
+      stopDetection()
+    }
+  })
+
+  test('close crossings reject the whole insertion without mutating the scene', () => {
+    seedLevel([
+      makeWall([2, -2], [2, 2], 'wall_close_a'),
+      makeWall([2.0055, -2], [2.0055, 2], 'wall_close_b'),
+    ])
+    useScene.temporal.getState().clear()
+    const beforeNodes = useScene.getState().nodes
+
+    const created = createWallOnCurrentLevel([0, 0], [4, 0])
+
+    expect(created).toBeNull()
+    expect(useScene.getState().nodes).toBe(beforeNodes)
+    expect(levelWalls()).toHaveLength(2)
+    expect(useScene.temporal.getState().pastStates).toHaveLength(0)
+  })
 })
 
 describe('resolveEndpointWallSplit', () => {