@pascal-app/editor 1.0.3 → 1.0.5

package/src/lib/follow-pascal-presentation.test.ts

@@ -0,0 +1,203 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  type Floor,
+  FollowPresentation,
+  type PresentationPort,
+  type ViewPresentation,
+} from './follow-pascal-presentation'
+
+// The owner, 12 October, on 3114: Follow Pascal left the view in cutaway with the upper floors hidden
+// after it stopped, and the walls looked invisible. Follow changes the presentation to see what a build
+// works on; when it ends it puts back what it changed, and only that.
+
+const GROUND: Floor = {
+  buildingId: 'b',
+  levelId: 'ground',
+  zoneId: null,
+  selectedIds: [],
+  room: null,
+}
+
+/** A view and a record of every write made to it. */
+function view(initial: Partial<ViewPresentation> = {}) {
+  const state: ViewPresentation = {
+    wall: 'up',
+    levels: 'stacked',
+    hideAbove: false,
+    floor: { ...GROUND },
+    ...initial,
+  }
+  const writes: string[] = []
+  const port: PresentationPort = {
+    read: () => ({ ...state, floor: { ...state.floor } }),
+    setWall: (mode) => {
+      writes.push(`wall:${mode}`)
+      state.wall = mode
+    },
+    setLevels: (mode) => {
+      writes.push(`levels:${mode}`)
+      state.levels = mode
+    },
+    setHideAbove: (hide) => {
+      writes.push(`hideAbove:${hide}`)
+      state.hideAbove = hide
+    },
+    // A selected floor drops the room and what was picked, as the viewer's selection does.
+    setFloor: ({ buildingId, levelId }) => {
+      writes.push(`floor:${levelId}`)
+      state.floor = {
+        buildingId: buildingId ?? state.floor.buildingId,
+        levelId,
+        zoneId: null,
+        selectedIds: [],
+        room: null,
+      }
+    },
+    putFloor: (floor) => {
+      writes.push(`put:${floor.levelId}`)
+      state.floor = { ...floor }
+    },
+  }
+  return { state, writes, port }
+}
+
+describe('what Follow changes, it puts back', () => {
+  test('the cutaway it switched to', () => {
+    const { state, port } = view({ wall: 'up' })
+    const follow = new FollowPresentation(port)
+    follow.wall('cutaway')
+    expect(state.wall).toBe('cutaway')
+    follow.restore()
+    expect(state.wall).toBe('up')
+  })
+
+  test('the floor it selected, with the room and the picks the person had', () => {
+    const had: Floor = {
+      buildingId: 'b',
+      levelId: 'upper',
+      zoneId: 'zone_kitchen',
+      selectedIds: ['item_a', 'item_b'],
+      room: { levelId: 'upper', zoneId: 'zone_kitchen' },
+    }
+    const { state, port } = view({ floor: had })
+    const follow = new FollowPresentation(port)
+    follow.floor({ buildingId: 'b', levelId: 'ground' })
+    expect(state.floor.levelId).toBe('ground')
+    expect(state.floor.room).toBeNull()
+    follow.restore()
+    expect(state.floor).toEqual(had)
+  })
+
+  test('the upper floors it hid, and the level display it set', () => {
+    const { state, port } = view({ hideAbove: false, levels: 'solo' })
+    const follow = new FollowPresentation(port)
+    follow.hideAbove(true)
+    follow.levels('stacked')
+    expect(state).toMatchObject({ hideAbove: true, levels: 'stacked' })
+    follow.restore()
+    expect(state).toMatchObject({ hideAbove: false, levels: 'solo' })
+  })
+
+  test('to what the person had before the first change, however many floors it visited', () => {
+    const { state, port } = view()
+    const follow = new FollowPresentation(port)
+    follow.floor({ buildingId: 'b', levelId: 'upper' })
+    follow.floor({ buildingId: 'b', levelId: 'roof' })
+    follow.wall('cutaway')
+    follow.wall('cutaway')
+    follow.restore()
+    expect(state.floor.levelId).toBe('ground')
+    expect(state.wall).toBe('up')
+  })
+
+  test('nothing it did not change: a setting already as Follow wants it is not written', () => {
+    const { writes, port } = view({ wall: 'cutaway', hideAbove: true, levels: 'stacked' })
+    const follow = new FollowPresentation(port)
+    follow.wall('cutaway')
+    follow.hideAbove(true)
+    follow.levels('stacked')
+    follow.floor({ buildingId: 'b', levelId: 'ground' })
+    follow.restore()
+    expect(writes).toEqual([])
+  })
+
+  test('once: ending again, with nothing held, writes nothing', () => {
+    const { writes, port } = view()
+    const follow = new FollowPresentation(port)
+    follow.wall('cutaway')
+    follow.restore()
+    const count = writes.length
+    follow.restore()
+    expect(writes).toHaveLength(count)
+  })
+
+  test('a later session starts from what the person has then', () => {
+    const { state, port } = view()
+    const follow = new FollowPresentation(port)
+    follow.wall('cutaway')
+    follow.restore()
+    state.wall = 'down'
+    follow.wall('cutaway')
+    follow.restore()
+    expect(state.wall).toBe('down')
+  })
+})
+
+describe("the person's own choices stand", () => {
+  test('a wall mode picked while Follow is on is kept, and Follow does not take it back', () => {
+    const { state, writes, port } = view({ wall: 'up' })
+    const follow = new FollowPresentation(port)
+    follow.wall('cutaway')
+    state.wall = 'translucent'
+    follow.wall('cutaway')
+    expect(state.wall).toBe('translucent')
+    follow.restore()
+    expect(state.wall).toBe('translucent')
+    expect(writes).toEqual(['wall:cutaway'])
+  })
+
+  test('a floor picked while Follow is on is kept, and Follow does not select over it', () => {
+    const { state, writes, port } = view()
+    const follow = new FollowPresentation(port)
+    follow.floor({ buildingId: 'b', levelId: 'upper' })
+    state.floor = { ...state.floor, levelId: 'roof' }
+    follow.floor({ buildingId: 'b', levelId: 'upper' })
+    expect(state.floor.levelId).toBe('roof')
+    follow.restore()
+    expect(state.floor.levelId).toBe('roof')
+    expect(writes).toEqual(['floor:upper'])
+  })
+
+  test('the floor stays when the person picked something on it', () => {
+    const { state, writes, port } = view()
+    const follow = new FollowPresentation(port)
+    follow.floor({ buildingId: 'b', levelId: 'upper' })
+    state.floor = { ...state.floor, selectedIds: ['item_x'] }
+    follow.restore()
+    expect(state.floor).toMatchObject({ levelId: 'upper', selectedIds: ['item_x'] })
+    expect(writes).toEqual(['floor:upper'])
+  })
+
+  test('the settings are independent: a wall mode of their own, the floor still goes back', () => {
+    const { state, port } = view()
+    const follow = new FollowPresentation(port)
+    follow.wall('cutaway')
+    follow.floor({ buildingId: 'b', levelId: 'upper' })
+    state.wall = 'down'
+    follow.restore()
+    expect(state.wall).toBe('down')
+    expect(state.floor.levelId).toBe('ground')
+  })
+
+  test("the person's choice is theirs for the session, then Follow may change it again", () => {
+    const { state, port } = view()
+    const follow = new FollowPresentation(port)
+    follow.wall('cutaway')
+    state.wall = 'down'
+    follow.restore()
+    follow.wall('cutaway')
+    expect(port.read().wall).toBe('cutaway')
+    follow.restore()
+    expect(port.read().wall).toBe('down')
+  })
+})

package/src/lib/follow-pascal-presentation.ts

@@ -0,0 +1,129 @@
+import type { WallMode } from '@pascal-app/viewer'
+import type { RoomKey } from './room-selection'
+
+/**
+ * Follow Pascal changes how the building is shown so the build it follows is in view: the walls cut
+ * away when no eye sees its target, the floor it works on selected, the floors above it hidden. This
+ * keeps what it changed, and what the person had before, so that when Follow ends it puts back exactly
+ * that: a setting it changed and the person has not touched since goes back to what the person had.
+ *
+ * A setting the person changes while Follow is on is theirs: it is not put back, and Follow does not
+ * change it again until it has ended. Everything here is arithmetic on a port, so it is tested without
+ * a viewer; the component that owns the port is `FollowPascal`.
+ */
+
+export type LevelMode = 'stacked' | 'exploded' | 'solo' | 'manual'
+
+/** The floor as the person has it: the selection and the room picked in the editor. */
+export type Floor = {
+  buildingId: string | null
+  levelId: string | null
+  zoneId: string | null
+  selectedIds: readonly string[]
+  room: RoomKey | null
+}
+
+export type ViewPresentation = {
+  wall: WallMode
+  levels: LevelMode
+  /** The upper floors are hidden, above the selected one. */
+  hideAbove: boolean
+  floor: Floor
+}
+
+/** What it needs of the viewer and the editor: read the view, and write one part of it. */
+export type PresentationPort = {
+  read(): ViewPresentation
+  setWall(mode: WallMode): void
+  setLevels(mode: LevelMode): void
+  setHideAbove(hide: boolean): void
+  /** Selects a floor in its building. The room and what was picked on the floor before are dropped. */
+  setFloor(floor: { buildingId: string | null; levelId: string }): void
+  /** Puts a floor back as the person had it; what is no longer in the scene is dropped. */
+  putFloor(floor: Floor): void
+}
+
+type Part = keyof ViewPresentation
+
+function sameFloor(a: Floor, b: Floor): boolean {
+  return (
+    a.buildingId === b.buildingId &&
+    a.levelId === b.levelId &&
+    a.zoneId === b.zoneId &&
+    a.selectedIds.length === b.selectedIds.length &&
+    a.selectedIds.every((id, index) => id === b.selectedIds[index]) &&
+    (a.room === b.room ||
+      (!!a.room &&
+        !!b.room &&
+        a.room.levelId === b.room.levelId &&
+        a.room.zoneId === b.room.zoneId))
+  )
+}
+
+function same<K extends Part>(part: K, a: ViewPresentation[K], b: ViewPresentation[K]): boolean {
+  return part === 'floor' ? sameFloor(a as Floor, b as Floor) : a === b
+}
+
+export class FollowPresentation {
+  /** For each part Follow changed: what the person had, and what Follow left it as. */
+  private held: { [K in Part]?: { before: ViewPresentation[K]; set: ViewPresentation[K] } } = {}
+  /** Parts the person changed after Follow did: theirs until Follow ends. */
+  private theirs = new Set<Part>()
+
+  constructor(private port: PresentationPort) {}
+
+  /** The walls as `mode` shows them (cutaway, when no eye sees the target). */
+  wall(mode: WallMode): void {
+    this.change('wall', mode === this.port.read().wall, () => this.port.setWall(mode))
+  }
+
+  levels(mode: LevelMode): void {
+    this.change('levels', mode === this.port.read().levels, () => this.port.setLevels(mode))
+  }
+
+  /** The floors above the selected one hidden, or shown. */
+  hideAbove(hide: boolean): void {
+    this.change('hideAbove', hide === this.port.read().hideAbove, () =>
+      this.port.setHideAbove(hide),
+    )
+  }
+
+  /** The floor a build works on, selected. Nothing changes when it is the selected one. */
+  floor(target: { buildingId: string | null; levelId: string }): void {
+    this.change('floor', this.port.read().floor.levelId === target.levelId, () =>
+      this.port.setFloor(target),
+    )
+  }
+
+  /**
+   * Follow ends: each part it changed goes back to what the person had, unless they have changed it
+   * since. A floor goes back only when the selection is as Follow left it: a room or an element
+   * picked on the floor is the person's choice of that floor.
+   */
+  restore(): void {
+    const now = this.port.read()
+    const { wall, levels, hideAbove, floor } = this.held
+    this.held = {}
+    this.theirs.clear()
+    if (wall && now.wall === wall.set) this.port.setWall(wall.before)
+    if (levels && now.levels === levels.set) this.port.setLevels(levels.before)
+    if (hideAbove && now.hideAbove === hideAbove.set) this.port.setHideAbove(hideAbove.before)
+    if (floor && sameFloor(now.floor, floor.set)) this.port.putFloor(floor.before)
+  }
+
+  private change<K extends Part>(part: K, already: boolean, write: () => void): void {
+    if (this.theirs.has(part)) return
+    const held = this.held[part]
+    const now = this.port.read()[part]
+    if (held && !same(part, now, held.set as ViewPresentation[K])) {
+      // Changed since Follow wrote it: the person's, and not Follow's to put back or to write over.
+      delete this.held[part]
+      this.theirs.add(part)
+      return
+    }
+    if (already) return
+    write()
+    const set = this.port.read()[part]
+    ;(this.held as Record<Part, unknown>)[part] = { before: held ? held.before : now, set }
+  }
+}

package/src/lib/follow-pascal-sight.ts

@@ -0,0 +1,84 @@
+import {
+  type AnyNodeId,
+  type CameraPose,
+  findLevelAncestorId,
+  sceneRegistry,
+  useScene,
+} from '@pascal-app/core'
+import { BATCHED_LAYER, SCENE_LAYER, setSurfaceRaycastLayers, useViewer } from '@pascal-app/viewer'
+import { type Intersection, type Mesh, type Object3D, Raycaster, Vector3 } from 'three'
+import type { FollowWant } from './follow-pascal'
+
+const DRAWN_LAYERS = (1 << SCENE_LAYER) | (1 << BATCHED_LAYER)
+
+/** Query modeled surfaces, including batch sources, but not editor overlays or shadow-only floors. */
+export class FollowSight {
+  private readonly ray = new Raycaster()
+  private readonly eye = new Vector3()
+  private readonly direction = new Vector3()
+  private readonly hits: Intersection[] = []
+  private meshes: Mesh[] = []
+
+  constructor(private scene: Object3D) {
+    setSurfaceRaycastLayers(this.ray.layers)
+  }
+
+  refresh(want: FollowWant): void {
+    this.meshes = []
+    const root = this.scene.getObjectByName('scene-renderer')
+    if (!root) return
+    const targets = new Set(
+      want.nodeIds?.flatMap((id) => {
+        const object = sceneRegistry.nodes.get(id)
+        return object ? [object] : []
+      }),
+    )
+    const owners = new Map([...sceneRegistry.nodes].map(([id, object]) => [object, id]))
+    const { nodes } = useScene.getState()
+    const viewer = useViewer.getState()
+    const selected = viewer.selection.levelId ? nodes[viewer.selection.levelId] : undefined
+    root.updateWorldMatrix(true, true)
+    root.traverseVisible((object) => {
+      const mesh = object as Mesh
+      if (!mesh.isMesh || (mesh.layers.mask & DRAWN_LAYERS) === 0) return
+      for (let ancestor: Object3D | null = object; ancestor; ancestor = ancestor.parent) {
+        if (targets.has(ancestor)) return
+        const id = owners.get(ancestor)
+        if (!id) continue
+        if (nodes[id as AnyNodeId]?.visible === false) return
+        // A batched source can retain its batch layer while its floor is shadow-only.
+        if (
+          mesh.layers.isEnabled(BATCHED_LAYER) &&
+          viewer.hideLevelsAboveSelection &&
+          selected?.type === 'level'
+        ) {
+          const levelId = findLevelAncestorId(id as AnyNodeId, nodes)
+          const level = levelId ? nodes[levelId as AnyNodeId] : undefined
+          if (
+            level?.type === 'level' &&
+            level.level > selected.level &&
+            !viewer.levelsRevealing.includes(level.id)
+          )
+            return
+        }
+      }
+      this.meshes.push(mesh)
+    })
+  }
+
+  clear(pose: CameraPose): boolean {
+    this.eye.set(...pose.position)
+    this.direction.set(...pose.target).sub(this.eye)
+    this.ray.far = this.direction.length() - 0.02
+    this.ray.set(this.eye, this.direction.normalize())
+    this.hits.length = 0
+    this.ray.intersectObjects(this.meshes, false, this.hits)
+    return !this.hits.some((hit) => {
+      const mesh = hit.object as Mesh
+      const material = Array.isArray(mesh.material)
+        ? mesh.material[hit.face?.materialIndex ?? 0]
+        : mesh.material
+      return material?.visible && material.opacity > 0.1 && material.colorWrite
+    })
+  }
+}