@pascal-app/editor 1.0.3 → 1.0.4

package/src/components/editor/use-floorplan-background-placement.ts

@@ -16,12 +16,13 @@ import {
 import { resolveCeilingPlanPointSnap } from '../../lib/ceiling-plan-snap'
 import { alignFloorplanDraftPoint, getPlanPointDistance } from '../../lib/floorplan'
 import { resolveGenericFloorplanGridEventPoint } from '../../lib/floorplan-grid-event-point'
+import { snapRegisteredDraftPoint } from '../../lib/registered-draft-snap'
 import { resolveSlabPlanPointSnap } from '../../lib/slab-plan-snap'
+import { commitWallPolygonDraft, wallPolygonDraftWalls } from '../../lib/wall-polygon-draft'
 import useAlignmentGuides from '../../store/use-alignment-guides'
 import useEditor, { isAngleSnapActive, isMagneticSnapActive } from '../../store/use-editor'
 import usePlacementPreview from '../../store/use-placement-preview'
 import useSegmentDraftChain from '../../store/use-segment-draft-chain'
-import { snapFenceDraftPoint } from '../tools/fence/fence-drafting'
 import { getSegmentGridStep, type WallPlanPoint } from '../tools/wall/wall-drafting'
 
 const NOOP_SUBSCRIBE = () => () => {}
@@ -239,6 +240,18 @@ export function useFloorplanBackgroundPlacement({
         return true
       }
 
+      const fenceMode = useEditor.getState().getContinuation('fence')
+      if (isFenceBuildActive && useEditor.getState().toolDefaults.fence?.featurePlacement) {
+        clearFencePlacementDraft()
+        emitFloorplanGridEvent('click', planPoint, event)
+        return true
+      }
+      if (isFenceBuildActive && (fenceMode === 'curved' || fenceMode === 'freehand')) {
+        clearFencePlacementDraft()
+        if (fenceMode === 'curved') emitFloorplanGridEvent('click', planPoint, event)
+        return true
+      }
+
       if (isFenceBuildActive) {
         // Fence draft: mode-driven (matches the chip), same as the move
         // preview. `grid` snaps to the world XZ grid (rotation-safe via the
@@ -246,15 +259,19 @@ export function useFloorplanBackgroundPlacement({
         // pulls onto walls / fences / alignment, `off` is free.
         const fenceStep = getSegmentGridStep()
         const fenceAngleSnap = fenceDraftStart !== null && isAngleSnapActive()
-        const fenceSnapped = snapFenceDraftPoint({
-          point: planPoint,
-          walls,
-          fences,
-          start: fenceDraftStart ?? undefined,
-          angleSnap: fenceAngleSnap,
-          magnetic: isMagneticSnapActive(),
-          gridSnap: (p) => worldGridSnap(p, fenceStep),
-        })
+        const fenceSnapped = snapRegisteredDraftPoint(
+          'fence',
+          {
+            point: planPoint,
+            walls,
+            fences,
+            start: fenceDraftStart ?? undefined,
+            angleSnap: fenceAngleSnap,
+            magnetic: isMagneticSnapActive(),
+            gridSnap: (p: [number, number]) => worldGridSnap(p, fenceStep),
+          },
+          planPoint,
+        )
         const fenceGridBase = worldGridSnap(planPoint, fenceStep)
         const fenceLocked =
           fenceSnapped[0] !== fenceGridBase[0] || fenceSnapped[1] !== fenceGridBase[1]
@@ -352,7 +369,7 @@ export function useFloorplanBackgroundPlacement({
         const wallAngleSnap = draftStart !== null && isAngleSnapActive()
         const wallSnapped = snapWallDraftPoint({
           point: planPoint,
-          walls,
+          walls: [...walls, ...wallPolygonDraftWalls()],
           start: draftStart ?? undefined,
           angleSnap: wallAngleSnap,
           gridSnap: (p) => worldGridSnap(p, wallStep),
@@ -377,6 +394,9 @@ export function useFloorplanBackgroundPlacement({
         // 2D draft too — otherwise it stays open against a closed 3D tool
         // and the next previewed segment is silently never created.
         if (draftStart && event.detail >= 2) {
+          // …and keeps an open Polygon room (2D-only owns it; in split view the
+          // 3D tool already committed it on the same click).
+          commitWallPolygonDraft()
           clearWallPlacementDraft()
           setCursorPoint(snappedPoint)
           return true

package/src/components/editor/vector-edge-extractor.tsx

@@ -0,0 +1,121 @@
+/**
+ * The viewer's own lines for a sheet: answers `camera-controls:extract-edges`
+ * with the visible feature edges of the scene through an orthographic pose
+ * — the same pose the thumbnail generator captures the picture from — as
+ * world segments on a `pascal:edges` DOM event (lib/vector-edges.ts).
+ *
+ * Runs inside the Canvas next to the ThumbnailGenerator so it shares the
+ * renderer and the scene; hides what the picture hides (scan / guide /
+ * spawn, the caller's types, objects tagged `userData.excludeFromCapture`)
+ * for the length of the extraction.
+ */
+import { emitter } from '@pascal-app/core'
+import { GRID_LAYER, holdLiveFrame, temporarilyHideNodeTypes } from '@pascal-app/viewer'
+import { useThree } from '@react-three/fiber'
+import { useEffect } from 'react'
+import * as THREE from 'three'
+import { EDITOR_LAYER } from '../../lib/constants'
+import { extractVisibleEdges, type VisibleEdges } from '../../lib/vector-edges'
+import { hideCaptureExcluded } from './thumbnail-generator'
+
+export type ExtractEdgesRequest = {
+  /** Echoed on the `pascal:edges` event so a caller matches its own answer. */
+  requestId: string
+  ortho: { position: [number, number, number]; target: [number, number, number]; viewWidth: number }
+  /** width / height of the picture the edges go over. */
+  aspect: number
+  hideTypes?: readonly string[]
+  /** The depth pass' width in pixels (default 2048). */
+  width?: number
+  thresholdDeg?: number
+}
+
+export type ExtractEdgesResult = {
+  requestId: string
+  ok: boolean
+  segments?: Float32Array
+  count?: number
+  tested?: number
+  ms?: number
+}
+
+export function VectorEdgeExtractor() {
+  const gl = useThree((state) => state.gl)
+  const scene = useThree((state) => state.scene)
+
+  useEffect(() => {
+    const respond = (detail: ExtractEdgesResult) => {
+      window.dispatchEvent(new CustomEvent('pascal:edges', { detail }))
+    }
+    const handle = async (event: ExtractEdgesRequest) => {
+      if (!event?.ortho) return
+      // a background tab never finishes the passes' readbacks (the WebGL
+      // backend polls them on animation frames): say so at once
+      if (document.visibilityState === 'hidden') {
+        respond({ requestId: event.requestId, ok: false })
+        return
+      }
+      const camera = new THREE.OrthographicCamera(-1, 1, 1, -1, 0.1, 2000)
+      camera.layers.disable(EDITOR_LAYER)
+      camera.layers.disable(GRID_LAYER)
+      const halfW = event.ortho.viewWidth / 2
+      const halfH = halfW / Math.max(1e-6, event.aspect)
+      camera.position.set(event.ortho.position[0], event.ortho.position[1], event.ortho.position[2])
+      camera.up.set(0, 1, 0)
+      camera.lookAt(event.ortho.target[0], event.ortho.target[1], event.ortho.target[2])
+      camera.left = -halfW
+      camera.right = halfW
+      camera.top = halfH
+      camera.bottom = -halfH
+      camera.updateProjectionMatrix()
+      camera.updateMatrixWorld(true)
+      // the depth and normal passes put their override material on the shared
+      // scene across each GPU readback: the viewport keeps its last frame
+      // meanwhile, or it draws the house in them (black, then colours)
+      const releaseLiveFrame = holdLiveFrame()
+      const restoreTypes = temporarilyHideNodeTypes([
+        'scan',
+        'guide',
+        'spawn',
+        ...(event.hideTypes ?? []),
+      ])
+      const restoreExcluded = hideCaptureExcluded(scene)
+      let result: VisibleEdges | null = null
+      try {
+        result = await extractVisibleEdges(gl as unknown as THREE.WebGLRenderer, scene, camera, {
+          width: event.width,
+          thresholdDeg: event.thresholdDeg,
+        })
+      } catch (error) {
+        console.error('[vector-edges] extraction failed', error)
+      } finally {
+        restoreExcluded()
+        restoreTypes()
+        releaseLiveFrame()
+      }
+      if (process.env.NODE_ENV !== 'production') {
+        ;(window as unknown as { __pascalLastEdges?: unknown }).__pascalLastEdges = result
+      }
+      respond(
+        result
+          ? {
+              requestId: event.requestId,
+              ok: true,
+              segments: result.segments,
+              count: result.count,
+              tested: result.tested,
+              ms: result.ms,
+            }
+          : { requestId: event.requestId, ok: false },
+      )
+    }
+    const bus = emitter as unknown as {
+      on: (name: string, handler: (event: ExtractEdgesRequest) => void) => void
+      off: (name: string, handler: (event: ExtractEdgesRequest) => void) => void
+    }
+    bus.on('camera-controls:extract-edges', handle)
+    return () => bus.off('camera-controls:extract-edges', handle)
+  }, [gl, scene])
+
+  return null
+}

package/src/components/editor/views/host-view.tsx

@@ -0,0 +1,61 @@
+'use client'
+
+import type { LazyComponent } from '@pascal-app/core'
+import { type ComponentType, lazy, Suspense } from 'react'
+import type { EditorViewDescriptor } from '../../../lib/editor-views'
+import { ErrorBoundary } from '../../ui/primitives/error-boundary'
+
+// `React.lazy` once per loader, so a view keeps its identity across renders.
+const lazyViewCache = new WeakMap<LazyComponent, ComponentType>()
+
+function resolveViewComponent(component: LazyComponent): ComponentType {
+  const cached = lazyViewCache.get(component)
+  if (cached) return cached
+  const Lazy = lazy(component)
+  lazyViewCache.set(component, Lazy)
+  return Lazy
+}
+
+function ViewMessage({ title, body }: { title: string; body: string }) {
+  return (
+    <div className="flex h-full w-full items-center justify-center bg-sidebar p-6 text-center">
+      <div className="max-w-xs">
+        <p className="font-medium text-sidebar-foreground text-sm">{title}</p>
+        <p className="mt-1 text-sidebar-foreground/50 text-xs">{body}</p>
+      </div>
+    </div>
+  )
+}
+
+/**
+ * A registered view, loaded lazily and isolated: a view that throws is
+ * unloaded for the session and the rest of the editor keeps working. A layout
+ * can name a view this project cannot show — its plugin uninstalled, or not
+ * registered yet — and the pane says so rather than silently swapping views,
+ * so the choice comes back once the view does.
+ */
+export function HostView({ view }: { view: EditorViewDescriptor | undefined }) {
+  if (!view?.component) {
+    return (
+      <ViewMessage
+        body="Its plugin isn't installed in this project. Pick another view above."
+        title="This view isn't available"
+      />
+    )
+  }
+  const Component = resolveViewComponent(view.component)
+  return (
+    <ErrorBoundary
+      fallback={
+        <ViewMessage
+          body="This view hit an error and was unloaded for this session. Reload to try again."
+          title={`"${view.label}" crashed`}
+        />
+      }
+    >
+      <Suspense fallback={<ViewMessage body="" title="Loading…" />}>
+        <Component />
+      </Suspense>
+    </ErrorBoundary>
+  )
+}