@pascal-app/editor 1.1.0 → 1.1.1

package/src/lib/room-assembly-overlay.test.ts

@@ -1,275 +0,0 @@
-import { afterEach, describe, expect, test } from 'bun:test'
-import { readFileSync } from 'node:fs'
-import {
-  type AnyNode,
-  BuildingNode,
-  CeilingNode,
-  getWallArcData,
-  getWallFaceOffsets,
-  LevelNode,
-  SlabNode,
-  sceneRegistry,
-  WallNode,
-} from '@pascal-app/core'
-import { migrateCeilingRoomLinks, migrateRoomZones } from '@pascal-app/core/scene-migrations'
-import { BoxGeometry, Mesh, MeshBasicMaterial } from 'three'
-import {
-  buildRoomAssembly,
-  getRoomAssembly,
-  type RoomAssemblyHeights,
-  resolveRoomAssemblyHeights,
-  roomWallFaces,
-} from './room-assembly-overlay'
-import { RoomSelectionIndex, type RoomSelectionRecord } from './room-selection'
-
-const levelId = 'level_room_assembly'
-const buildingId = 'building_room_assembly'
-
-function wall(id: string, start: [number, number], end: [number, number], extra = {}) {
-  return WallNode.parse({
-    id: `wall_${id}`,
-    parentId: levelId,
-    start,
-    end,
-    thickness: 0.2,
-    ...extra,
-  })
-}
-
-function scene(walls: WallNode[], extra: AnyNode[] = []) {
-  const raw = Object.fromEntries(
-    [
-      BuildingNode.parse({ id: buildingId, children: [levelId] }),
-      LevelNode.parse({
-        id: levelId,
-        parentId: buildingId,
-        children: [...walls, ...extra].map((node) => node.id),
-      }),
-      ...walls,
-      ...extra,
-    ].map((node) => [node.id, node]),
-  )
-  return migrateCeilingRoomLinks(migrateRoomZones(raw).nodes).nodes as Record<string, AnyNode>
-}
-
-// Two 4 x 4 rooms split by `shared`, with a T-stem into the east room.
-function twoRooms(extraWalls: WallNode[] = []) {
-  return scene([
-    wall('south', [0, 0], [8, 0]),
-    wall('east', [8, 0], [8, 4]),
-    wall('north', [8, 4], [0, 4]),
-    wall('west', [0, 4], [0, 0]),
-    wall('shared', [4, 0], [4, 4]),
-    ...extraWalls,
-  ])
-}
-
-function roomAt(records: RoomSelectionRecord[], point: [number, number]) {
-  const [x, z] = point
-  return records.find(({ polygon }) => {
-    const xs = polygon.map((p) => p[0])
-    const zs = polygon.map((p) => p[1])
-    return x > Math.min(...xs) && x < Math.max(...xs) && z > Math.min(...zs) && z < Math.max(...zs)
-  })!
-}
-
-function withNodes(nodes: Record<string, AnyNode>, ...added: AnyNode[]) {
-  const level = nodes[levelId] as LevelNode
-  return {
-    ...nodes,
-    ...Object.fromEntries(added.map((node) => [node.id, node])),
-    [levelId]: { ...level, children: [...level.children, ...added.map((node) => node.id)] },
-  } as Record<string, AnyNode>
-}
-
-const heights = (tops: Record<string, number>, floorY = 0): RoomAssemblyHeights => ({
-  floorY,
-  wallTops: new Map(Object.entries(tops)),
-  ceiling: null,
-})
-
-const length = ({ from, to }: { from: readonly number[]; to: readonly number[] }) =>
-  Math.hypot(to[0]! - from[0]!, to[1]! - from[1]!)
-
-function yValues(array: Float32Array) {
-  const ys = new Set<number>()
-  for (let i = 1; i < array.length; i += 3) ys.add(Math.round(array[i]! * 1000) / 1000)
-  return [...ys].sort((a, b) => a - b)
-}
-
-afterEach(() => sceneRegistry.clear())
-
-describe('room assembly faces', () => {
-  test('only the room-facing face, clipped at the partition and the corners', () => {
-    const room = roomAt(new RoomSelectionIndex(levelId).update(twoRooms()), [2, 2])
-    const faces = roomWallFaces(room.geometry)
-    const byWall = new Map<string, typeof faces>()
-    for (const face of faces) byWall.set(face.wallId, [...(byWall.get(face.wallId) ?? []), face])
-    expect([...byWall.keys()].sort()).toEqual(
-      ['wall_north', 'wall_shared', 'wall_south', 'wall_west'].sort(),
-    )
-    const south = byWall.get('wall_south')!
-    expect(south.every(({ face }) => face === 'a')).toBe(true)
-    for (const { from, to } of south) {
-      expect(from[1]).toBeCloseTo(0.1)
-      expect(to[1]).toBeCloseTo(0.1)
-      for (const x of [from[0], to[0]]) {
-        expect(x).toBeGreaterThanOrEqual(0.1 - 1e-6)
-        expect(x).toBeLessThanOrEqual(3.9 + 1e-6)
-      }
-    }
-    expect(south.reduce((sum, face) => sum + length(face), 0)).toBeCloseTo(3.8)
-    // The partition contributes its west face only.
-    for (const { from, to } of byWall.get('wall_shared')!) {
-      expect(from[0]).toBeCloseTo(3.9)
-      expect(to[0]).toBeCloseTo(3.9)
-    }
-  })
-
-  test('a T-stem splits the host face into per-room t-ranges', () => {
-    const nodes = twoRooms([wall('stem', [4, 2], [8, 2])])
-    const records = new RoomSelectionIndex(levelId).update(nodes)
-    const lower = roomAt(records, [6, 1])
-    const upper = roomAt(records, [6, 3])
-    for (const [room, zMin, zMax] of [
-      [lower, 0.1, 1.9],
-      [upper, 2.1, 3.9],
-    ] as const) {
-      const shared = roomWallFaces(room.geometry).filter(({ wallId }) => wallId === 'wall_shared')
-      const span = room.spans.find(({ boundaryId }) => boundaryId === 'wall_shared')!
-      expect(shared.reduce((sum, face) => sum + length(face), 0)).toBeCloseTo(zMax - zMin)
-      for (const { from, to, face } of shared) {
-        expect(face).toBe(span.face)
-        for (const [x, z] of [from, to]) {
-          expect(x).toBeCloseTo(4.1)
-          expect(z).toBeGreaterThanOrEqual(zMin - 1e-6)
-          expect(z).toBeLessThanOrEqual(zMax + 1e-6)
-          const t = z / 4
-          expect(t).toBeGreaterThanOrEqual(span.t0 - 1e-6)
-          expect(t).toBeLessThanOrEqual(span.t1 + 1e-6)
-        }
-      }
-    }
-  })
-
-  test('curved faces follow the offset arc and only draw verticals at their ends', () => {
-    const nodes = twoRooms()
-    const curved = { ...(nodes.wall_shared as WallNode), curveOffset: 0.5 }
-    const room = roomAt(
-      new RoomSelectionIndex(levelId).update({ ...nodes, [curved.id]: curved }),
-      [1, 2],
-    )
-    const faces = roomWallFaces(room.geometry).filter(({ wallId }) => wallId === curved.id)
-    expect(faces.length).toBeGreaterThan(4)
-    const arc = getWallArcData(curved)!
-    const face = faces[0]!.face
-    const radius = arc.radius - arc.direction * getWallFaceOffsets(curved)[face]
-    for (const { from, to } of faces) {
-      for (const [x, z] of [from, to])
-        expect(Math.hypot(x - arc.center.x, z - arc.center.y)).toBeCloseTo(radius, 2)
-    }
-    const tops = Object.fromEntries(room.boundaryWallIds.map((id) => [id, 2.5]))
-    const { outline } = buildRoomAssembly(room.geometry, heights(tops))
-    let verticals = 0
-    for (let i = 0; i < outline.length; i += 6) {
-      if (
-        outline[i + 1]! !== outline[i + 4]! &&
-        Math.hypot(outline[i]! - outline[i + 3]!, outline[i + 2]! - outline[i + 5]!) < 1e-6
-      )
-        verticals++
-    }
-    // Four walls, two run ends each; the arc's chords share their joints.
-    expect(verticals).toBe(8)
-  })
-})
-
-describe('room assembly geometry', () => {
-  test('walls rise from the plate top to their own tops; the ceiling sits at its height', () => {
-    const base = twoRooms()
-    const initial = roomAt(new RoomSelectionIndex(levelId).update(base), [2, 2])
-    const polygon: [number, number][] = [
-      [0.1, 0.1],
-      [3.9, 0.1],
-      [3.9, 3.9],
-      [0.1, 3.9],
-    ]
-    const nodes = withNodes(
-      { ...base, wall_south: { ...(base.wall_south as WallNode), height: 2.1 } },
-      SlabNode.parse({ parentId: levelId, polygon, zoneIds: [initial.zoneId], elevation: 0.3 }),
-      CeilingNode.parse({ parentId: levelId, polygon, zoneId: initial.zoneId, height: 2.4 }),
-    )
-    const room = roomAt(new RoomSelectionIndex(levelId).update(nodes), [2, 2])
-    const resolved = resolveRoomAssemblyHeights(room, nodes)
-    expect(resolved.floorY).toBe(0.3)
-    expect(resolved.ceiling?.y).toBe(2.4)
-    expect(resolved.wallTops.get('wall_south')).toBe(2.1)
-    const planeTop = resolved.wallTops.get('wall_west')!
-    expect(planeTop).toBeGreaterThan(2.1)
-    const assembly = buildRoomAssembly(room.geometry, resolved)
-    expect(yValues(assembly.floor)).toEqual([0.305])
-    expect(yValues(assembly.surfaces)).toEqual(
-      [0.305, 2.1, 2.38, Math.round(planeTop * 1000) / 1000].sort((a, b) => a - b),
-    )
-    expect(yValues(assembly.outline)).toContain(2.38)
-    expect(assembly.floor.length).toBeGreaterThan(0)
-  })
-
-  test('cache hits on the same topology revision and misses on topology or height change', () => {
-    const index = new RoomSelectionIndex(levelId)
-    const nodes = twoRooms()
-    const room = roomAt(index.update(nodes), [2, 2])
-    const tops = Object.fromEntries(room.boundaryWallIds.map((id) => [id, 2.5]))
-    const first = getRoomAssembly(room.geometry, heights(tops))
-    // A fresh heights object with equal values and an unrelated scene edit both hit.
-    expect(getRoomAssembly(room.geometry, heights({ ...tops }))).toBe(first)
-    const zone = nodes[room.zoneId]!
-    const renamed = roomAt(
-      index.update({ ...nodes, [zone.id]: { ...zone, name: 'Kitchen' } as AnyNode }),
-      [2, 2],
-    )
-    expect(renamed.geometry).toBe(room.geometry)
-    expect(getRoomAssembly(renamed.geometry, heights(tops))).toBe(first)
-    expect(getRoomAssembly(room.geometry, heights({ ...tops, wall_south: 2 }))).not.toBe(first)
-    const moved = roomAt(
-      index.update({
-        ...nodes,
-        wall_shared: { ...(nodes.wall_shared as WallNode), start: [5, 0], end: [5, 4] },
-      }),
-      [2, 2],
-    )
-    expect(moved.geometry).not.toBe(room.geometry)
-    const rebuilt = getRoomAssembly(moved.geometry, heights(tops))
-    expect(rebuilt).not.toBe(first)
-    expect(rebuilt.floor.length).toBeGreaterThan(0)
-  })
-
-  test('building and resolving never touch the rendered wall meshes', () => {
-    const nodes = twoRooms()
-    const room = roomAt(new RoomSelectionIndex(levelId).update(nodes), [2, 2])
-    const meshes = room.boundaryWallIds.map((id) => {
-      const mesh = new Mesh(new BoxGeometry(), new MeshBasicMaterial())
-      mesh.userData = { batched: true, pascalId: id }
-      sceneRegistry.nodes.set(id, mesh)
-      return {
-        mesh,
-        material: mesh.material,
-        geometry: mesh.geometry,
-        layers: mesh.layers.mask,
-        userData: structuredClone(mesh.userData),
-        visible: mesh.visible,
-      }
-    })
-    getRoomAssembly(room.geometry, resolveRoomAssemblyHeights(room, nodes))
-    for (const { mesh, material, geometry, layers, userData, visible } of meshes) {
-      expect(mesh.material).toBe(material)
-      expect(mesh.geometry).toBe(geometry)
-      expect(mesh.layers.mask).toBe(layers)
-      expect(mesh.userData).toEqual(userData)
-      expect(mesh.visible).toBe(visible)
-    }
-    for (const file of ['./room-assembly-overlay.ts', '../components/editor/room-highlight.tsx']) {
-      const source = readFileSync(new URL(file, import.meta.url), 'utf8')
-      expect(source).not.toMatch(/\.material\s*=[^=]|userData|sceneRegistry\.nodes\.set/)
-    }
-  })
-})

package/src/lib/room-assembly-overlay.ts

@@ -1,265 +0,0 @@
-import {
-  type AnyNode,
-  type AnyNodeId,
-  area,
-  getWallArcData,
-  getWallBaseElevationForNodes,
-  getWallCurveFrameAt,
-  getWallFaceOffsets,
-  getWallTop,
-  resolveCeilingHeight,
-  roomDrawnFloor,
-  type WallNode,
-} from '@pascal-app/core'
-import { ShapeUtils, Vector2 } from 'three'
-import type { RoomSelectionGeometry, RoomSelectionRecord } from './room-selection'
-
-type Point = readonly [number, number]
-type Ring = readonly Point[]
-
-/** Everything the assembly depends on besides the room's topology geometry. */
-export type RoomAssemblyHeights = {
-  /** Level-local Y of the room's plate top (the level plane without a plate). */
-  floorY: number
-  /** Level-local Y of each boundary wall's top. */
-  wallTops: ReadonlyMap<string, number>
-  ceiling: { polygon: Ring; holes: readonly Ring[]; y: number } | null
-}
-
-export type RoomWallFacePortion = { wallId: string; face: 'a' | 'b'; from: Point; to: Point }
-
-/** Flat level-local position buffers; the renderer only wraps them. */
-export type RoomAssembly = {
-  floor: Float32Array
-  surfaces: Float32Array
-  outline: Float32Array
-  faces: RoomWallFacePortion[]
-}
-
-const ON_FACE = 1e-3
-const FLOOR_LIFT = 0.005
-const CEILING_DROP = 0.02
-const CURVE_SAMPLES = 24
-const MIN_PIECE_AREA = 0.01
-
-/**
- * Curved boundaries leave hairline slivers between the sampled room face and
- * the sampled wall footprint; they would add stray face runs.
- */
-function clearPieces(geometry: RoomSelectionGeometry) {
-  return geometry.clearPolygon.filter((piece) => area([piece]) >= MIN_PIECE_AREA)
-}
-
-export function resolveRoomAssemblyHeights(
-  room: RoomSelectionRecord,
-  nodes: Readonly<Record<string, AnyNode>>,
-): RoomAssemblyHeights {
-  const sceneNodes = nodes as Record<AnyNodeId, AnyNode>
-  const { levelId } = room.key
-  const zone = nodes[room.zoneId]
-  let floorY = 0
-  // A drawn slab floors the room even with its floor switched off.
-  if (zone?.type === 'zone' && (zone.hasFloor !== false || roomDrawnFloor(nodes, zone.id))) {
-    const level = nodes[levelId]
-    const plate =
-      level?.type === 'level'
-        ? level.children
-            .map((id) => nodes[id])
-            .find((node) => node?.type === 'slab' && node.zoneIds?.includes(room.zoneId))
-        : undefined
-    const drawn = plate ? null : roomDrawnFloor(nodes, room.zoneId)
-    const linked =
-      plate ?? (drawn ? nodes[drawn.slabId] : room.slabId ? nodes[room.slabId] : undefined)
-    floorY = (linked?.type === 'slab' ? linked.elevation : zone.floor?.elevation) ?? 0
-  }
-  const wallTops = new Map<string, number>()
-  for (const id of room.boundaryWallIds) {
-    const wall = nodes[id]
-    if (wall?.type !== 'wall') continue
-    const base = getWallBaseElevationForNodes(wall, sceneNodes)
-    wallTops.set(id, getWallTop(wall, levelId, sceneNodes, base, 0.5))
-  }
-  const ceilingNode = room.ceilingId ? nodes[room.ceilingId] : undefined
-  const ceiling =
-    ceilingNode?.type === 'ceiling'
-      ? {
-          polygon: ceilingNode.polygon,
-          holes: ceilingNode.holes,
-          y: resolveCeilingHeight(ceilingNode, sceneNodes),
-        }
-      : null
-  return { floorY, wallTops, ceiling }
-}
-
-function heightsKey({ floorY, wallTops, ceiling }: RoomAssemblyHeights) {
-  const rings = ceiling ? [ceiling.polygon, ...ceiling.holes].map((ring) => ring.join(' ')) : []
-  return [floorY, ...wallTops, ceiling?.y, ...rings].join('|')
-}
-
-const cache = new WeakMap<RoomSelectionGeometry, { key: string; assembly: RoomAssembly }>()
-
-/**
- * The room geometry object is reused for as long as the level topology
- * revision stands, so it keys the cache; heights and the ceiling outline are
- * compared by value. Hover changes and pointer moves only ever hit.
- */
-export function getRoomAssembly(
-  geometry: RoomSelectionGeometry,
-  heights: RoomAssemblyHeights,
-): RoomAssembly {
-  const key = heightsKey(heights)
-  const cached = cache.get(geometry)
-  if (cached?.key === key) return cached.assembly
-  const assembly = buildRoomAssembly(geometry, heights)
-  cache.set(geometry, { key, assembly })
-  return assembly
-}
-
-function faceTest(wall: WallNode, face: 'a' | 'b') {
-  const offset = getWallFaceOffsets(wall)[face]
-  const arc = getWallArcData(wall)
-  if (arc) {
-    const radius = arc.radius - arc.direction * offset
-    return ([x, z]: Point) =>
-      Math.abs(Math.hypot(x - arc.center.x, z - arc.center.y) - radius) < ON_FACE
-  }
-  const dx = wall.end[0] - wall.start[0]
-  const dz = wall.end[1] - wall.start[1]
-  const length = Math.hypot(dx, dz)
-  if (length < 1e-9) return () => false
-  return ([x, z]: Point) =>
-    Math.abs(((x - wall.start[0]) * -dz + (z - wall.start[1]) * dx) / length - offset) < ON_FACE
-}
-
-function* ringEdges(ring: Ring) {
-  for (let i = 0; i < ring.length; i++) yield [ring[i]!, ring[(i + 1) % ring.length]!] as const
-}
-
-function overlap(p: Point, q: Point, a: Point, b: Point): [Point, Point] | null {
-  const ex = b[0] - a[0]
-  const ez = b[1] - a[1]
-  const lengthSq = ex * ex + ez * ez
-  if (lengthSq < 1e-12) return null
-  const length = Math.sqrt(lengthSq)
-  const offLine = ([x, z]: Point) => Math.abs((x - a[0]) * ez - (z - a[1]) * ex) / length
-  if (offLine(p) > ON_FACE || offLine(q) > ON_FACE) return null
-  const up = ((p[0] - a[0]) * ex + (p[1] - a[1]) * ez) / lengthSq
-  const uq = ((q[0] - a[0]) * ex + (q[1] - a[1]) * ez) / lengthSq
-  const lo = Math.max(0, Math.min(up, uq))
-  const hi = Math.min(1, Math.max(up, uq))
-  if ((hi - lo) * length < 1e-4) return null
-  return [
-    [a[0] + ex * lo, a[1] + ez * lo],
-    [a[0] + ex * hi, a[1] + ez * hi],
-  ]
-}
-
-/**
- * The room-facing part of each boundary wall face. The clear polygon's
- * boundary is exactly the mitered faces the room sees, clipped by T-stems
- * and separators, so its edges are matched against each wall's footprint
- * face edges; that also keeps collinear walls apart.
- */
-export function roomWallFaces(geometry: RoomSelectionGeometry): RoomWallFacePortion[] {
-  const rings = clearPieces(geometry).flatMap(({ outer, holes }) => [outer, ...holes])
-  const faces: RoomWallFacePortion[] = []
-  const seen = new Set<string>()
-  for (const span of geometry.spans) {
-    if (span.kind !== 'wall') continue
-    const wallId = span.boundaryId
-    const wall = geometry.context.walls.get(wallId)
-    if (!wall) continue
-    if (!rings.length) {
-      faces.push(...sampledFace(wall, span.face, span.t0, span.t1))
-      continue
-    }
-    const key = `${wallId}:${span.face}`
-    const footprint = geometry.context.wallFootprints.get(wallId)
-    if (seen.has(key) || !footprint) continue
-    seen.add(key)
-    const onFace = faceTest(wall, span.face)
-    const faceEdges = [...ringEdges(footprint)].filter(([a, b]) => onFace(a) && onFace(b))
-    for (const ring of rings) {
-      for (const [p, q] of ringEdges(ring)) {
-        if (!(onFace(p) && onFace(q))) continue
-        for (const [a, b] of faceEdges) {
-          const portion = overlap(p, q, a, b)
-          if (portion) faces.push({ wallId, face: span.face, from: portion[0], to: portion[1] })
-        }
-      }
-    }
-  }
-  return faces
-}
-
-// Only used when the clear polygon could not be computed for the room.
-function sampledFace(wall: WallNode, face: 'a' | 'b', t0: number, t1: number) {
-  const offset = getWallFaceOffsets(wall)[face]
-  const steps = getWallArcData(wall) ? CURVE_SAMPLES : 1
-  const points = Array.from({ length: steps + 1 }, (_, i): Point => {
-    const { point, normal } = getWallCurveFrameAt(wall, t0 + ((t1 - t0) * i) / steps)
-    return [point.x + normal.x * offset, point.y + normal.y * offset]
-  })
-  return points
-    .slice(1)
-    .map((to, i): RoomWallFacePortion => ({ wallId: wall.id, face, from: points[i]!, to }))
-}
-
-function pushTriangles(target: number[], outer: Ring, holes: readonly Ring[], y: number) {
-  const contour = outer.map(([x, z]) => new Vector2(x, z))
-  const holePoints = holes.map((ring) => ring.map(([x, z]) => new Vector2(x, z)))
-  const points = [...contour, ...holePoints.flat()]
-  for (const triangle of ShapeUtils.triangulateShape(contour, holePoints)) {
-    for (const index of triangle) target.push(points[index]!.x, y, points[index]!.y)
-  }
-}
-
-function pushRing(target: number[], ring: Ring, y: number) {
-  for (const [[ax, az], [bx, bz]] of ringEdges(ring)) target.push(ax, y, az, bx, y, bz)
-}
-
-export function buildRoomAssembly(
-  geometry: RoomSelectionGeometry,
-  heights: RoomAssemblyHeights,
-): RoomAssembly {
-  const floor: number[] = []
-  const surfaces: number[] = []
-  const outline: number[] = []
-  const floorY = heights.floorY + FLOOR_LIFT
-  for (const { outer, holes } of clearPieces(geometry)) {
-    pushTriangles(floor, outer, holes, floorY)
-    for (const ring of [outer, ...holes]) pushRing(outline, ring, floorY)
-  }
-  const faces = roomWallFaces(geometry)
-  const ends = new Map<string, { point: Point; top: number; count: number }>()
-  for (const { wallId, from, to } of faces) {
-    const top = heights.wallTops.get(wallId)
-    if (top === undefined || top <= floorY) continue
-    const [ax, az] = from
-    const [bx, bz] = to
-    surfaces.push(ax, floorY, az, bx, floorY, bz, bx, top, bz)
-    surfaces.push(ax, floorY, az, bx, top, bz, ax, top, az)
-    outline.push(ax, top, az, bx, top, bz)
-    for (const point of [from, to]) {
-      const key = `${wallId}:${point[0].toFixed(4)},${point[1].toFixed(4)}`
-      const end = ends.get(key)
-      if (end) end.count++
-      else ends.set(key, { point, top, count: 1 })
-    }
-  }
-  // Verticals only where a face run starts or stops, not between curve chords.
-  for (const { point, top, count } of ends.values()) {
-    if (count === 1) outline.push(point[0], floorY, point[1], point[0], top, point[1])
-  }
-  if (heights.ceiling) {
-    const { polygon, holes, y } = heights.ceiling
-    pushTriangles(surfaces, polygon, holes, y - CEILING_DROP)
-    for (const ring of [polygon, ...holes]) pushRing(outline, ring, y - CEILING_DROP)
-  }
-  return {
-    floor: new Float32Array(floor),
-    surfaces: new Float32Array(surfaces),
-    outline: new Float32Array(outline),
-    faces,
-  }
-}