@pascal-app/editor 1.0.3 → 1.0.5

package/src/lib/floor-opening-draft.ts

@@ -0,0 +1,218 @@
+import {
+  type AnyNode,
+  type AnyNodeId,
+  area,
+  cutFloorOpening,
+  type FloorOpeningHint,
+  generateId,
+  type LevelNode,
+  type MultiPolygon,
+  type StructurePlan,
+  structureChangeBatch,
+  useScene,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { create } from 'zustand'
+import { getRoomSelectionIndex } from '../hooks/use-selected-room'
+import useEditor from '../store/use-editor'
+import {
+  CROSSING_MESSAGE,
+  clipFloorRegion,
+  floorRegionAxisAngle,
+  floorRegionSelfIntersects,
+} from './floor-region-geometry'
+import {
+  cancelFloorRegion,
+  type FloorDraftCommit,
+  type FloorDraftPurpose,
+  type FloorRegionRoom,
+  useFloorRegionDraft,
+} from './floor-region-session'
+import { type FloorRegionPoint, floorRegionSnapTargets } from './floor-region-snap'
+import { beginGesture, type GestureHandle } from './gesture-lifecycle'
+import { resolveRoomAssemblyHeights } from './room-assembly-overlay'
+import { roomFloorElevation } from './room-handle-drag'
+import { sfxEmitter } from './sfx-bus'
+
+// "Cut opening": draws an opening on a room's floor (or its ceiling) with the
+// floor region draft, rectangle or polygon, snapped to the room's wall faces
+// and its other openings. One outline is one `floor-opening` node (core's
+// `cutFloorOpening`), one undo step; the reconciler cuts the surfaces. The new
+// opening is then selected so its shape and switch are a click away, and Done
+// or Delete returns to the room.
+
+export const OPENING_DRAFT_HANDLE = 'floor-opening-draft'
+export const OPENING_OUTSIDE_MESSAGE = 'Draw the opening inside the room.'
+export const OPENING_TOO_SMALL_MESSAGE = 'Too small for an opening.'
+export const OPENING_FAILED_MESSAGE = "Can't cut an opening here."
+/** Smallest opening worth cutting, m². */
+const MIN_OPENING_AREA = 0.04
+
+export type OpeningShape = 'rectangle' | 'polygon'
+export type OpeningSurface = 'floor' | 'ceiling'
+
+export const useOpeningDraft = create<{
+  host: (FloorRegionRoom & { drawnOn: OpeningSurface }) | null
+  shape: OpeningShape
+  /** Hints the last cut returned (a manual ceiling below that is not cut). */
+  hints: FloorOpeningHint[]
+}>(() => ({ host: null, shape: 'rectangle', hints: [] }))
+
+/** The plan for an outline, or why it cannot be cut. */
+export function planFloorOpening(
+  nodes: Record<string, AnyNode>,
+  host: FloorRegionRoom,
+  drawnOn: OpeningSurface,
+  polygon: readonly FloorRegionPoint[],
+):
+  | { plan: StructurePlan & { openingIds: string[]; hints: FloorOpeningHint[] } }
+  | { message: string } {
+  const outline = polygon.map(([x, z]): [number, number] => [x, z])
+  if (floorRegionSelfIntersects(outline)) return { message: CROSSING_MESSAGE }
+  if (area([{ outer: outline, holes: [] }]) < MIN_OPENING_AREA)
+    return { message: OPENING_TOO_SMALL_MESSAGE }
+  if (!clipFloorRegion(polygon, host.clear)) return { message: OPENING_OUTSIDE_MESSAGE }
+  try {
+    const plan = cutFloorOpening(nodes, {
+      zoneId: host.zoneId,
+      polygon: outline,
+      drawnOn,
+      mintId: generateId,
+    })
+    const conflict = plan.conflicts?.[0]
+    return conflict ? { message: conflict.message || OPENING_FAILED_MESSAGE } : { plan }
+  } catch {
+    return { message: OPENING_FAILED_MESSAGE }
+  }
+}
+
+let tool: GestureHandle | null = null
+
+function reset() {
+  if (useOpeningDraft.getState().host) useOpeningDraft.setState({ host: null })
+  const { draft } = useFloorRegionDraft.getState()
+  if (draft?.room.purpose === OPENING) useFloorRegionDraft.setState({ draft: null, hover: null })
+}
+
+function commitOpening(room: FloorRegionRoom, polygon: readonly FloorRegionPoint[]) {
+  const host = useOpeningDraft.getState().host
+  const drawnOn = host?.drawnOn ?? 'floor'
+  const result = planFloorOpening(useScene.getState().nodes, room, drawnOn, polygon)
+  if ('message' in result) return { ok: false, message: result.message } as FloorDraftCommit
+  const apply = () =>
+    useScene.getState().applyNodeChanges(structureChangeBatch(result.plan.changes))
+  const handle = tool
+  tool = null
+  try {
+    if (handle?.active) handle.finish(apply)
+    else apply()
+  } finally {
+    reset()
+  }
+  sfxEmitter.emit('sfx:structure-build')
+  useOpeningDraft.setState({ hints: result.plan.hints })
+  const openingId = result.plan.openingIds[0]
+  if (openingId) useViewer.getState().setSelection({ selectedIds: [openingId as AnyNodeId] })
+  return { ok: true } as const
+}
+
+function hostGone(host: FloorRegionRoom) {
+  const scene = useScene.getState()
+  const zone = scene.nodes[host.zoneId as AnyNodeId]
+  return scene.readOnly || zone?.type !== 'zone' || zone.parentId !== host.levelId
+}
+
+function beginTool(host: FloorRegionRoom & { drawnOn: OpeningSurface }) {
+  const handle = beginGesture({
+    kind: 'floor-opening-draft',
+    scope: { kind: 'handle-drag', nodeId: host.zoneId, handle: OPENING_DRAFT_HANDLE },
+    stale: () => hostGone(host),
+    onCancel: () => {
+      if (tool === handle) tool = null
+      reset()
+    },
+  })
+  tool = handle
+  useOpeningDraft.setState({ host, hints: [] })
+  return handle
+}
+
+const OPENING: FloorDraftPurpose = {
+  persistent: true,
+  own: (room) => {
+    if (tool?.active) return tool
+    const host = useOpeningDraft.getState().host
+    return beginTool({ ...room, drawnOn: host?.drawnOn ?? 'floor' })
+  },
+  commit: commitOpening,
+  fill: '#f59e0b',
+}
+
+/**
+ * The room an opening is drawn in: its clear floor bounds and snaps the
+ * outline (with the level's other openings); the draft plane is its floor, or
+ * its ceiling for a ceiling opening. A mezzanine draws on its own deck.
+ */
+export function describeOpeningHost(
+  nodes: Record<string, AnyNode>,
+  zoneId: string,
+  drawnOn: OpeningSurface,
+): (FloorRegionRoom & { drawnOn: OpeningSurface }) | null {
+  const zone = nodes[zoneId]
+  if (zone?.type !== 'zone' || zone.spaceRole !== 'room' || !zone.parentId) return null
+  if (zone.floor?.support === 'open' && drawnOn !== 'floor') return null
+  const record = getRoomSelectionIndex(zone.parentId)
+    .update(nodes as ReturnType<typeof useScene.getState>['nodes'])
+    .find((room) => room.zoneId === zoneId)
+  if (!record) return null
+  const clear: MultiPolygon = record.clearPolygon
+  const others = Object.values(nodes).flatMap((node) =>
+    node.type === 'floor-opening' && node.parentId === zone.parentId ? [node.polygon] : [],
+  )
+  const heights = resolveRoomAssemblyHeights(record, nodes)
+  const elevation =
+    drawnOn === 'ceiling'
+      ? (heights.ceiling?.y ?? heights.floorY + 2.5)
+      : roomFloorElevation(nodes, zoneId)
+  return {
+    zoneId,
+    levelId: zone.parentId,
+    clear,
+    elevation,
+    angle: floorRegionAxisAngle(clear),
+    targets: floorRegionSnapTargets(clear, others),
+    purpose: OPENING,
+    drawnOn,
+  }
+}
+
+/** Arms "Cut opening" in a room, on its floor or its ceiling. False when it cannot. */
+export function startOpeningDraft(
+  zoneId: string,
+  drawnOn: OpeningSurface = 'floor',
+  shape: OpeningShape = 'rectangle',
+): boolean {
+  const nodes = useScene.getState().nodes
+  if (useScene.getState().readOnly) return false
+  const host = describeOpeningHost(nodes, zoneId, drawnOn)
+  if (!host) return false
+  cancelOpeningDraft()
+  cancelFloorRegion()
+  useOpeningDraft.setState({ shape })
+  if (useEditor.getState().mode !== 'select') useEditor.getState().setMode('select')
+  if (useViewer.getState().selection.levelId !== host.levelId)
+    useViewer.getState().setSelection({ levelId: host.levelId as LevelNode['id'] })
+  beginTool(host)
+  return true
+}
+
+export function cancelOpeningDraft() {
+  const current = tool
+  tool = null
+  if (current?.active) current.cancel()
+  else reset()
+}
+
+export function openingDraftActive() {
+  return !!useOpeningDraft.getState().host
+}

package/src/lib/floor-openings.test.ts

@@ -0,0 +1,216 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import {
+  type AnyNode,
+  BuildingNode,
+  createMezzanine,
+  createZone,
+  type FloorOpeningNode,
+  generateId,
+  initSpaceDetectionSync,
+  LevelNode,
+  structureChangeBatch,
+  useScene,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import useEditor from '../store/use-editor'
+import { installImmediateAnimationFrames } from '../test-utils/immediate-animation-frames'
+import {
+  deleteFloorOpening,
+  finishFloorEdit,
+  finishFloorOpening,
+  roomSurfaceOpenings,
+  startFloorEdit,
+  useFloorEditSession,
+} from './floor-edit-session'
+import {
+  cancelOpeningDraft,
+  describeOpeningHost,
+  OPENING_OUTSIDE_MESSAGE,
+  OPENING_TOO_SMALL_MESSAGE,
+  openingDraftActive,
+  planFloorOpening,
+  startOpeningDraft,
+  useOpeningDraft,
+} from './floor-opening-draft'
+import { applyRoomPlan } from './room-structure-commands'
+
+const GROUND = 'level_openings_ground'
+const UPPER = 'level_openings_upper'
+let stop = () => {}
+let restoreFrames = () => {}
+const nodes = () => useScene.getState().nodes as Record<string, AnyNode>
+const history = () => useScene.temporal.getState().pastStates.length
+const groundCeilingHoles = () =>
+  Object.values(nodes()).flatMap((n) =>
+    n.type === 'ceiling' && n.parentId === GROUND ? (n.holes ?? []) : [],
+  )
+const upperPlateHoles = () =>
+  Object.values(nodes()).flatMap((n) =>
+    n.type === 'slab' && n.parentId === UPPER ? (n.holes ?? []) : [],
+  )
+const openings = () =>
+  Object.values(nodes()).filter((n): n is FloorOpeningNode => n.type === 'floor-opening')
+
+const rect = (x0: number, z0: number, x1: number, z1: number): [number, number][] => [
+  [x0, z0],
+  [x1, z0],
+  [x1, z1],
+  [x0, z1],
+]
+const room = (levelId: string, name: string) => {
+  const plan = createZone(nodes(), {
+    levelId,
+    polygon: rect(0, 0, 8, 5),
+    enclose: true,
+    mintId: generateId,
+    name,
+  })
+  applyRoomPlan(plan)
+  return plan.zoneId
+}
+
+let groundRoom: string
+let upperRoom: string
+
+beforeEach(() => {
+  restoreFrames = installImmediateAnimationFrames()
+  const building = BuildingNode.parse({ id: 'building_openings', children: [GROUND, UPPER] })
+  const ground = LevelNode.parse({ id: GROUND, parentId: building.id, level: 0 })
+  const upper = LevelNode.parse({ id: UPPER, parentId: building.id, level: 1 })
+  useScene.setState({
+    nodes: { [building.id]: building, [ground.id]: ground, [upper.id]: upper },
+    rootNodeIds: [building.id],
+    dirtyNodes: new Set(),
+    materials: {},
+    collections: {},
+    readOnly: false,
+  })
+  useScene.temporal.getState().resume()
+  stop = initSpaceDetectionSync(useScene, { getState: () => ({ spaces: {}, setSpaces: () => {} }) })
+  groundRoom = room(GROUND, 'Hall')
+  upperRoom = room(UPPER, 'Landing')
+  useScene.temporal.getState().clear()
+  useEditor.setState({ phase: 'building', mode: 'select', room: null })
+  useViewer.getState().setSelection({ buildingId: building.id, levelId: UPPER, selectedIds: [] })
+})
+afterEach(() => {
+  cancelOpeningDraft()
+  finishFloorEdit()
+  stop()
+  restoreFrames()
+})
+
+const cutVoid = () => {
+  const host = describeOpeningHost(nodes(), upperRoom, 'floor')!
+  const result = planFloorOpening(nodes(), host, 'floor', rect(2, 1, 4, 2))
+  if ('message' in result) throw Error(result.message)
+  useScene.getState().applyNodeChanges(structureChangeBatch(result.plan.changes))
+  return result.plan.openingIds[0]!
+}
+
+describe('Cut opening (point 8)', () => {
+  test('an outline outside the room or too small is refused, in words', () => {
+    const host = describeOpeningHost(nodes(), upperRoom, 'floor')!
+    expect(planFloorOpening(nodes(), host, 'floor', rect(20, 20, 22, 22))).toEqual({
+      message: OPENING_OUTSIDE_MESSAGE,
+    })
+    expect(planFloorOpening(nodes(), host, 'floor', rect(1, 1, 1.1, 1.1))).toEqual({
+      message: OPENING_TOO_SMALL_MESSAGE,
+    })
+  })
+
+  test('a floor opening over a room below also cuts its ceiling, in one undo step', () => {
+    const id = cutVoid()
+    expect(history()).toBe(1)
+    const opening = nodes()[id] as FloorOpeningNode
+    expect(opening).toMatchObject({ parentId: UPPER, drawnOn: 'floor', cutsAdjacent: true })
+    expect(roomSurfaceOpenings(nodes(), upperRoom, 'floor').map((o) => o.id as string)).toEqual([
+      id,
+    ])
+    expect(roomSurfaceOpenings(nodes(), groundRoom, 'ceiling').map((o) => o.id as string)).toEqual([
+      id,
+    ])
+    expect(groundCeilingHoles()).toHaveLength(1)
+    expect(upperPlateHoles()).toHaveLength(1)
+    useScene.temporal.getState().undo()
+    expect(openings()).toEqual([])
+    expect(groundCeilingHoles()).toEqual([])
+  })
+
+  test('with its switch off, only the floor is cut', () => {
+    const id = cutVoid()
+    useScene.getState().updateNode(id as FloorOpeningNode['id'], { cutsAdjacent: false })
+    expect(roomSurfaceOpenings(nodes(), upperRoom, 'floor')).toHaveLength(1)
+    expect(roomSurfaceOpenings(nodes(), groundRoom, 'ceiling')).toEqual([])
+    expect(groundCeilingHoles()).toEqual([])
+  })
+
+  test('a ceiling opening on the top storey cuts only the ceiling', () => {
+    const host = describeOpeningHost(nodes(), upperRoom, 'ceiling')!
+    const result = planFloorOpening(nodes(), host, 'ceiling', rect(2, 1, 4, 2))
+    if ('message' in result) throw Error(result.message)
+    useScene.getState().applyNodeChanges(structureChangeBatch(result.plan.changes))
+    const [opening] = openings()
+    expect(opening).toMatchObject({ drawnOn: 'ceiling', cutsAdjacent: false })
+    expect(roomSurfaceOpenings(nodes(), upperRoom, 'ceiling')).toHaveLength(1)
+  })
+
+  test('a hatch in a mezzanine cuts only the mezzanine', () => {
+    const plan = createMezzanine(nodes(), {
+      hostZoneId: groundRoom,
+      polygon: rect(1, 1, 5, 4),
+      mintId: generateId,
+    })
+    applyRoomPlan(plan)
+    const host = describeOpeningHost(nodes(), plan.zoneId, 'floor')!
+    const result = planFloorOpening(nodes(), host, 'floor', rect(2, 2, 3, 3))
+    if ('message' in result) throw Error(result.message)
+    useScene.getState().applyNodeChanges(structureChangeBatch(result.plan.changes))
+    const [hatch] = openings()
+    expect(hatch).toMatchObject({ hostZoneId: plan.zoneId, cutsAdjacent: false })
+    expect(roomSurfaceOpenings(nodes(), plan.zoneId, 'floor').map((o) => o.id)).toEqual([hatch!.id])
+    expect(roomSurfaceOpenings(nodes(), groundRoom, 'floor')).toEqual([])
+  })
+
+  test('the shape is picked before drawing, not toggled during it', () => {
+    expect(startOpeningDraft(upperRoom, 'floor', 'polygon')).toBe(true)
+    expect(useOpeningDraft.getState().shape).toBe('polygon')
+    cancelOpeningDraft()
+    expect(startOpeningDraft(upperRoom, 'floor')).toBe(true)
+    expect(useOpeningDraft.getState().shape).toBe('rectangle')
+  })
+
+  test('the tool arms on the room and drops cleanly on cancel, writing nothing', () => {
+    expect(startOpeningDraft(upperRoom, 'floor')).toBe(true)
+    expect(openingDraftActive()).toBe(true)
+    cancelOpeningDraft()
+    expect(openingDraftActive()).toBe(false)
+    expect(history()).toBe(0)
+  })
+})
+
+describe('Edit floor, Done and Delete return to the room', () => {
+  test('Edit floor is a session on the room; Done ends it on the room', () => {
+    useEditor.getState().selectRoom({ levelId: UPPER, zoneId: upperRoom })
+    expect(startFloorEdit(upperRoom)).toBe(true)
+    expect(useFloorEditSession.getState().session?.zoneId).toBe(upperRoom)
+    expect(finishFloorEdit()).toBe(true)
+    expect(useFloorEditSession.getState().session).toBeNull()
+    expect(useEditor.getState().room).toEqual({ levelId: UPPER, zoneId: upperRoom })
+  })
+
+  test('Done in the opening panel and Delete both land on the room', () => {
+    const id = cutVoid()
+    useViewer.getState().setSelection({ selectedIds: [id as FloorOpeningNode['id']] })
+    expect(finishFloorOpening(id)).toBe(true)
+    expect(useViewer.getState().selection.selectedIds).toEqual([])
+    expect(useEditor.getState().room).toEqual({ levelId: UPPER, zoneId: upperRoom })
+
+    useViewer.getState().setSelection({ selectedIds: [id as FloorOpeningNode['id']] })
+    const before = history()
+    expect(deleteFloorOpening(id)).toBe(true)
+    expect(openings()).toEqual([])
+    expect(history()).toBe(before + 1)
+    expect(useEditor.getState().room).toEqual({ levelId: UPPER, zoneId: upperRoom })
+  })
+})

package/src/lib/floor-region-geometry.ts

@@ -0,0 +1,191 @@
+import { area, containsPoint, intersection, type MultiPolygon } from '@pascal-app/core'
+import type { FloorRegionPoint } from './floor-region-snap'
+
+// Pure geometry for "Paint part of the floor": which room a plan point is in,
+// the box a rectangle drag draws, crossing edges, and the clip to the room.
+
+/** Smaller than this (m²) is a click, not a region. */
+export const MIN_FLOOR_REGION_AREA = 0.01
+export const CROSSING_MESSAGE = "Edges can't cross"
+export const OUTSIDE_MESSAGE = 'Draw inside the room'
+
+/** The first room (in the given order) whose clear floor holds the point. */
+/**
+ * The room whose clear floor holds `point`. Rooms can stack (a mezzanine over
+ * its host): with `elevationOf`, the topmost floor wins, as the plan shows it
+ * and as a 3D ray from above would land.
+ */
+export function floorRegionRoomAt<T extends { clearPolygon: MultiPolygon }>(
+  rooms: readonly T[],
+  point: FloorRegionPoint,
+  elevationOf?: (room: T) => number,
+): T | null {
+  let best: T | null = null
+  let bestElevation = Number.NEGATIVE_INFINITY
+  for (const room of rooms) {
+    if (!containsPoint(room.clearPolygon, point)) continue
+    if (!elevationOf) return room
+    const elevation = elevationOf(room)
+    if (elevation > bestElevation) {
+      best = room
+      bestElevation = elevation
+    }
+  }
+  return best
+}
+
+/**
+ * The rectangle frame of a room: the direction of its longest boundary edge,
+ * folded into [-45°, 45°) so an axis-aligned room reads exactly 0 and a box
+ * drawn in a room at an angle follows the room.
+ */
+export function floorRegionAxisAngle(clear: MultiPolygon): number {
+  let longest = 0
+  let angle = 0
+  for (const { outer } of clear) {
+    for (let i = 0; i < outer.length; i++) {
+      const a = outer[i]!
+      const b = outer[(i + 1) % outer.length]!
+      const length = Math.hypot(b[0] - a[0], b[1] - a[1])
+      if (length > longest + 1e-9) {
+        longest = length
+        angle = Math.atan2(b[1] - a[1], b[0] - a[0])
+      }
+    }
+  }
+  const quarter = Math.PI / 2
+  let folded = angle - Math.round(angle / quarter) * quarter
+  if (folded >= Math.PI / 4) folded -= quarter
+  return Math.abs(folded) < 1e-9 ? 0 : folded
+}
+
+/** The box with opposite corners `start` and `end`, its sides along `angle` and across it. */
+export function floorRegionRectangle(
+  start: FloorRegionPoint,
+  end: FloorRegionPoint,
+  angle: number,
+): FloorRegionPoint[] {
+  const dx = end[0] - start[0]
+  const dz = end[1] - start[1]
+  if (angle === 0)
+    return [
+      [start[0], start[1]],
+      [end[0], start[1]],
+      [end[0], end[1]],
+      [start[0], end[1]],
+    ]
+  const ux = Math.cos(angle)
+  const uz = Math.sin(angle)
+  const along = dx * ux + dz * uz
+  const across = -dx * uz + dz * ux
+  const corner = (u: number, v: number): FloorRegionPoint => [
+    start[0] + u * ux - v * uz,
+    start[1] + u * uz + v * ux,
+  ]
+  return [corner(0, 0), corner(along, 0), corner(along, across), corner(0, across)]
+}
+
+function orientation(a: FloorRegionPoint, b: FloorRegionPoint, c: FloorRegionPoint) {
+  return (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0])
+}
+
+const EPSILON = 1e-9
+
+function onSegment(a: FloorRegionPoint, b: FloorRegionPoint, p: FloorRegionPoint) {
+  return (
+    Math.min(a[0], b[0]) - EPSILON <= p[0] &&
+    p[0] <= Math.max(a[0], b[0]) + EPSILON &&
+    Math.min(a[1], b[1]) - EPSILON <= p[1] &&
+    p[1] <= Math.max(a[1], b[1]) + EPSILON
+  )
+}
+
+/** Whether two segments touch or cross (end points included). */
+export function segmentsTouch(
+  a: FloorRegionPoint,
+  b: FloorRegionPoint,
+  c: FloorRegionPoint,
+  d: FloorRegionPoint,
+): boolean {
+  const o1 = orientation(a, b, c)
+  const o2 = orientation(a, b, d)
+  const o3 = orientation(c, d, a)
+  const o4 = orientation(c, d, b)
+  const s = (value: number) => (Math.abs(value) < EPSILON ? 0 : Math.sign(value))
+  if (s(o1) * s(o2) < 0 && s(o3) * s(o4) < 0) return true
+  return (
+    (s(o1) === 0 && onSegment(a, b, c)) ||
+    (s(o2) === 0 && onSegment(a, b, d)) ||
+    (s(o3) === 0 && onSegment(c, d, a)) ||
+    (s(o4) === 0 && onSegment(c, d, b))
+  )
+}
+
+/** Whether a segment folds back along its neighbour (shared end, overlapping). */
+function foldsBack(shared: FloorRegionPoint, previous: FloorRegionPoint, next: FloorRegionPoint) {
+  const cross = orientation(shared, previous, next)
+  const dot =
+    (previous[0] - shared[0]) * (next[0] - shared[0]) +
+    (previous[1] - shared[1]) * (next[1] - shared[1])
+  return Math.abs(cross) < EPSILON && dot > 0
+}
+
+/**
+ * Whether adding `next` after the open path `points` makes an edge cross (or
+ * fold back onto) an earlier one. With `closing`, `next` is the first point and
+ * the new edge closes the ring.
+ */
+export function floorRegionEdgeCrosses(
+  points: readonly FloorRegionPoint[],
+  next: FloorRegionPoint,
+  closing = false,
+): boolean {
+  const last = points.at(-1)
+  if (!last) return false
+  if (points.length >= 2 && foldsBack(last, points.at(-2)!, next)) return true
+  if (closing && points.length >= 2 && foldsBack(points[0]!, points[1]!, last)) return true
+  // Edges i → i+1 that do not share an end with the new edge.
+  const firstEdge = closing ? 1 : 0
+  for (let i = firstEdge; i < points.length - 2; i++)
+    if (segmentsTouch(points[i]!, points[i + 1]!, last, next)) return true
+  return false
+}
+
+/** Whether a closed ring has two edges that cross. */
+export function floorRegionSelfIntersects(ring: readonly FloorRegionPoint[]): boolean {
+  for (let i = 1; i < ring.length; i++)
+    if (floorRegionEdgeCrosses(ring.slice(0, i), ring[i]!)) return true
+  return ring.length >= 3 && floorRegionEdgeCrosses(ring, ring[0]!, true)
+}
+
+export type FloorRegionClip = {
+  /** What gets stored: the clipped outline, or the drawn one when the room splits it. */
+  polygon: FloorRegionPoint[]
+  /** The painted pieces (what the floor will show). */
+  pieces: MultiPolygon
+  area: number
+}
+
+/**
+ * Clips a drawn outline to the room's clear floor. One piece stores its outer
+ * ring (the plate partition clips any hole, like a column, again at render).
+ * When the room splits the outline into several pieces (a box across a
+ * U-shaped room's notch), the drawn outline is stored as is: the renderer
+ * intersects every region with the room, so all pieces paint in one region and
+ * one undo step. Nothing inside the room, or less than a click's worth, is null.
+ */
+export function clipFloorRegion(
+  polygon: readonly FloorRegionPoint[],
+  clear: MultiPolygon,
+): FloorRegionClip | null {
+  if (polygon.length < 3) return null
+  const ring = polygon.map(([x, z]) => [x, z] as FloorRegionPoint)
+  const pieces = intersection(ring, clear)
+  const clipped = area(pieces)
+  if (clipped < MIN_FLOOR_REGION_AREA) return null
+  return {
+    polygon: pieces.length === 1 ? pieces[0]!.outer.map(([x, z]) => [x, z]) : ring,
+    pieces,
+    area: clipped,
+  }
+}