@pascal-app/editor 1.0.1 → 1.0.4

package/src/components/tools/shared/pointer-support-cap.test.ts

@@ -19,6 +19,7 @@ import {
   MeshBasicMaterial,
   OrthographicCamera,
   PerspectiveCamera,
+  Ray,
   Vector3,
 } from 'three'
 import { z } from 'zod'
@@ -161,6 +162,32 @@ describe('resolvePointerSupportSurface node tops', () => {
     expect(support?.worldPoint).toEqual([0, 2, 0])
   })
 
+  test('XR floor drawing uses the controller ray even when the camera sees a raised surface', () => {
+    addPluginPlatform(2, [4, 2, 2])
+    const camera = new PerspectiveCamera()
+    camera.position.set(0, 5, 5)
+    camera.updateMatrixWorld(true)
+    const controllerRay = new Ray(new Vector3(0, 1.5, 0), new Vector3(0, -1, 0))
+    const desktop = resolvePointerSupportSurface(camera, [0, 0, 0], {
+      includeNodeTopSurfaces: true,
+    })
+    expect(desktop?.sourceNodeId).toBe(PLATFORM_ID)
+    const xr = resolvePointerSupportSurface(camera, [0, 0, 0], {
+      includeNodeTopSurfaces: true,
+      pointerRay: controllerRay,
+    })
+    expect(xr?.sourceNodeId).toBeNull()
+    expect(xr?.worldPoint).toEqual([0, 0, 0])
+    camera.position.set(12, 8, -10)
+    camera.updateMatrixWorld(true)
+    expect(
+      resolvePointerSupportSurface(camera, [0, 0, 0], {
+        includeNodeTopSurfaces: true,
+        pointerRay: controllerRay,
+      })?.worldPoint,
+    ).toEqual([0, 0, 0])
+  })
+
   test('keeps an unhovered item top above a batched slab across batch transitions', () => {
     const restoreRegistry = nodeRegistry._snapshot()
     const item = ItemNode.parse({

package/src/components/tools/shared/pointer-support-cap.ts

@@ -11,7 +11,7 @@ import {
   useScene,
 } from '@pascal-app/core'
 import { setSurfaceRaycastLayers, useViewer } from '@pascal-app/viewer'
-import { type Camera, type Object3D, Raycaster, Vector3 } from 'three'
+import { type Camera, type Object3D, type Ray, Raycaster, Vector3 } from 'three'
 import { resolveTerrainGroundHit } from '../../../lib/ground-surface'
 import { scopeNodeId } from '../../../lib/interaction/scope'
 import useInteractionScope from '../../../store/use-interaction-scope'
@@ -79,16 +79,22 @@ export type PointerSupportSurface = {
 export function resolvePointerSupportSurface(
   camera: Camera,
   worldHit: readonly [number, number, number],
-  options?: { includeNodeTopSurfaces?: boolean },
+  options?: { includeNodeTopSurfaces?: boolean; pointerRay?: Ray },
 ): PointerSupportSurface | null {
   const levelId = useViewer.getState().selection.levelId
   if (!levelId) return null
 
   // The world ray, kept before the level conversion below: the terrain field is
   // world-space (site geometry, not level-local), so the march needs this frame.
-  camera.getWorldPosition(worldRayOrigin)
+  if (options?.pointerRay) worldRayOrigin.copy(options.pointerRay.origin)
+  else camera.getWorldPosition(worldRayOrigin)
+  const isOrthographic =
+    !options?.pointerRay &&
+    (camera as Camera & { isOrthographicCamera?: boolean }).isOrthographicCamera === true
   const cameraToHit = hitScratch.set(worldHit[0], worldHit[1], worldHit[2]).sub(worldRayOrigin)
-  if ((camera as Camera & { isOrthographicCamera?: boolean }).isOrthographicCamera) {
+  if (options?.pointerRay) {
+    worldRayDirection.copy(options.pointerRay.direction).normalize()
+  } else if (isOrthographic) {
     // For an orthographic camera every screen pixel has the same direction. The
     // hit point is offset from the camera along the view plane, so using
     // `camera.position -> hit` tilts the ray toward the screen centre and makes
@@ -102,7 +108,13 @@ export function resolvePointerSupportSurface(
   }
 
   originScratch.copy(worldRayOrigin)
-  hitScratch.set(worldHit[0], worldHit[1], worldHit[2])
+  // Second world point defining the ray fed to the surface solve. In the plain
+  // perspective case `worldHit` already lies on the true pointer ray, so using
+  // it keeps `t === 1` (and the returned plan point exact) whenever the pointed
+  // surface IS the event plane — the pointer-ray and orthographic branches have
+  // no such hit, so they step one unit along the resolved direction.
+  if (options?.pointerRay || isOrthographic) hitScratch.copy(worldRayOrigin).add(worldRayDirection)
+  else hitScratch.set(worldHit[0], worldHit[1], worldHit[2])
   // Slab polygons/elevations live in the level frame; the level mesh
   // carries the storey Y offset and any building rotation.
   const levelMesh = sceneRegistry.nodes.get(levelId as AnyNodeId)

package/src/components/tools/shared/surface-rejection.test.tsx

@@ -3,12 +3,12 @@ import {
   type AnyNode,
   ItemNode,
   nodeRegistry,
-  registerNode,
   resolveSurfacePlacement,
   type SceneApi,
   type SurfaceProvider,
   type SurfaceRejectReason,
 } from '@pascal-app/core'
+import { registerHostingTestNode } from '../__fixtures__/hosting'
 import { createSurfaceRejectionFeedback } from './surface-rejection'
 
 let restore: () => void
@@ -27,7 +27,7 @@ for (const reason of [
   'no-surface',
   'invalid-hit',
 ] as const) {
-  test(`${reason} remains available from onReject without user-facing text`, () => {
+  test(`${reason}: eligible-host diagnostics remain available; ineligible hosts defer silently`, () => {
     const provider: SurfaceProvider = {
       childFrame: 'host-local',
       resolveHit: () =>
@@ -56,7 +56,7 @@ for (const reason of [
             },
       accepts: () => reason !== 'child-not-accepted',
     }
-    registerNode({
+    registerHostingTestNode({
       kind: 'test-host',
       schemaVersion: 1,
       schema: ItemNode,
@@ -75,6 +75,7 @@ for (const reason of [
           type: reason === 'host-not-eligible' ? 'guide' : 'test-host',
         } as unknown as AnyNode,
         childKind: 'item',
+        childId: 'item_existing',
         childFootprint: {
           size: reason === 'footprint-outside-surface' ? [3, 1, 3] : [0.3, 0.3, 0.3],
           rotationY: 0,
@@ -87,7 +88,7 @@ for (const reason of [
         onReject: (r) => feedback.reject(r),
       }),
     ).toBeNull()
-    expect(feedback.reason).toBe(reason)
+    expect(feedback.reason).toBe(reason === 'host-not-eligible' ? null : reason)
   })
 }
 

package/src/components/tools/shared/surface-rejection.tsx

@@ -27,3 +27,17 @@ export function createSurfaceRejectionFeedback(
     },
   }
 }
+
+// R3F reuses one native event across enter/move dispatch and bubbled ancestor hits.
+export function createSurfaceEventOwnership() {
+  const owners = new WeakMap<object, string>()
+  return {
+    allows(hostId: string, event: object) {
+      const owner = owners.get(event)
+      return owner === undefined || owner === hostId
+    },
+    claim(hostId: string, event: object) {
+      if (!owners.has(event)) owners.set(event, hostId)
+    },
+  }
+}

package/src/components/tools/site/site-boundary-editor.tsx

@@ -458,8 +458,7 @@ export const SiteBoundaryEditor: React.FC = () => {
 
   const exitSiteEditing = useCallback(() => {
     const editor = useEditor.getState()
-    editor.setPhase('structure')
-    editor.setStructureLayer('elements')
+    editor.setPhase('building')
     editor.setMode('select')
   }, [])
 

package/src/components/tools/stair/stair-defaults.ts

@@ -1,8 +1,5 @@
 export const DEFAULT_STAIR_TYPE = 'straight' as const
 export const DEFAULT_STAIR_WIDTH = 1.0
-export const DEFAULT_STAIR_LENGTH = 3.0
-export const DEFAULT_STAIR_HEIGHT = 2.5
-export const DEFAULT_STAIR_STEP_COUNT = 10
 export const DEFAULT_STAIR_ATTACHMENT_SIDE = 'front' as const
 export const DEFAULT_STAIR_FILL_TO_FLOOR = true
 export const DEFAULT_STAIR_THICKNESS = 0.25

package/src/components/tools/stair/stair-tool.tsx

@@ -1,7 +1,7 @@
 import {
   type AnyNode,
   collectAlignmentAnchors,
-  createDefaultStairSegment,
+  createSizedStairFlight,
   createSurfaceOpeningPreviewController,
   DEFAULT_LEVEL_HEIGHT,
   emitter,
@@ -11,6 +11,8 @@ import {
   type LevelNode,
   movingAlignmentAnchors,
   type NodeEvent,
+  planStairCreation,
+  planStairSizing,
   resolveAlignment,
   resolveFrozenFloorPlacementPatch,
   resolveSupportSlabPatch,
@@ -23,6 +25,7 @@ import { useViewer } from '@pascal-app/viewer'
 import { useThree } from '@react-three/fiber'
 import { useEffect, useMemo, useRef } from 'react'
 import * as THREE from 'three'
+import { EDITOR_LAYER } from '../../../lib/constants'
 import { sfxEmitter } from '../../../lib/sfx-bus'
 import {
   resolveStairDestinationLevel,
@@ -54,11 +57,9 @@ import {
   DEFAULT_SPIRAL_TOP_LANDING_MODE,
   DEFAULT_STAIR_ATTACHMENT_SIDE,
   DEFAULT_STAIR_FILL_TO_FLOOR,
-  DEFAULT_STAIR_LENGTH,
   DEFAULT_STAIR_OPENING_OFFSET,
   DEFAULT_STAIR_RAILING_HEIGHT,
   DEFAULT_STAIR_RAILING_MODE,
-  DEFAULT_STAIR_STEP_COUNT,
   DEFAULT_STAIR_THICKNESS,
   DEFAULT_STAIR_TYPE,
   DEFAULT_STAIR_WIDTH,
@@ -75,19 +76,18 @@ type MoveTriggerEvent = GridEvent | NodeEvent<AnyNode>
  * Same algorithm as StairSystem's generateStairSegmentGeometry.
  */
 function createStairPreviewGeometry(rise: number): THREE.BufferGeometry {
-  const riserHeight = rise / DEFAULT_STAIR_STEP_COUNT
-  const treadDepth = DEFAULT_STAIR_LENGTH / DEFAULT_STAIR_STEP_COUNT
+  const { stepCount, length, riserHeight, going: treadDepth } = planStairSizing(rise)
 
   const shape = new THREE.Shape()
   shape.moveTo(0, 0)
 
-  for (let i = 0; i < DEFAULT_STAIR_STEP_COUNT; i++) {
+  for (let i = 0; i < stepCount; i++) {
     shape.lineTo(i * treadDepth, (i + 1) * riserHeight)
     shape.lineTo((i + 1) * treadDepth, (i + 1) * riserHeight)
   }
 
   // Fill to floor (absoluteHeight = 0)
-  shape.lineTo(DEFAULT_STAIR_LENGTH, 0)
+  shape.lineTo(length, 0)
   shape.lineTo(0, 0)
 
   const geometry = new THREE.ExtrudeGeometry(shape, {
@@ -110,33 +110,28 @@ function createStairPreviewGeometry(rise: number): THREE.BufferGeometry {
  * dropped on, not a constant: the placed stair has no explicit `totalRise`, so
  * this is the height `syncStairRises` immediately converges it to anyway.
  */
-function resolvePlacedStairRise(
+function resolvePlacedStairBase(
   nodes: Record<string, AnyNode>,
   levelId: LevelNode['id'],
   stair: StairNode,
   supportSurface: PointerSupportSurface | null,
+  seed: StairSegmentNode,
 ): number {
-  // Same contract as `resolveStairTotalRise` for a stair that is not in the
-  // scene yet: the storey height minus whatever slab lifts the drop point,
-  // capped by the surface the pointer actually aims at (a floor under an
-  // overlapping deck must not elect the deck).
+  // Keep the pointer-selected base when an overlapping deck is above the cursor.
   const base = getFloorStackedPosition({
     node: stair,
-    nodes,
+    nodes: { ...nodes, [seed.id]: { ...seed, parentId: stair.id } },
     position: stair.position,
     rotation: stair.rotation,
     levelId,
     maxElevation: supportSurface?.elevation ?? null,
   })[1]
-  return getLevelFloorToFloorHeight(levelId, nodes) - base
+  return base
 }
 
 function createSeedStairSegment(rise: number) {
-  return createDefaultStairSegment({
+  return createSizedStairFlight(rise, {
     width: DEFAULT_STAIR_WIDTH,
-    length: DEFAULT_STAIR_LENGTH,
-    height: rise,
-    stepCount: DEFAULT_STAIR_STEP_COUNT,
     attachmentSide: DEFAULT_STAIR_ATTACHMENT_SIDE,
     fillToFloor: DEFAULT_STAIR_FILL_TO_FLOOR,
     thickness: DEFAULT_STAIR_THICKNESS,
@@ -160,15 +155,16 @@ function createDefaultStairNode({
 }) {
   return StairNode.parse({
     name,
+    parentId: levelId,
     position,
     rotation,
     stairType: DEFAULT_STAIR_TYPE,
+    uniformRisers: true,
     fromLevelId: levelId,
     toLevelId: nextLevelId,
     slabOpeningMode: 'destination',
     openingOffset: DEFAULT_STAIR_OPENING_OFFSET,
     width: DEFAULT_STAIR_WIDTH,
-    stepCount: DEFAULT_STAIR_STEP_COUNT,
     thickness: DEFAULT_STAIR_THICKNESS,
     fillToFloor: DEFAULT_STAIR_FILL_TO_FLOOR,
     innerRadius: DEFAULT_CURVED_STAIR_INNER_RADIUS,
@@ -202,7 +198,9 @@ function commitStairPlacement(
 
   const stairCount = Object.values(nodes).filter((n) => n.type === 'stair').length
   const name = `Staircase ${stairCount + 1}`
-  const seed = createSeedStairSegment(getLevelFloorToFloorHeight(placementLevelId, nodes))
+  const storeyRise = getLevelFloorToFloorHeight(placementLevelId, nodes)
+  if (!(storeyRise > 0)) return
+  const seed = createSeedStairSegment(storeyRise)
 
   const destinationPlan = resolveStairDestinationLevel({
     createMissing: true,
@@ -222,10 +220,28 @@ function commitStairPlacement(
     }),
     parentId: placementLevelId,
   })
-  const segment = {
-    ...seed,
-    height: resolvePlacedStairRise(nodes, placementLevelId, stair, supportSurface),
+  const base = resolvePlacedStairBase(nodes, placementLevelId, stair, supportSurface, seed)
+  let segment: StairSegmentNode
+  try {
+    segment = {
+      ...planStairCreation(
+        stair,
+        nodes,
+        {
+          width: seed.width,
+          attachmentSide: seed.attachmentSide,
+          fillToFloor: seed.fillToFloor,
+          thickness: seed.thickness,
+        },
+        base,
+      ).flight,
+      id: seed.id,
+    }
+  } catch (error) {
+    if (error instanceof RangeError) return
+    throw error
   }
+  stair.stepCount = segment.stepCount
   const prospectiveNodes = {
     ...nodes,
     [stair.id]: stair,
@@ -270,6 +286,7 @@ export const StairTool: React.FC = () => {
   cameraRef.current = camera
   const cursorRef = useRef<THREE.Group>(null)
   const previewRef = useRef<THREE.Group>(null)
+  const previewMeshRef = useRef<THREE.Mesh>(null)
   const rotationRef = useRef(0)
   const supportSurfaceRef = useRef<PointerSupportSurface | null>(null)
   const previousGridPosRef = useRef<[number, number] | null>(null)
@@ -281,8 +298,10 @@ export const StairTool: React.FC = () => {
   )
   const previewRiseRef = useRef(previewRise)
   previewRiseRef.current = previewRise
-  const previewGeometry = useMemo(() => createStairPreviewGeometry(previewRise), [previewRise])
-  useEffect(() => () => previewGeometry.dispose(), [previewGeometry])
+  const previewGeometry = useMemo(() => createStairPreviewGeometry(DEFAULT_LEVEL_HEIGHT), [])
+  const ownedGeometryRef = useRef(previewGeometry)
+  const geometryRiseRef = useRef(DEFAULT_LEVEL_HEIGHT)
+  useEffect(() => () => ownedGeometryRef.current.dispose(), [])
 
   useEffect(() => {
     if (!currentLevelId) return
@@ -321,7 +340,9 @@ export const StairTool: React.FC = () => {
         nodes,
       })
       const nextLevelId = destinationPlan?.toLevel.id ?? placementLevelId
-      const seed = createSeedStairSegment(getLevelFloorToFloorHeight(placementLevelId, nodes))
+      const storeyRise = getLevelFloorToFloorHeight(placementLevelId, nodes)
+      if (!(storeyRise > 0)) return null
+      const seed = createSeedStairSegment(storeyRise)
       const stair = createDefaultStairNode({
         name: 'Staircase Preview',
         levelId: placementLevelId,
@@ -330,10 +351,28 @@ export const StairTool: React.FC = () => {
         rotation,
         segmentId: seed.id,
       })
-      const segment = {
-        ...seed,
-        height: resolvePlacedStairRise(nodes, placementLevelId, stair, supportSurface),
+      const base = resolvePlacedStairBase(nodes, placementLevelId, stair, supportSurface, seed)
+      let segment: StairSegmentNode
+      try {
+        segment = {
+          ...planStairCreation(
+            stair,
+            nodes,
+            {
+              width: seed.width,
+              attachmentSide: seed.attachmentSide,
+              fillToFloor: seed.fillToFloor,
+              thickness: seed.thickness,
+            },
+            base,
+          ).flight,
+          id: seed.id,
+        }
+      } catch (error) {
+        if (error instanceof RangeError) return null
+        throw error
       }
+      stair.stepCount = segment.stepCount
       const previewNodes = {
         ...nodes,
         ...(destinationPlan?.createdLevel
@@ -360,11 +399,13 @@ export const StairTool: React.FC = () => {
       rotation: number,
       supportSurface: PointerSupportSurface | null,
     ) => {
-      const key = `${position[0].toFixed(3)},${position[2].toFixed(3)},${rotation.toFixed(4)},${supportSurface?.elevation.toFixed(3) ?? 'none'},${supportSurface?.sourceNodeId ?? 'floor'}`
+      const key = `${position[0].toFixed(3)},${position[2].toFixed(3)},${rotation.toFixed(4)},${supportSurface?.elevation.toFixed(3) ?? 'none'},${supportSurface?.sourceNodeId ?? 'floor'},${previewRiseRef.current}`
       if (key === lastPreviewKey) return
       lastPreviewKey = key
-      useStairBuildPreview.getState().setPreview([position[0], position[2]], rotation)
       const preview = buildPreviewScene(position, rotation, supportSurface)
+      useStairBuildPreview
+        .getState()
+        .setPreview(preview ? [position[0], position[2]] : null, rotation, preview?.rise ?? null)
       const frozenPatch =
         preview && supportSurface?.sourceNodeId
           ? resolveFrozenFloorPlacementPatch(preview.stair, preview.previewNodes, {
@@ -398,11 +439,17 @@ export const StairTool: React.FC = () => {
       }
 
       if (previewRef.current) {
+        previewRef.current.visible = Boolean(preview)
         previewRef.current.position.set(...visualPosition)
         previewRef.current.rotation.y = rotation
-        // The ghost geometry is built for the storey height; squash it to the
-        // rise the placed flight will get on this surface.
-        previewRef.current.scale.y = preview ? preview.rise / previewRiseRef.current : 1
+        if (preview && previewMeshRef.current && preview.rise !== geometryRiseRef.current) {
+          const previous = previewMeshRef.current.geometry
+          previewMeshRef.current.geometry = createStairPreviewGeometry(preview.rise)
+          previous.dispose()
+          ownedGeometryRef.current = previewMeshRef.current.geometry
+          geometryRiseRef.current = preview.rise
+        }
+        previewRef.current.scale.y = 1
       }
 
       // Forward-facing triangle (editor-side overlay). The run ascends along
@@ -410,19 +457,20 @@ export const StairTool: React.FC = () => {
       // so `reversed` points the triangle out of the entry (where you approach
       // from), sitting just before it — not inside the footprint or at the
       // elevated far end. Centre is the footprint mid-run (origin is the entry).
+      if (!preview) {
+        useFacingPose.getState().clear()
+        openingPreview.clear()
+        return
+      }
+      const sizing = planStairSizing(preview.rise)
       useFacingPose.getState().set({
         position: visualPosition,
         rotationY: rotation,
-        depth: DEFAULT_STAIR_LENGTH,
-        center: [0, DEFAULT_STAIR_LENGTH / 2],
+        depth: sizing.length,
+        center: [0, sizing.length / 2],
         reversed: true,
       })
 
-      if (!preview) {
-        openingPreview.clear()
-        return
-      }
-
       openingPreview.apply(syncAutoStairOpenings(preview.previewNodes))
     }
 
@@ -625,7 +673,7 @@ export const StairTool: React.FC = () => {
           forward-facing triangle is drawn by the editor-side overlay from the
           pose published in `applyDraftPreview`. */}
       <group ref={previewRef}>
-        <mesh castShadow geometry={previewGeometry}>
+        <mesh dispose={null} geometry={previewGeometry} layers={EDITOR_LAYER} ref={previewMeshRef}>
           <meshStandardMaterial color="#818cf8" depthWrite={false} opacity={0.35} transparent />
         </mesh>
       </group>