diff --git a/packages/editor/src/components/ui/panels/elevator-panel.tsx b/packages/editor/src/components/ui/panels/elevator-panel.tsx
new file mode 100644
index 00000000..f5e4fa9d
--- /dev/null
+++ b/packages/editor/src/components/ui/panels/elevator-panel.tsx
@@ -0,0 +1,471 @@
+'use client'
+
+import {
+ type AnyNode,
+ type AnyNodeId,
+ type ElevatorNode,
+ ElevatorNode as ElevatorNodeSchema,
+ type LevelNode,
+ useInteractive,
+ useLiveNodeOverrides,
+ useScene,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { Copy, Move, Send, Trash2 } from 'lucide-react'
+import { useCallback, useEffect } from 'react'
+import { useShallow } from 'zustand/react/shallow'
+import { sfxEmitter } from '../../../lib/sfx-bus'
+import useEditor from '../../../store/use-editor'
+import { ActionButton, ActionGroup } from '../controls/action-button'
+import { MetricControl } from '../controls/metric-control'
+import { PanelSection } from '../controls/panel-section'
+import { SliderControl } from '../controls/slider-control'
+import { PanelWrapper } from './panel-wrapper'
+
+function findLevelId(levels: LevelNode[], levelId: string | null | undefined) {
+ if (!levelId) return null
+ return levels.some((level) => level.id === levelId) ? levelId : null
+}
+
+function getLegacyServedLevels(node: ElevatorNode | undefined, levels: LevelNode[]) {
+ if (!node || node.fromLevelId || node.toLevelId || !node.servedLevelIds?.length) return []
+ const servedIds = new Set(node.servedLevelIds)
+ return levels.filter((level) => servedIds.has(level.id))
+}
+
+function getResolvedFromLevelId(node: ElevatorNode | undefined, levels: LevelNode[]) {
+ if (!node) return levels[0]?.id ?? ''
+ const legacyServedLevels = getLegacyServedLevels(node, levels)
+ return (
+ findLevelId(levels, node.fromLevelId) ??
+ legacyServedLevels[0]?.id ??
+ findLevelId(levels, node.defaultLevelId) ??
+ levels[0]?.id ??
+ ''
+ )
+}
+
+function getResolvedToLevelId(
+ node: ElevatorNode | undefined,
+ levels: LevelNode[],
+ fromLevelId: string,
+) {
+ if (!node) return levels[0]?.id ?? ''
+
+ const explicitTo = findLevelId(levels, node.toLevelId)
+ if (explicitTo) return explicitTo
+ const legacyServedLevels = getLegacyServedLevels(node, levels)
+ const legacyTo = legacyServedLevels[legacyServedLevels.length - 1]?.id
+ if (legacyTo) return legacyTo
+
+ const fromIndex = levels.findIndex((level) => level.id === fromLevelId)
+ const fallbackIndex = fromIndex >= 0 ? Math.min(fromIndex + 1, levels.length - 1) : 0
+ return levels[fallbackIndex]?.id ?? fromLevelId
+}
+
+function getServiceLevels(levels: LevelNode[], fromLevelId: string, toLevelId: string) {
+ const fromIndex = levels.findIndex((level) => level.id === fromLevelId)
+ const toIndex = levels.findIndex((level) => level.id === toLevelId)
+ if (fromIndex < 0 && toIndex < 0) return []
+
+ const resolvedFromIndex = fromIndex >= 0 ? fromIndex : toIndex
+ const resolvedToIndex =
+ toIndex >= 0 ? toIndex : Math.min(Math.max(resolvedFromIndex, 0) + 1, levels.length - 1)
+ const minIndex = Math.min(resolvedFromIndex, resolvedToIndex)
+ const maxIndex = Math.max(resolvedFromIndex, resolvedToIndex)
+
+ return levels.slice(minIndex, maxIndex + 1)
+}
+
+function stripDuplicateFlags(metadata: ElevatorNode['metadata']) {
+ if (typeof metadata !== 'object' || metadata === null || Array.isArray(metadata)) {
+ return metadata
+ }
+
+ const nextMeta = { ...(metadata as Record
) }
+ delete nextMeta.isNew
+ delete nextMeta.isTransient
+ return nextMeta as ElevatorNode['metadata']
+}
+
+type ElevatorMetricKey = 'width' | 'depth' | 'cabHeight' | 'doorWidth' | 'doorHeight'
+
+export function ElevatorPanel() {
+ const selectedId = useViewer((s) => s.selection.selectedIds[0])
+ const selectedCount = useViewer((s) => s.selection.selectedIds.length)
+ const setSelection = useViewer((s) => s.setSelection)
+ const updateNode = useScene((s) => s.updateNode)
+ const createNode = useScene((s) => s.createNode)
+ const setMovingNode = useEditor((s) => s.setMovingNode)
+ const runtime = useInteractive(
+ useShallow((s) => {
+ const state = selectedId ? s.elevators[selectedId as AnyNodeId] : null
+ if (!state) return null
+ return {
+ currentLevelId: state.currentLevelId,
+ queue: state.queue,
+ targetLevelId: state.targetLevelId,
+ }
+ }),
+ )
+
+ const node = useScene((s) =>
+ selectedId ? (s.nodes[selectedId as AnyNode['id']] as ElevatorNode | undefined) : undefined,
+ )
+ const liveOverrides = useLiveNodeOverrides((s) =>
+ selectedId ? s.get(selectedId as AnyNodeId) : undefined,
+ )
+
+ useEffect(() => {
+ return () => {
+ if (selectedId) useLiveNodeOverrides.getState().clear(selectedId as AnyNodeId)
+ }
+ }, [selectedId])
+
+ const levels = useScene(
+ useShallow((s) => {
+ if (!(node?.parentId && s.nodes[node.parentId as AnyNodeId]?.type === 'building')) return []
+ const building = s.nodes[node.parentId as AnyNodeId]
+ if (building?.type !== 'building') return []
+ return building.children
+ .map((childId) => s.nodes[childId as AnyNodeId])
+ .filter((entry): entry is LevelNode => entry?.type === 'level')
+ .sort((left, right) => left.level - right.level)
+ }),
+ )
+
+ const handleUpdate = useCallback(
+ (updates: Partial) => {
+ if (!selectedId) return
+ updateNode(selectedId as AnyNode['id'], updates)
+ },
+ [selectedId, updateNode],
+ )
+
+ const clearLivePreview = useCallback(() => {
+ if (selectedId) useLiveNodeOverrides.getState().clear(selectedId as AnyNodeId)
+ }, [selectedId])
+
+ const previewMetric = useCallback(
+ (key: K, value: ElevatorNode[K]) => {
+ if (!selectedId) return
+ useLiveNodeOverrides.getState().set(selectedId as AnyNodeId, { [key]: value })
+ },
+ [selectedId],
+ )
+
+ const commitMetric = useCallback(
+ (key: K, value: ElevatorNode[K]) => {
+ if (!selectedId) return
+
+ const hasChange = !(node && Math.abs(Number(node[key]) - Number(value)) <= 1e-6)
+ if (hasChange) {
+ updateNode(selectedId as AnyNode['id'], { [key]: value } as Partial)
+ }
+ useLiveNodeOverrides.getState().clear(selectedId as AnyNodeId)
+ },
+ [node, selectedId, updateNode],
+ )
+
+ const handleClose = useCallback(() => {
+ clearLivePreview()
+ setSelection({ selectedIds: [] })
+ }, [clearLivePreview, setSelection])
+
+ const handleMove = useCallback(() => {
+ if (!node) return
+ sfxEmitter.emit('sfx:item-pick')
+ clearLivePreview()
+ setMovingNode(node)
+ setSelection({ selectedIds: [] })
+ }, [clearLivePreview, node, setMovingNode, setSelection])
+
+ const handleDuplicate = useCallback(() => {
+ if (!(node && node.parentId)) return
+ sfxEmitter.emit('sfx:item-pick')
+
+ const duplicate = ElevatorNodeSchema.parse({
+ ...structuredClone(node),
+ id: undefined,
+ name: node.name ? `${node.name} Copy` : 'Elevator Copy',
+ position: [node.position[0] + 1, node.position[1], node.position[2] + 1],
+ metadata: { ...(stripDuplicateFlags(node.metadata) as Record), isNew: true },
+ })
+
+ createNode(duplicate, node.parentId as AnyNodeId)
+ clearLivePreview()
+ setMovingNode(duplicate)
+ setSelection({ selectedIds: [] })
+ }, [clearLivePreview, node, createNode, setMovingNode, setSelection])
+
+ const handleDelete = useCallback(() => {
+ if (!(selectedId && node)) return
+ sfxEmitter.emit('sfx:structure-delete')
+ clearLivePreview()
+ useScene.getState().deleteNode(selectedId as AnyNodeId)
+ setSelection({ selectedIds: [] })
+ }, [clearLivePreview, selectedId, node, setSelection])
+
+ const requestLevel = useCallback(
+ (levelId: LevelNode['id']) => {
+ if (!node) return
+ useInteractive.getState().requestElevator(node.id as AnyNodeId, levelId as AnyNodeId)
+ },
+ [node],
+ )
+
+ const handleServiceBoundaryChange = useCallback(
+ (field: 'fromLevelId' | 'toLevelId', levelId: string) => {
+ if (!node) return
+ const nextFromLevelId =
+ field === 'fromLevelId' ? levelId : getResolvedFromLevelId(node, levels)
+ const nextToLevelId =
+ field === 'toLevelId' ? levelId : getResolvedToLevelId(node, levels, nextFromLevelId)
+ const nextServedLevels = getServiceLevels(levels, nextFromLevelId, nextToLevelId)
+ const currentDefaultIsServed = nextServedLevels.some(
+ (level) => level.id === node.defaultLevelId,
+ )
+
+ handleUpdate({
+ [field]: levelId || null,
+ defaultLevelId: currentDefaultIsServed
+ ? node.defaultLevelId
+ : nextFromLevelId || nextServedLevels[0]?.id || null,
+ servedLevelIds: undefined,
+ } as Partial)
+ },
+ [node, levels, handleUpdate],
+ )
+
+ if (!(node && node.type === 'elevator' && selectedId && selectedCount === 1)) return null
+
+ const displayNode = liveOverrides ? ({ ...node, ...liveOverrides } as ElevatorNode) : node
+ const fromLevelId = getResolvedFromLevelId(node, levels)
+ const toLevelId = getResolvedToLevelId(node, levels, fromLevelId)
+ const servedLevels = getServiceLevels(levels, fromLevelId, toLevelId)
+ const defaultLevelOptions = servedLevels.length > 0 ? servedLevels : levels
+ const selectedDefaultLevelId = defaultLevelOptions.some(
+ (level) => level.id === node.defaultLevelId,
+ )
+ ? (node.defaultLevelId ?? '')
+ : fromLevelId
+ const activeLevelId =
+ runtime?.currentLevelId ??
+ (servedLevels.some((level) => level.id === node.defaultLevelId)
+ ? node.defaultLevelId
+ : fromLevelId || levels[0]?.id) ??
+ null
+ const queuedLevelIds = new Set()
+ for (const levelId of runtime?.queue ?? []) queuedLevelIds.add(levelId)
+ if (runtime?.targetLevelId) queuedLevelIds.add(runtime.targetLevelId)
+
+ return (
+
+
+
+ } label="Move" onClick={handleMove} />
+ }
+ label="Duplicate"
+ onClick={handleDuplicate}
+ />
+ }
+ label="Delete"
+ onClick={handleDelete}
+ />
+
+
+
+
+ previewMetric('width', value)}
+ onCommit={(value) => commitMetric('width', value)}
+ precision={2}
+ restoreOnCommit={false}
+ step={0.05}
+ unit="m"
+ value={displayNode.width}
+ />
+ previewMetric('depth', value)}
+ onCommit={(value) => commitMetric('depth', value)}
+ precision={2}
+ restoreOnCommit={false}
+ step={0.05}
+ unit="m"
+ value={displayNode.depth}
+ />
+ previewMetric('cabHeight', value)}
+ onCommit={(value) => commitMetric('cabHeight', value)}
+ precision={2}
+ restoreOnCommit={false}
+ step={0.05}
+ unit="m"
+ value={displayNode.cabHeight}
+ />
+
+
+
+ previewMetric('doorWidth', value)}
+ onCommit={(value) => commitMetric('doorWidth', value)}
+ precision={2}
+ restoreOnCommit={false}
+ step={0.05}
+ unit="m"
+ value={displayNode.doorWidth}
+ />
+ previewMetric('doorHeight', value)}
+ onCommit={(value) => commitMetric('doorHeight', value)}
+ precision={2}
+ restoreOnCommit={false}
+ step={0.05}
+ unit="m"
+ value={displayNode.doorHeight}
+ />
+
+
+
+
+
+
+ From
+
+
+
+
+
+
+ To
+
+
+
+
+
+ Default Floor
+
+
+
+ {servedLevels.map((level) => {
+ const isActive = activeLevelId === level.id
+ const isQueued = queuedLevelIds.has(level.id)
+ return (
+
+ )
+ })}
+
+
+
+
+ handleUpdate({ speed: value })}
+ precision={1}
+ step={0.1}
+ unit="m/s"
+ value={node.speed}
+ />
+ handleUpdate({ doorDurationMs: value })}
+ step={50}
+ unit="ms"
+ value={node.doorDurationMs}
+ />
+ handleUpdate({ dwellMs: value })}
+ step={100}
+ unit="ms"
+ value={node.dwellMs}
+ />
+
+
+ )
+}
diff --git a/packages/editor/src/components/ui/panels/node-display.ts b/packages/editor/src/components/ui/panels/node-display.ts
index 3b545680..16ee20d9 100644
--- a/packages/editor/src/components/ui/panels/node-display.ts
+++ b/packages/editor/src/components/ui/panels/node-display.ts
@@ -13,6 +13,7 @@ const TYPE_DEFAULTS: Record = {
slab: { icon: '/icons/floor.png', label: 'Slab' },
ceiling: { icon: '/icons/ceiling.png', label: 'Ceiling' },
column: { icon: '/icons/column.png', label: 'Column' },
+ elevator: { icon: '/icons/elevator.svg', label: 'Elevator' },
fence: { icon: '/icons/fence.png', label: 'Fence' },
roof: { icon: '/icons/roof.png', label: 'Roof' },
'roof-segment': { icon: '/icons/roof.png', label: 'Roof segment' },
diff --git a/packages/editor/src/components/ui/panels/panel-manager.tsx b/packages/editor/src/components/ui/panels/panel-manager.tsx
index e948ab80..1052238f 100755
--- a/packages/editor/src/components/ui/panels/panel-manager.tsx
+++ b/packages/editor/src/components/ui/panels/panel-manager.tsx
@@ -7,6 +7,7 @@ import {
type CeilingNode,
type ColumnNode,
type DoorNode,
+ type ElevatorNode,
type FenceNode,
type ItemNode,
type RoofNode,
@@ -26,6 +27,7 @@ import useEditor from '../../../store/use-editor'
import { CeilingPanel } from './ceiling-panel'
import { ColumnPanel } from './column-panel'
import { DoorPanel } from './door-panel'
+import { ElevatorPanel } from './elevator-panel'
import { FencePanel } from './fence-panel'
import { ItemPanel } from './item-panel'
import { MobilePanelSheet } from './mobile-panel-sheet'
@@ -46,6 +48,7 @@ type MovableNode =
| ItemNode
| WindowNode
| DoorNode
+ | ElevatorNode
| CeilingNode
| ColumnNode
| SlabNode
@@ -61,6 +64,7 @@ const MOVABLE_TYPES = new Set([
'item',
'window',
'door',
+ 'elevator',
'ceiling',
'column',
'slab',
@@ -102,6 +106,8 @@ function panelForType(type: string | null) {
return
case 'door':
return
+ case 'elevator':
+ return
case 'window':
return
default:
@@ -264,6 +270,8 @@ export function PanelManager() {
return
case 'door':
return
+ case 'elevator':
+ return
case 'window':
return
}
diff --git a/packages/editor/src/components/ui/panels/slab-panel.tsx b/packages/editor/src/components/ui/panels/slab-panel.tsx
index b44b1a64..0034c7ca 100755
--- a/packages/editor/src/components/ui/panels/slab-panel.tsx
+++ b/packages/editor/src/components/ui/panels/slab-panel.tsx
@@ -91,7 +91,7 @@ export function SlabPanel() {
(index: number) => {
if (!selectedId) return
const currentHoles = node?.holes || []
- if (node?.holeMetadata?.[index]?.source === 'stair') return
+ if ((node?.holeMetadata?.[index]?.source ?? 'manual') !== 'manual') return
const newHoles = currentHoles.filter((_, i) => i !== index)
const currentMetadata = currentHoles.map(
(_, metadataIndex) => node?.holeMetadata?.[metadataIndex] ?? { source: 'manual' as const },
@@ -173,7 +173,8 @@ export function SlabPanel() {
const isEditing =
editingHole?.nodeId === selectedId && editingHole?.holeIndex === index
const source = node.holeMetadata?.[index]?.source ?? 'manual'
- const isAutoHole = source === 'stair'
+ const isAutoHole = source !== 'manual'
+ const autoLabel = source === 'elevator' ? 'Auto elevator cutout' : 'Auto stair cutout'
return (
{holeArea.toFixed(2)} m² · {hole.length} pts ·{' '}
- {isAutoHole ? 'Auto stair cutout' : 'Manual'}
+ {isAutoHole ? autoLabel : 'Manual'}
diff --git a/packages/editor/src/components/ui/sidebar/panels/site-panel/building-tree-node.tsx b/packages/editor/src/components/ui/sidebar/panels/site-panel/building-tree-node.tsx
index fdbae4e9..5407b929 100644
--- a/packages/editor/src/components/ui/sidebar/panels/site-panel/building-tree-node.tsx
+++ b/packages/editor/src/components/ui/sidebar/panels/site-panel/building-tree-node.tsx
@@ -39,8 +39,10 @@ export const BuildingTreeNode = memo(function BuildingTreeNode({
const handleAddLevel = (e: React.MouseEvent) => {
e.stopPropagation()
+ const nodes = useScene.getState().nodes
+ const levelCount = children.filter((childId) => nodes[childId]?.type === 'level').length
const newLevel = LevelNode.parse({
- level: children.length,
+ level: levelCount,
children: [],
parentId: nodeId,
})
diff --git a/packages/editor/src/components/ui/sidebar/panels/site-panel/elevator-tree-node.tsx b/packages/editor/src/components/ui/sidebar/panels/site-panel/elevator-tree-node.tsx
new file mode 100644
index 00000000..0f345171
--- /dev/null
+++ b/packages/editor/src/components/ui/sidebar/panels/site-panel/elevator-tree-node.tsx
@@ -0,0 +1,75 @@
+import { type AnyNodeId, type ElevatorNode, useScene } from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import Image from 'next/image'
+import { memo, useCallback, useState } from 'react'
+import useEditor from './../../../../../store/use-editor'
+import { InlineRenameInput } from './inline-rename-input'
+import { focusTreeNode, handleTreeSelection, TreeNodeWrapper } from './tree-node'
+import { TreeNodeActions } from './tree-node-actions'
+
+interface ElevatorTreeNodeProps {
+ nodeId: AnyNodeId
+ depth: number
+ isLast?: boolean
+}
+
+export const ElevatorTreeNode = memo(function ElevatorTreeNode({
+ nodeId,
+ depth,
+ isLast,
+}: ElevatorTreeNodeProps) {
+ const [isEditing, setIsEditing] = useState(false)
+ const isVisible = useScene((s) => s.nodes[nodeId]?.visible !== false)
+ const node = useScene((s) => s.nodes[nodeId] as ElevatorNode | undefined)
+ const isSelected = useViewer((state) => state.selection.selectedIds.includes(nodeId))
+ const isHovered = useViewer((state) => state.hoveredId === nodeId)
+ const setSelection = useViewer((state) => state.setSelection)
+ const setHoveredId = useViewer((state) => state.setHoveredId)
+
+ const handleClick = useCallback(
+ (event: React.MouseEvent) => {
+ event.stopPropagation()
+ const handled = handleTreeSelection(
+ event,
+ nodeId,
+ useViewer.getState().selection.selectedIds,
+ setSelection,
+ )
+ if (!handled && useEditor.getState().phase === 'furnish') {
+ useEditor.getState().setPhase('structure')
+ }
+ },
+ [nodeId, setSelection],
+ )
+
+ return (
+
}
+ depth={depth}
+ expanded={false}
+ hasChildren={false}
+ icon={
+
+ }
+ isHovered={isHovered}
+ isLast={isLast}
+ isSelected={isSelected}
+ isVisible={isVisible}
+ label={
+
setIsEditing(true)}
+ onStopEditing={() => setIsEditing(false)}
+ />
+ }
+ nodeId={nodeId}
+ onClick={handleClick}
+ onDoubleClick={() => focusTreeNode(nodeId)}
+ onMouseEnter={() => setHoveredId(nodeId)}
+ onMouseLeave={() => setHoveredId(null)}
+ onToggle={() => {}}
+ />
+ )
+})
diff --git a/packages/editor/src/components/ui/sidebar/panels/site-panel/tree-node.tsx b/packages/editor/src/components/ui/sidebar/panels/site-panel/tree-node.tsx
index 2e7ba5df..3b0717d0 100644
--- a/packages/editor/src/components/ui/sidebar/panels/site-panel/tree-node.tsx
+++ b/packages/editor/src/components/ui/sidebar/panels/site-panel/tree-node.tsx
@@ -58,6 +58,7 @@ import { BuildingTreeNode } from './building-tree-node'
import { CeilingTreeNode } from './ceiling-tree-node'
import { ColumnTreeNode } from './column-tree-node'
import { DoorTreeNode } from './door-tree-node'
+import { ElevatorTreeNode } from './elevator-tree-node'
import { FenceTreeNode } from './fence-tree-node'
import { ItemTreeNode } from './item-tree-node'
import { LevelTreeNode } from './level-tree-node'
@@ -87,6 +88,8 @@ export const TreeNode = memo(function TreeNode({ nodeId, depth = 0, isLast }: Tr
return
case 'column':
return
+ case 'elevator':
+ return
case 'level':
return
case 'slab':
diff --git a/packages/editor/src/hooks/use-contextual-tools.ts b/packages/editor/src/hooks/use-contextual-tools.ts
index ebb288a6..e51121b1 100644
--- a/packages/editor/src/hooks/use-contextual-tools.ts
+++ b/packages/editor/src/hooks/use-contextual-tools.ts
@@ -28,6 +28,7 @@ export function useContextualTools() {
'slab',
'ceiling',
'roof',
+ 'elevator',
'door',
'window',
]
diff --git a/packages/editor/src/hooks/use-keyboard.ts b/packages/editor/src/hooks/use-keyboard.ts
index 3183fd56..cc05f3ac 100755
--- a/packages/editor/src/hooks/use-keyboard.ts
+++ b/packages/editor/src/hooks/use-keyboard.ts
@@ -133,13 +133,19 @@ export const useKeyboard = ({
const { buildingId, levelId } = useViewer.getState().selection
if (buildingId) {
const building = useScene.getState().nodes[buildingId]
- if (building && building.type === 'building' && building.children.length > 0) {
- const currentIdx = levelId ? building.children.indexOf(levelId as any) : -1
- const nextIdx = currentIdx < building.children.length - 1 ? currentIdx + 1 : currentIdx
+ const levels =
+ building?.type === 'building'
+ ? building.children.filter(
+ (childId) => useScene.getState().nodes[childId as AnyNodeId]?.type === 'level',
+ )
+ : []
+ if (levels.length > 0) {
+ const currentIdx = levelId ? levels.indexOf(levelId as any) : -1
+ const nextIdx = currentIdx < levels.length - 1 ? currentIdx + 1 : currentIdx
if (nextIdx !== -1 && nextIdx !== currentIdx) {
- useViewer.getState().setSelection({ levelId: building.children[nextIdx] as any })
+ useViewer.getState().setSelection({ levelId: levels[nextIdx] as any })
} else if (currentIdx === -1) {
- useViewer.getState().setSelection({ levelId: building.children[0] as any })
+ useViewer.getState().setSelection({ levelId: levels[0] as any })
}
}
}
@@ -148,15 +154,19 @@ export const useKeyboard = ({
const { buildingId, levelId } = useViewer.getState().selection
if (buildingId) {
const building = useScene.getState().nodes[buildingId]
- if (building && building.type === 'building' && building.children.length > 0) {
- const currentIdx = levelId ? building.children.indexOf(levelId as any) : -1
+ const levels =
+ building?.type === 'building'
+ ? building.children.filter(
+ (childId) => useScene.getState().nodes[childId as AnyNodeId]?.type === 'level',
+ )
+ : []
+ if (levels.length > 0) {
+ const currentIdx = levelId ? levels.indexOf(levelId as any) : -1
const prevIdx = currentIdx > 0 ? currentIdx - 1 : currentIdx
if (prevIdx !== -1 && prevIdx !== currentIdx) {
- useViewer.getState().setSelection({ levelId: building.children[prevIdx] as any })
+ useViewer.getState().setSelection({ levelId: levels[prevIdx] as any })
} else if (currentIdx === -1) {
- useViewer
- .getState()
- .setSelection({ levelId: building.children[building.children.length - 1] as any })
+ useViewer.getState().setSelection({ levelId: levels[levels.length - 1] as any })
}
}
}
diff --git a/packages/editor/src/lib/history.ts b/packages/editor/src/lib/history.ts
index bdd37fbb..281a476e 100644
--- a/packages/editor/src/lib/history.ts
+++ b/packages/editor/src/lib/history.ts
@@ -1,6 +1,7 @@
-import { useLiveTransforms, useScene } from '@pascal-app/core'
+import { useLiveNodeOverrides, useLiveTransforms, useScene } from '@pascal-app/core'
function refreshSceneAfterHistoryJump() {
+ useLiveNodeOverrides.getState().clearAll()
useLiveTransforms.getState().clearAll()
const state = useScene.getState()
diff --git a/packages/editor/src/store/use-editor.tsx b/packages/editor/src/store/use-editor.tsx
index b3aa2616..5536c13d 100644
--- a/packages/editor/src/store/use-editor.tsx
+++ b/packages/editor/src/store/use-editor.tsx
@@ -7,6 +7,7 @@ import {
type CeilingNode,
type ColumnNode,
type DoorNode,
+ type ElevatorNode,
type FenceNode,
type ItemNode,
type LevelNode,
@@ -58,6 +59,7 @@ export type StructureTool =
| 'ceiling'
| 'roof'
| 'column'
+ | 'elevator'
| 'stair'
| 'item'
| 'zone'
@@ -138,6 +140,7 @@ type EditorState = {
| ItemNode
| WindowNode
| DoorNode
+ | ElevatorNode
| FenceNode
| CeilingNode
| ColumnNode
@@ -155,6 +158,7 @@ type EditorState = {
| ItemNode
| WindowNode
| DoorNode
+ | ElevatorNode
| FenceNode
| CeilingNode
| ColumnNode
@@ -449,9 +453,14 @@ export function selectDefaultBuildingAndLevel() {
})
if (level0Id) {
viewer.setSelection({ levelId: level0Id as LevelNode['id'] })
- } else if (buildingNode.children[0]) {
+ } else {
// Fallback to first level if level 0 doesn't exist
- viewer.setSelection({ levelId: buildingNode.children[0] as LevelNode['id'] })
+ const firstLevelId = buildingNode.children.find(
+ (childId) => scene.nodes[childId]?.type === 'level',
+ )
+ if (firstLevelId) {
+ viewer.setSelection({ levelId: firstLevelId as LevelNode['id'] })
+ }
}
}
}
@@ -580,6 +589,7 @@ const useEditor = create()(
| ItemNode
| WindowNode
| DoorNode
+ | ElevatorNode
| FenceNode
| CeilingNode
| SlabNode
diff --git a/packages/viewer/package.json b/packages/viewer/package.json
index 77c4ed75..6915df02 100644
--- a/packages/viewer/package.json
+++ b/packages/viewer/package.json
@@ -29,7 +29,6 @@
"three": "^0.184"
},
"dependencies": {
- "polygon-clipping": "^0.15.7",
"three-bvh-csg": "^0.0.18",
"three-mesh-bvh": "^0.9.8",
"zustand": "^5"
diff --git a/packages/viewer/src/components/renderers/elevator/elevator-renderer.tsx b/packages/viewer/src/components/renderers/elevator/elevator-renderer.tsx
new file mode 100644
index 00000000..0b5dc355
--- /dev/null
+++ b/packages/viewer/src/components/renderers/elevator/elevator-renderer.tsx
@@ -0,0 +1,811 @@
+import {
+ type AnyNodeId,
+ type ElevatorNode,
+ useInteractive,
+ useLiveNodeOverrides,
+ useRegistry,
+ useScene,
+} from '@pascal-app/core'
+import { useFrame, type ThreeEvent } from '@react-three/fiber'
+import { useEffect, useMemo, useRef } from 'react'
+import type { Group } from 'three'
+import { useShallow } from 'zustand/react/shallow'
+import { useNodeEvents } from '../../../hooks/use-node-events'
+import { resolveElevatorLevels } from '../../../systems/elevator/elevator-utils'
+
+const SHAFT_WALL_COLOR = '#d7dce4'
+const SHAFT_SIDE_COLOR = '#4b5563'
+const SHAFT_TRIM_COLOR = '#eef2f7'
+const CAB_COLOR = '#d7dde5'
+const GLASS_COLOR = '#f8fafc'
+const DOOR_COLOR = '#8e98a6'
+const PANEL_COLOR = '#1f2937'
+
+type SegmentName =
+ | 'bottom'
+ | 'lowerLeft'
+ | 'lowerRight'
+ | 'middle'
+ | 'top'
+ | 'upperLeft'
+ | 'upperRight'
+
+const DIGIT_SEGMENTS: Record = {
+ '0': ['top', 'upperLeft', 'upperRight', 'lowerLeft', 'lowerRight', 'bottom'],
+ '1': ['upperRight', 'lowerRight'],
+ '2': ['top', 'upperRight', 'middle', 'lowerLeft', 'bottom'],
+ '3': ['top', 'upperRight', 'middle', 'lowerRight', 'bottom'],
+ '4': ['upperLeft', 'upperRight', 'middle', 'lowerRight'],
+ '5': ['top', 'upperLeft', 'middle', 'lowerRight', 'bottom'],
+ '6': ['top', 'upperLeft', 'middle', 'lowerLeft', 'lowerRight', 'bottom'],
+ '7': ['top', 'upperRight', 'lowerRight'],
+ '8': ['top', 'upperLeft', 'upperRight', 'middle', 'lowerLeft', 'lowerRight', 'bottom'],
+ '9': ['top', 'upperLeft', 'upperRight', 'middle', 'lowerRight', 'bottom'],
+ '-': ['middle'],
+}
+
+const SEGMENT_PROPS: Record<
+ SegmentName,
+ { position: [number, number, number]; size: [number, number, number] }
+> = {
+ bottom: { position: [0, -0.44, 0], size: [0.56, 0.11, 0.018] },
+ lowerLeft: { position: [-0.32, -0.22, 0], size: [0.11, 0.42, 0.018] },
+ lowerRight: { position: [0.32, -0.22, 0], size: [0.11, 0.42, 0.018] },
+ middle: { position: [0, 0, 0], size: [0.52, 0.1, 0.018] },
+ top: { position: [0, 0.44, 0], size: [0.56, 0.11, 0.018] },
+ upperLeft: { position: [-0.32, 0.22, 0], size: [0.11, 0.42, 0.018] },
+ upperRight: { position: [0.32, 0.22, 0], size: [0.11, 0.42, 0.018] },
+}
+
+function MeshButtonLabel({
+ color,
+ label,
+ position,
+ scale,
+}: {
+ color: string
+ label: string
+ position: [number, number, number]
+ scale: number
+}) {
+ const characters = label.split('').filter((character) => DIGIT_SEGMENTS[character])
+ const spacing = 0.72 * scale
+ const startX = -((characters.length - 1) * spacing) / 2
+
+ if (characters.length === 0) return null
+
+ return (
+
+ {characters.map((character, charIndex) => (
+
+ {(DIGIT_SEGMENTS[character] ?? []).map((segment) => {
+ const props = SEGMENT_PROPS[segment]
+ return (
+
+
+
+
+ )
+ })}
+
+ ))}
+
+ )
+}
+
+function ElevatorDirectionGlyph({
+ color,
+ direction,
+ position,
+ scale,
+}: {
+ color: string
+ direction: 'down' | 'up' | null
+ position: [number, number, number]
+ scale: number
+}) {
+ if (!direction) {
+ return (
+
+
+
+
+ )
+ }
+
+ const ySign = direction === 'up' ? 1 : -1
+ return (
+
+
+
+
+
+
+
+
+
+
+ )
+}
+
+function ElevatorFloorIndicator({
+ active,
+ direction,
+ faceSign = -1,
+ label,
+ position,
+ scale = 1,
+}: {
+ active: boolean
+ direction: 'down' | 'up' | null
+ faceSign?: -1 | 1
+ label: string
+ position: [number, number, number]
+ scale?: number
+}) {
+ const glowColor = active ? '#38bdf8' : '#94a3b8'
+ const screenColor = active ? '#041f2f' : '#111827'
+ const displayLabel = label || '-'
+ const screenZ = faceSign * 0.026 * scale
+ const glyphZ = faceSign * 0.041 * scale
+
+ return (
+
+
+
+
+
+
+
+
+
+
+
+
+ )
+}
+
+function ElevatorMeshButton({
+ active,
+ buttonKind,
+ elevatorId,
+ faceSign = -1,
+ label,
+ levelId,
+ onRequest,
+ position,
+ queued,
+ radius = 0.055,
+}: {
+ active: boolean
+ buttonKind: 'cab' | 'landing'
+ elevatorId: AnyNodeId
+ faceSign?: -1 | 1
+ label?: string
+ levelId: AnyNodeId
+ onRequest: () => void
+ position: [number, number, number]
+ queued: boolean
+ radius?: number
+}) {
+ const buttonColor = active ? '#38bdf8' : queued ? '#fbbf24' : '#d6dde7'
+ const labelColor = active || queued ? '#111827' : '#334155'
+ const ringColor = active ? '#0ea5e9' : queued ? '#f59e0b' : '#64748b'
+ const depth = active ? 0.028 : 0.04
+ const faceZ = faceSign * (depth / 2 + 0.004)
+ const userData = useMemo(
+ () => ({
+ elevatorButton: {
+ elevatorId,
+ kind: buttonKind,
+ levelId,
+ },
+ }),
+ [buttonKind, elevatorId, levelId],
+ )
+
+ const press = (event: ThreeEvent) => {
+ if (event.button !== 0) return
+ onRequest()
+ }
+
+ return (
+
+ {(active || queued) && (
+
+
+
+
+ )}
+
+
+
+
+
+
+
+
+ {label && (
+
+ )}
+
+ )
+}
+
+function DoorLeaf({
+ animated,
+ doorOpen,
+ height,
+ side,
+ width,
+ y,
+ z,
+}: {
+ animated?:
+ | {
+ elevatorId: AnyNodeId
+ kind: 'cab'
+ }
+ | {
+ elevatorId: AnyNodeId
+ kind: 'landing'
+ levelId: AnyNodeId
+ }
+ doorOpen: number
+ height: number
+ side: 'left' | 'right'
+ width: number
+ y: number
+ z: number
+}) {
+ const ref = useRef(null)
+ const direction = side === 'left' ? -1 : 1
+ const getLeafX = (openAmount: number) => direction * (width / 4 + openAmount * width * 0.34)
+ const leafWidth = Math.max(width / 2 - 0.018, 0.12)
+ const railHeight = Math.min(0.09, Math.max(0.055, height * 0.04))
+ const stileWidth = Math.min(0.07, Math.max(0.04, leafWidth * 0.18))
+ const glassWidth = Math.max(leafWidth - stileWidth * 2.2, 0.03)
+ const glassHeight = Math.max(height - railHeight * 3, 0.2)
+
+ useFrame(() => {
+ if (!(animated && ref.current)) return
+ const runtime = useInteractive.getState().elevators[animated.elevatorId]
+ const nextDoorOpen =
+ animated.kind === 'cab'
+ ? (runtime?.doorOpen ?? 0)
+ : runtime?.currentLevelId === animated.levelId
+ ? (runtime?.doorOpen ?? 0)
+ : 0
+ ref.current.position.x = getLeafX(nextDoorOpen)
+ }, 2.6)
+
+ return (
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ )
+}
+
+function LandingDoorFrame({
+ doorHeight,
+ doorWidth,
+ levelTopY,
+ levelY,
+ shaftWidth,
+ z,
+}: {
+ doorHeight: number
+ doorWidth: number
+ levelTopY: number
+ levelY: number
+ shaftWidth: number
+ z: number
+}) {
+ const wallDepth = 0.09
+ const levelHeight = Math.max(levelTopY - levelY, doorHeight + 0.24)
+ const jambWidth = Math.max((shaftWidth - doorWidth) / 2, 0.08)
+ const jambCenterOffset = doorWidth / 2 + jambWidth / 2
+ const headerHeight = Math.max(levelHeight - doorHeight, 0.14)
+ const trim = 0.055
+
+ return (
+ <>
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ )
+}
+
+function LandingDoor({
+ animated,
+ elevatorId,
+ doorOpen,
+ doorHeight,
+ doorWidth,
+ levelId,
+ levelY,
+ z,
+}: {
+ animated: boolean
+ elevatorId: AnyNodeId
+ doorOpen: number
+ doorHeight: number
+ doorWidth: number
+ levelId: AnyNodeId
+ levelY: number
+ z: number
+}) {
+ return (
+ <>
+
+
+
+ )
+}
+
+export const ElevatorRenderer = ({ node }: { node: ElevatorNode }) => {
+ const ref = useRef(null!)
+ const cabRef = useRef(null)
+ const nodes = useScene((state) => state.nodes)
+ const handlers = useNodeEvents(node, 'elevator')
+ const liveOverrides = useLiveNodeOverrides((state) => state.get(node.id))
+ const renderNode = useMemo(
+ () => (liveOverrides ? ({ ...node, ...liveOverrides } as ElevatorNode) : node),
+ [liveOverrides, node],
+ )
+
+ useRegistry(node.id, 'elevator', ref)
+
+ const { entries, defaultEntry, shaftBaseY, shaftTopY, totalHeight } = useMemo(
+ () => resolveElevatorLevels(renderNode, nodes),
+ [renderNode, nodes],
+ )
+ const elevatorId = node.id as AnyNodeId
+ const runtimeStatus = useInteractive(
+ useShallow((state) => {
+ const runtime = state.elevators[elevatorId]
+ if (!runtime) return null
+ return {
+ currentLevelId: runtime.currentLevelId,
+ phase: runtime.phase,
+ queue: runtime.queue,
+ targetLevelId: runtime.targetLevelId,
+ }
+ }),
+ )
+
+ useEffect(() => {
+ if (!defaultEntry) return
+
+ const elevatorId = node.id as AnyNodeId
+ const interactive = useInteractive.getState()
+ const current = interactive.elevators[elevatorId]
+ if (!current) {
+ interactive.initElevator(elevatorId, defaultEntry.id as AnyNodeId, defaultEntry.baseY)
+ } else if (!entries.some((entry) => entry.id === current.currentLevelId)) {
+ interactive.setElevatorState(elevatorId, {
+ carY: defaultEntry.baseY,
+ currentLevelId: defaultEntry.id as AnyNodeId,
+ doorOpen: 0,
+ phase: 'idle',
+ phaseStartedAt: null,
+ queue: [],
+ targetLevelId: null,
+ })
+ }
+ }, [defaultEntry, entries, node.id])
+
+ useEffect(() => {
+ return () => {
+ useInteractive.getState().removeElevator(elevatorId)
+ }
+ }, [elevatorId])
+
+ useFrame(() => {
+ if (!cabRef.current) return
+ const runtime = useInteractive.getState().elevators[elevatorId]
+ if (!runtime) return
+ cabRef.current.position.y = runtime.carY
+ }, 2.6)
+
+ const shaftWidth = Math.max(renderNode.width, 0.8)
+ const shaftDepth = Math.max(renderNode.depth, 0.8)
+ const cabHeight = Math.max(renderNode.cabHeight, 1.4)
+ const doorWidth = Math.min(Math.max(renderNode.doorWidth, 0.45), shaftWidth - 0.18)
+ const doorHeight = Math.min(Math.max(renderNode.doorHeight, 1.2), cabHeight - 0.1)
+ const shaftHeight = Math.max(totalHeight, cabHeight + 0.3)
+ const resolvedShaftTopY = Math.max(shaftTopY, shaftBaseY + shaftHeight)
+ const shaftWallThickness = 0.09
+ const runtimeSnapshot = useInteractive.getState().elevators[elevatorId]
+ const cabBaseY = runtimeSnapshot?.carY ?? defaultEntry?.baseY ?? 0
+ const activeLevelId =
+ runtimeStatus?.currentLevelId ?? runtimeSnapshot?.currentLevelId ?? defaultEntry?.id ?? null
+ const pendingLevelId =
+ runtimeStatus?.targetLevelId ??
+ runtimeSnapshot?.targetLevelId ??
+ runtimeStatus?.queue[0] ??
+ runtimeSnapshot?.queue[0] ??
+ null
+ const currentEntry =
+ entries.find((entry) => entry.id === activeLevelId) ?? defaultEntry ?? entries[0] ?? null
+ const pendingEntry = pendingLevelId ? entries.find((entry) => entry.id === pendingLevelId) : null
+ const indicatorEntry = pendingEntry ?? currentEntry
+ const indicatorDirection =
+ currentEntry && pendingEntry && Math.abs(pendingEntry.baseY - currentEntry.baseY) > 0.001
+ ? pendingEntry.baseY > currentEntry.baseY
+ ? 'up'
+ : 'down'
+ : null
+ const indicatorActive = Boolean(
+ pendingEntry ||
+ runtimeStatus?.phase === 'moving' ||
+ runtimeSnapshot?.phase === 'moving' ||
+ runtimeStatus?.phase === 'opening' ||
+ runtimeSnapshot?.phase === 'opening',
+ )
+ const queuedLevelIds = new Set()
+ for (const levelId of runtimeStatus?.queue ?? runtimeSnapshot?.queue ?? [])
+ queuedLevelIds.add(levelId)
+ if (runtimeStatus?.targetLevelId ?? runtimeSnapshot?.targetLevelId) {
+ queuedLevelIds.add((runtimeStatus?.targetLevelId ?? runtimeSnapshot?.targetLevelId)!)
+ }
+ const doorOpen = runtimeSnapshot?.doorOpen ?? 0
+ const frontWallZ = -shaftDepth / 2 - shaftWallThickness / 2
+ const frontZ = frontWallZ - shaftWallThickness / 2 - 0.018
+ const landingPanelX = Math.min(shaftWidth / 2 - 0.16, doorWidth / 2 + 0.18)
+ const cabPanelX = shaftWidth / 2 - 0.075
+ const cabPanelZ = -shaftDepth / 2 + 0.36
+ const cabButtonColumns = entries.length > 1 ? 2 : 1
+ const cabButtonRows = Math.max(1, Math.ceil(entries.length / cabButtonColumns))
+ const cabButtonSpacingX = 0.14
+ const cabButtonSpacingY = 0.15
+ const cabPanelWidth = cabButtonColumns * cabButtonSpacingX + 0.13
+ const cabPanelHeight = cabButtonRows * cabButtonSpacingY + 0.12
+ const panelRelativeY = Math.min(Math.max(doorHeight * 0.6, 0.95), cabHeight - 0.35)
+ const cabPanelY = panelRelativeY
+ const entrySpans = entries.map((entry, index) => {
+ const nextEntry = entries[index + 1]
+ return {
+ entry,
+ levelTopY: Math.max(nextEntry?.baseY ?? resolvedShaftTopY, entry.baseY + doorHeight + 0.24),
+ }
+ })
+ const requestLevel = (levelId: AnyNodeId) => {
+ useInteractive.getState().requestElevator(elevatorId, levelId)
+ }
+
+ return (
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ {entries.map((entry, index) => {
+ const column = index % cabButtonColumns
+ const row = Math.floor(index / cabButtonColumns)
+ const x = (column - (cabButtonColumns - 1) / 2) * cabButtonSpacingX
+ const y = ((cabButtonRows - 1) / 2 - row) * cabButtonSpacingY
+
+ return (
+ requestLevel(entry.id as AnyNodeId)}
+ position={[x, y, 0.045]}
+ queued={queuedLevelIds.has(entry.id)}
+ />
+ )
+ })}
+
+
+
+ {entrySpans.map(({ entry, levelTopY }) => (
+
+
+
+
+
+
+
+
+
+ 0.5}
+ buttonKind="landing"
+ elevatorId={elevatorId}
+ levelId={entry.id as AnyNodeId}
+ onRequest={() => requestLevel(entry.id as AnyNodeId)}
+ position={[0, 0.06, -0.045]}
+ queued={queuedLevelIds.has(entry.id)}
+ radius={0.045}
+ />
+
+
+
+
+
+
+ ))}
+
+ )
+}
diff --git a/packages/viewer/src/components/renderers/node-renderer.tsx b/packages/viewer/src/components/renderers/node-renderer.tsx
index c4b6db97..48a8bc18 100644
--- a/packages/viewer/src/components/renderers/node-renderer.tsx
+++ b/packages/viewer/src/components/renderers/node-renderer.tsx
@@ -5,6 +5,7 @@ import { BuildingRenderer } from './building/building-renderer'
import { CeilingRenderer } from './ceiling/ceiling-renderer'
import { ColumnRenderer } from './column/column-renderer'
import { DoorRenderer } from './door/door-renderer'
+import { ElevatorRenderer } from './elevator/elevator-renderer'
import { FenceRenderer } from './fence/fence-renderer'
import { GuideRenderer } from './guide/guide-renderer'
import { ItemRenderer } from './item/item-renderer'
@@ -32,6 +33,7 @@ export const NodeRenderer = ({ nodeId }: { nodeId: AnyNode['id'] }) => {
{node.type === 'building' && }
{node.type === 'ceiling' && }
{node.type === 'column' && }
+ {node.type === 'elevator' && }
{node.type === 'level' && }
{node.type === 'item' && }
{node.type === 'slab' && }
diff --git a/packages/viewer/src/components/renderers/site/site-renderer.tsx b/packages/viewer/src/components/renderers/site/site-renderer.tsx
index c16e056a..301e87c8 100644
--- a/packages/viewer/src/components/renderers/site/site-renderer.tsx
+++ b/packages/viewer/src/components/renderers/site/site-renderer.tsx
@@ -1,8 +1,8 @@
import { type SiteNode, type SlabNode, useRegistry, useScene } from '@pascal-app/core'
-import polygonClipping from 'polygon-clipping'
import { useMemo, useRef } from 'react'
import { BufferGeometry, Float32BufferAttribute, type Group, Path, Shape } from 'three'
import { useNodeEvents } from '../../../hooks/use-node-events'
+import { unionPolygons } from '../../../lib/polygon-union'
import useViewer from '../../../store/use-viewer'
import { NodeRenderer } from '../node-renderer'
@@ -89,22 +89,12 @@ export const SiteRenderer = ({ node }: { node: SiteNode }) => {
shape.closePath()
if (slabPolygons.length > 0) {
- const multiPolygons = slabPolygons.map((p) => [
- p.map((pt) => [pt[0], -pt[1]] as [number, number]),
- ])
- const unioned = polygonClipping.union(
- multiPolygons[0] as polygonClipping.Polygon,
- ...(multiPolygons.slice(1) as polygonClipping.Polygon[]),
- )
- for (const geom of unioned) {
- const ring = geom[0]
- if (ring && ring.length > 0) {
- const hole = new Path()
- hole.moveTo(ring[0]![0], ring[0]![1])
- for (let i = 1; i < ring.length; i++) hole.lineTo(ring[i]![0], ring[i]![1])
- hole.closePath()
- shape.holes.push(hole)
- }
+ for (const ring of unionPolygons(slabPolygons.map((p) => p.map((pt) => [pt[0], -pt[1]])))) {
+ const hole = new Path()
+ hole.moveTo(ring[0]![0], ring[0]![1])
+ for (let i = 1; i < ring.length; i++) hole.lineTo(ring[i]![0], ring[i]![1])
+ hole.closePath()
+ shape.holes.push(hole)
}
}
diff --git a/packages/viewer/src/components/viewer/ground-occluder.tsx b/packages/viewer/src/components/viewer/ground-occluder.tsx
index 54be8b51..717f7bc5 100644
--- a/packages/viewer/src/components/viewer/ground-occluder.tsx
+++ b/packages/viewer/src/components/viewer/ground-occluder.tsx
@@ -1,7 +1,7 @@
import { type LevelNode, useScene } from '@pascal-app/core'
-import polygonClipping from 'polygon-clipping'
import { useMemo } from 'react'
import * as THREE from 'three'
+import { unionPolygons } from '../../lib/polygon-union'
import useViewer from '../../store/use-viewer'
export const GroundOccluder = () => {
@@ -64,31 +64,15 @@ export const GroundOccluder = () => {
})
if (polygons.length > 0) {
- // Format for polygon-clipping: [[[x, y], [x, y], ...]]
- const multiPolygons = polygons.map((pts) => {
- const ring = pts.map((p) => [p[0], -p[1]] as [number, number]) // Negate Y (which was Z)
- return [ring]
- })
+ for (const ring of unionPolygons(polygons.map((pts) => pts.map((p) => [p[0], -p[1]])))) {
+ const hole = new THREE.Path()
- // Union all polygons together to prevent artifacts from overlapping
- const unionedPolygons = polygonClipping.union(multiPolygons[0]!, ...multiPolygons.slice(1))
-
- // Add each resulting unioned polygon as a hole
- for (const geom of unionedPolygons) {
- // First ring in each geometry is the exterior ring
- if (geom.length > 0) {
- const ring = geom[0]!
- const hole = new THREE.Path()
-
- if (ring.length > 0) {
- hole.moveTo(ring[0]![0], ring[0]![1])
- for (let i = 1; i < ring.length; i++) {
- hole.lineTo(ring[i]![0], ring[i]![1])
- }
- hole.closePath()
- s.holes.push(hole)
- }
+ hole.moveTo(ring[0]![0], ring[0]![1])
+ for (let i = 1; i < ring.length; i++) {
+ hole.lineTo(ring[i]![0], ring[i]![1])
}
+ hole.closePath()
+ s.holes.push(hole)
}
}
diff --git a/packages/viewer/src/components/viewer/index.tsx b/packages/viewer/src/components/viewer/index.tsx
index bc2b5b85..0ae36bf1 100644
--- a/packages/viewer/src/components/viewer/index.tsx
+++ b/packages/viewer/src/components/viewer/index.tsx
@@ -8,6 +8,8 @@ import useViewer from '../../store/use-viewer'
import { CeilingSystem } from '../../systems/ceiling/ceiling-system'
import { DoorAnimationSystem } from '../../systems/door/door-animation-system'
import { DoorSystem } from '../../systems/door/door-system'
+import { ElevatorAnimationSystem } from '../../systems/elevator/elevator-animation-system'
+import { ElevatorOpeningSystem } from '../../systems/elevator/elevator-opening-system'
import { FenceSystem } from '../../systems/fence/fence-system'
import { GuideSystem } from '../../systems/guide/guide-system'
import { ItemSystem } from '../../systems/item/item-system'
@@ -94,8 +96,6 @@ type WebGPUDeviceLossInfo = {
type WebGPUDeviceLike = {
lost: Promise
- label?: string
- features?: Set
addEventListener?: (type: string, listener: EventListener) => void
removeEventListener?: (type: string, listener: EventListener) => void
}
@@ -108,18 +108,9 @@ function GPUDeviceWatcher() {
const device = backend?.device as WebGPUDeviceLike | undefined
if (!device) {
- console.warn('[viewer] No WebGPU device on backend — running on a fallback renderer.', {
- backend: backend?.constructor?.name ?? 'unknown',
- rendererType: (gl as any).constructor?.name ?? 'unknown',
- })
return
}
- console.log('[viewer] WebGPU device ready', {
- label: device.label,
- features: device.features ? Array.from(device.features) : [],
- })
-
device.lost.then((info: WebGPUDeviceLossInfo) => {
console.error(
`[viewer] WebGPU device lost: reason="${info.reason ?? 'unknown'}", message="${info.message ?? ''}". ` +
@@ -167,24 +158,12 @@ const Viewer: React.FC = ({
const canvas = props.canvas
const cached = canvas ? WEBGPU_RENDERER_CACHE.get(canvas) : undefined
if (cached) return cached
- // Surface the env we're about to ask WebGPU for — catches "no
- // navigator.gpu" / "adapter request failed" silently failing in
- // mobile WebViews where WebGPU is gated behind flags.
- const hasGpu = typeof navigator !== 'undefined' && 'gpu' in navigator
- console.log('[viewer] Creating WebGPURenderer', {
- hasNavigatorGPU: hasGpu,
- ua: typeof navigator !== 'undefined' ? navigator.userAgent : 'n/a',
- })
const promise = (async () => {
try {
const renderer = new THREE.WebGPURenderer(props as any)
renderer.toneMapping = THREE.ACESFilmicToneMapping
renderer.toneMappingExposure = 0.9
await renderer.init()
- console.log('[viewer] WebGPURenderer ready', {
- backend: (renderer as any).backend?.constructor?.name,
- isWebGPU: (renderer as any).isWebGPURenderer === true,
- })
return renderer
} catch (err) {
// Drop the failed promise from the cache so a future Canvas
@@ -228,6 +207,8 @@ const Viewer: React.FC = ({
{/* Core systems */}
+
+
diff --git a/packages/viewer/src/components/viewer/post-processing.tsx b/packages/viewer/src/components/viewer/post-processing.tsx
index 8dd494b1..5babfa05 100644
--- a/packages/viewer/src/components/viewer/post-processing.tsx
+++ b/packages/viewer/src/components/viewer/post-processing.tsx
@@ -174,22 +174,9 @@ const PostProcessingPasses = ({
void pipelineVersion
if (!(renderer && scene && camera)) {
- console.warn('[viewer/post-processing] Skipping pipeline build — missing dependency.', {
- hasRenderer: !!renderer,
- hasScene: !!scene,
- hasCamera: !!camera,
- })
return
}
- console.log('[viewer/post-processing] Building pipeline', {
- version: pipelineVersion,
- ssgi: SSGI_PARAMS.enabled,
- hoverHighlightMode,
- projectId,
- rendererCtor: (renderer as any).constructor?.name,
- })
-
hasPipelineErrorRef.current = false
// WebGPU availability check: SSGI, denoise, and RenderPipeline are all
@@ -202,9 +189,6 @@ const PostProcessingPasses = ({
// exclusively and never attempts the TSL pipeline.
const hasWebGPU = typeof navigator !== 'undefined' && 'gpu' in navigator
if (!hasWebGPU) {
- console.warn(
- '[viewer] WebGPU unavailable — rendering without post-processing (SSGI, outlines, denoise).',
- )
hasPipelineErrorRef.current = true
renderPipelineRef.current = null
return
@@ -331,7 +315,6 @@ const PostProcessingPasses = ({
renderPipeline.outputNode = finalOutput
renderPipelineRef.current = renderPipeline
retryCountRef.current = 0
- console.log('[viewer/post-processing] Pipeline built OK', { version: pipelineVersion })
} catch (error) {
hasPipelineErrorRef.current = true
console.error(
@@ -410,9 +393,6 @@ const PostProcessingPasses = ({
if (retryCountRef.current < MAX_PIPELINE_RETRIES) {
// Auto-retry: schedule a pipeline rebuild if we haven't exceeded the retry limit
retryCountRef.current++
- console.warn(
- `[viewer/post-processing] Scheduling pipeline rebuild (attempt ${retryCountRef.current}/${MAX_PIPELINE_RETRIES})`,
- )
if (rebuildTimeoutRef.current !== null) {
clearTimeout(rebuildTimeoutRef.current)
}
diff --git a/packages/viewer/src/hooks/use-node-events.ts b/packages/viewer/src/hooks/use-node-events.ts
index 18487347..e1e10503 100644
--- a/packages/viewer/src/hooks/use-node-events.ts
+++ b/packages/viewer/src/hooks/use-node-events.ts
@@ -7,6 +7,8 @@ import {
type ColumnNode,
type DoorEvent,
type DoorNode,
+ type ElevatorEvent,
+ type ElevatorNode,
type EventSuffix,
emitter,
type FenceEvent,
@@ -57,6 +59,7 @@ type NodeConfig = {
'stair-segment': { node: StairSegmentNode; event: StairSegmentEvent }
window: { node: WindowNode; event: WindowEvent }
door: { node: DoorNode; event: DoorEvent }
+ elevator: { node: ElevatorNode; event: ElevatorEvent }
}
type NodeType = keyof NodeConfig
diff --git a/packages/viewer/src/lib/polygon-union.test.ts b/packages/viewer/src/lib/polygon-union.test.ts
new file mode 100644
index 00000000..6bbaaa0e
--- /dev/null
+++ b/packages/viewer/src/lib/polygon-union.test.ts
@@ -0,0 +1,77 @@
+// @ts-expect-error — bun:test is provided by the Bun runtime; viewer does not
+// depend on @types/bun so the import type is unresolved at compile time.
+import { describe, expect, test } from 'bun:test'
+import { type Point2D, unionPolygons } from './polygon-union'
+
+function polygonArea(points: Point2D[]) {
+ let area = 0
+ for (let i = 0; i < points.length; i++) {
+ const current = points[i]!
+ const next = points[(i + 1) % points.length]!
+ area += current[0] * next[1] - next[0] * current[1]
+ }
+ return Math.abs(area / 2)
+}
+
+describe('unionPolygons', () => {
+ test('collapses a contained polygon into the containing polygon', () => {
+ const small: Point2D[] = [
+ [0, 0],
+ [1, 0],
+ [1, 1],
+ [0, 1],
+ ]
+ const large: Point2D[] = [
+ [-1, -1],
+ [2, -1],
+ [2, 2],
+ [-1, 2],
+ ]
+
+ const result = unionPolygons([small, large])
+
+ expect(result).toHaveLength(1)
+ expect(polygonArea(result[0]!)).toBeCloseTo(9)
+ })
+
+ test('combines overlapping rectangles into one boundary', () => {
+ const left: Point2D[] = [
+ [0, 0],
+ [2, 0],
+ [2, 2],
+ [0, 2],
+ ]
+ const right: Point2D[] = [
+ [1, 1],
+ [3, 1],
+ [3, 3],
+ [1, 3],
+ ]
+
+ const result = unionPolygons([left, right])
+
+ expect(result).toHaveLength(1)
+ expect(result[0]).toHaveLength(8)
+ expect(polygonArea(result[0]!)).toBeCloseTo(7)
+ })
+
+ test('keeps disjoint polygons as separate boundaries', () => {
+ const left: Point2D[] = [
+ [0, 0],
+ [1, 0],
+ [1, 1],
+ [0, 1],
+ ]
+ const right: Point2D[] = [
+ [2, 0],
+ [3, 0],
+ [3, 1],
+ [2, 1],
+ ]
+
+ const result = unionPolygons([left, right])
+
+ expect(result).toHaveLength(2)
+ expect(result.map(polygonArea)).toEqual([1, 1])
+ })
+})
diff --git a/packages/viewer/src/lib/polygon-union.ts b/packages/viewer/src/lib/polygon-union.ts
new file mode 100644
index 00000000..f078ccdd
--- /dev/null
+++ b/packages/viewer/src/lib/polygon-union.ts
@@ -0,0 +1,294 @@
+export type Point2D = [number, number]
+
+const EPSILON = 1e-7
+const KEY_SCALE = 1e6
+
+type Edge = {
+ start: Point2D
+ end: Point2D
+ polygonIndex: number
+ splits: number[]
+}
+
+type Segment = {
+ start: Point2D
+ end: Point2D
+ used: boolean
+}
+
+function pointsEqual(a: Point2D, b: Point2D, tolerance = EPSILON) {
+ return Math.hypot(a[0] - b[0], a[1] - b[1]) <= tolerance
+}
+
+function pointKey(point: Point2D) {
+ return `${Math.round(point[0] * KEY_SCALE)}:${Math.round(point[1] * KEY_SCALE)}`
+}
+
+function interpolate(a: Point2D, b: Point2D, t: number): Point2D {
+ return [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t]
+}
+
+function cross(ax: number, ay: number, bx: number, by: number) {
+ return ax * by - ay * bx
+}
+
+function polygonArea(points: Point2D[]) {
+ let area = 0
+ for (let i = 0; i < points.length; i++) {
+ const current = points[i]!
+ const next = points[(i + 1) % points.length]!
+ area += current[0] * next[1] - next[0] * current[1]
+ }
+ return area / 2
+}
+
+function pointOnSegment(point: Point2D, start: Point2D, end: Point2D) {
+ const dx = end[0] - start[0]
+ const dz = end[1] - start[1]
+ const crossValue = cross(point[0] - start[0], point[1] - start[1], dx, dz)
+ if (Math.abs(crossValue) > EPSILON) return false
+
+ const dot =
+ (point[0] - start[0]) * (point[0] - end[0]) + (point[1] - start[1]) * (point[1] - end[1])
+ return dot <= EPSILON
+}
+
+function pointInPolygon(point: Point2D, polygon: Point2D[]) {
+ let inside = false
+
+ for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+ const pi = polygon[i]!
+ const pj = polygon[j]!
+
+ if (pointOnSegment(point, pj, pi)) return false
+
+ const intersects =
+ pi[1] > point[1] !== pj[1] > point[1] &&
+ point[0] < ((pj[0] - pi[0]) * (point[1] - pi[1])) / (pj[1] - pi[1]) + pi[0]
+
+ if (intersects) inside = !inside
+ }
+
+ return inside
+}
+
+function normalizeRing(ring: Point2D[]) {
+ const normalized: Point2D[] = []
+
+ for (const [x, z] of ring) {
+ if (!Number.isFinite(x) || !Number.isFinite(z)) continue
+
+ const point: Point2D = [x, z]
+ const previous = normalized[normalized.length - 1]
+ if (!previous || !pointsEqual(previous, point)) {
+ normalized.push(point)
+ }
+ }
+
+ const first = normalized[0]
+ const last = normalized[normalized.length - 1]
+ if (first && last && pointsEqual(first, last)) {
+ normalized.pop()
+ }
+
+ if (normalized.length < 3 || Math.abs(polygonArea(normalized)) <= EPSILON) return []
+ return polygonArea(normalized) < 0 ? [...normalized].reverse() : normalized
+}
+
+function addSplit(edge: Edge, t: number) {
+ if (t < -EPSILON || t > 1 + EPSILON) return
+ const clamped = Math.max(0, Math.min(1, t))
+ if (edge.splits.some((split) => Math.abs(split - clamped) <= EPSILON)) return
+ edge.splits.push(clamped)
+}
+
+function parameterOnEdge(point: Point2D, edge: Edge) {
+ const dx = edge.end[0] - edge.start[0]
+ const dz = edge.end[1] - edge.start[1]
+ const lengthSquared = dx * dx + dz * dz
+ if (lengthSquared <= EPSILON) return 0
+ return ((point[0] - edge.start[0]) * dx + (point[1] - edge.start[1]) * dz) / lengthSquared
+}
+
+function addIntersectionSplits(left: Edge, right: Edge) {
+ const rx = left.end[0] - left.start[0]
+ const rz = left.end[1] - left.start[1]
+ const sx = right.end[0] - right.start[0]
+ const sz = right.end[1] - right.start[1]
+ const qpx = right.start[0] - left.start[0]
+ const qpz = right.start[1] - left.start[1]
+ const denominator = cross(rx, rz, sx, sz)
+ const numerator = cross(qpx, qpz, rx, rz)
+
+ if (Math.abs(denominator) <= EPSILON) {
+ if (Math.abs(numerator) > EPSILON) return
+
+ for (const point of [left.start, left.end, right.start, right.end]) {
+ if (
+ pointOnSegment(point, left.start, left.end) &&
+ pointOnSegment(point, right.start, right.end)
+ ) {
+ addSplit(left, parameterOnEdge(point, left))
+ addSplit(right, parameterOnEdge(point, right))
+ }
+ }
+ return
+ }
+
+ const t = cross(qpx, qpz, sx, sz) / denominator
+ const u = cross(qpx, qpz, rx, rz) / denominator
+ if (t < -EPSILON || t > 1 + EPSILON || u < -EPSILON || u > 1 + EPSILON) return
+
+ addSplit(left, t)
+ addSplit(right, u)
+}
+
+function buildEdges(polygons: Point2D[][]) {
+ const edges: Edge[] = []
+
+ polygons.forEach((polygon, polygonIndex) => {
+ for (let i = 0; i < polygon.length; i++) {
+ edges.push({
+ start: polygon[i]!,
+ end: polygon[(i + 1) % polygon.length]!,
+ polygonIndex,
+ splits: [0, 1],
+ })
+ }
+ })
+
+ for (let i = 0; i < edges.length; i++) {
+ for (let j = i + 1; j < edges.length; j++) {
+ const left = edges[i]!
+ const right = edges[j]!
+ if (left.polygonIndex === right.polygonIndex) continue
+ addIntersectionSplits(left, right)
+ }
+ }
+
+ return edges
+}
+
+function buildBoundarySegments(edges: Edge[], polygons: Point2D[][]) {
+ const segments: Segment[] = []
+
+ for (const edge of edges) {
+ const splits = [...edge.splits].sort((a, b) => a - b)
+
+ for (let i = 0; i < splits.length - 1; i++) {
+ const startT = splits[i]!
+ const endT = splits[i + 1]!
+ if (endT - startT <= EPSILON) continue
+
+ const start = interpolate(edge.start, edge.end, startT)
+ const end = interpolate(edge.start, edge.end, endT)
+ const mid = interpolate(edge.start, edge.end, (startT + endT) / 2)
+ const insideAnother = polygons.some(
+ (polygon, index) => index !== edge.polygonIndex && pointInPolygon(mid, polygon),
+ )
+
+ if (!insideAnother) {
+ segments.push({ start, end, used: false })
+ }
+ }
+ }
+
+ return removeDuplicateInteriorSegments(segments)
+}
+
+function segmentKey(segment: Segment) {
+ const start = pointKey(segment.start)
+ const end = pointKey(segment.end)
+ return start < end ? `${start}|${end}` : `${end}|${start}`
+}
+
+function removeDuplicateInteriorSegments(segments: Segment[]) {
+ const groups = new Map()
+ for (const segment of segments) {
+ const key = segmentKey(segment)
+ const group = groups.get(key)
+ if (group) {
+ group.push(segment)
+ } else {
+ groups.set(key, [segment])
+ }
+ }
+
+ const result: Segment[] = []
+ for (const group of groups.values()) {
+ if (group.length === 1) {
+ result.push(group[0]!)
+ continue
+ }
+
+ const firstStart = pointKey(group[0]!.start)
+ const firstEnd = pointKey(group[0]!.end)
+ const hasOppositeDirection = group.some(
+ (segment) => pointKey(segment.start) === firstEnd && pointKey(segment.end) === firstStart,
+ )
+
+ if (!hasOppositeDirection) {
+ result.push(group[0]!)
+ }
+ }
+
+ return result
+}
+
+function assembleRings(segments: Segment[]) {
+ const byStart = new Map()
+ for (const segment of segments) {
+ const key = pointKey(segment.start)
+ const group = byStart.get(key)
+ if (group) {
+ group.push(segment)
+ } else {
+ byStart.set(key, [segment])
+ }
+ }
+
+ const rings: Point2D[][] = []
+
+ for (const firstSegment of segments) {
+ if (firstSegment.used) continue
+
+ firstSegment.used = true
+ const ring: Point2D[] = [firstSegment.start, firstSegment.end]
+ const startKey = pointKey(firstSegment.start)
+ let currentKey = pointKey(firstSegment.end)
+
+ while (currentKey !== startKey) {
+ const next = byStart.get(currentKey)?.find((segment) => !segment.used)
+ if (!next) break
+
+ next.used = true
+ ring.push(next.end)
+ currentKey = pointKey(next.end)
+ }
+
+ if (currentKey !== startKey) continue
+
+ const last = ring[ring.length - 1]
+ if (last && pointsEqual(ring[0]!, last)) {
+ ring.pop()
+ }
+
+ const normalized = normalizeRing(ring)
+ if (normalized.length >= 3) {
+ rings.push(normalized)
+ }
+ }
+
+ return rings
+}
+
+export function unionPolygons(polygons: Point2D[][]): Point2D[][] {
+ const validPolygons = polygons.map(normalizeRing).filter((polygon) => polygon.length >= 3)
+ if (validPolygons.length <= 1) return validPolygons
+
+ const edges = buildEdges(validPolygons)
+ const segments = buildBoundarySegments(edges, validPolygons)
+ const rings = assembleRings(segments)
+
+ return rings.length > 0 ? rings : validPolygons
+}
diff --git a/packages/viewer/src/systems/ceiling/ceiling-system.tsx b/packages/viewer/src/systems/ceiling/ceiling-system.tsx
index 5e383d2b..e37f14c3 100644
--- a/packages/viewer/src/systems/ceiling/ceiling-system.tsx
+++ b/packages/viewer/src/systems/ceiling/ceiling-system.tsx
@@ -1,6 +1,7 @@
-import { useFrame } from '@react-three/fiber'
import { type AnyNodeId, type CeilingNode, sceneRegistry, useScene } from '@pascal-app/core'
+import { useFrame } from '@react-three/fiber'
import * as THREE from 'three'
+import { mergeSurfaceHolePolygons } from '../surface-hole-geometry'
function ensureUv2Attribute(geometry: THREE.BufferGeometry) {
const uv = geometry.getAttribute('uv')
@@ -82,7 +83,7 @@ export function generateCeilingGeometry(ceilingNode: CeilingNode): THREE.BufferG
shape.closePath()
// Add holes to the shape
- const holes = ceilingNode.holes || []
+ const holes = mergeSurfaceHolePolygons(ceilingNode.holes || [])
for (const holePolygon of holes) {
if (holePolygon.length < 3) continue
diff --git a/packages/viewer/src/systems/elevator/elevator-animation-system.tsx b/packages/viewer/src/systems/elevator/elevator-animation-system.tsx
new file mode 100644
index 00000000..49be4c84
--- /dev/null
+++ b/packages/viewer/src/systems/elevator/elevator-animation-system.tsx
@@ -0,0 +1,155 @@
+import {
+ type AnyNodeId,
+ type ElevatorNode,
+ sceneRegistry,
+ useInteractive,
+ useScene,
+} from '@pascal-app/core'
+import { useFrame } from '@react-three/fiber'
+import { resolveElevatorLevels } from './elevator-utils'
+
+const EPSILON = 0.001
+
+function moveToward(current: number, target: number, maxDelta: number) {
+ const delta = target - current
+ if (Math.abs(delta) <= maxDelta) return target
+ return current + Math.sign(delta) * maxDelta
+}
+
+export function ElevatorAnimationSystem() {
+ useFrame(({ clock }, delta) => {
+ const interactive = useInteractive.getState()
+ const nodes = useScene.getState().nodes
+ const now = clock.getElapsedTime() * 1000
+
+ for (const elevatorId of sceneRegistry.byType.elevator) {
+ const typedElevatorId = elevatorId as AnyNodeId
+ const node = nodes[typedElevatorId]
+ if (node?.type !== 'elevator') {
+ interactive.removeElevator(typedElevatorId)
+ continue
+ }
+
+ const elevator = node as ElevatorNode
+ const { entries, defaultEntry } = resolveElevatorLevels(elevator, nodes)
+ if (!defaultEntry) continue
+
+ const state = interactive.elevators[typedElevatorId]
+ if (!state) {
+ interactive.initElevator(typedElevatorId, defaultEntry.id as AnyNodeId, defaultEntry.baseY)
+ continue
+ }
+
+ const currentEntry =
+ entries.find((entry) => entry.id === state.currentLevelId) ?? defaultEntry
+ if (currentEntry.id !== state.currentLevelId) {
+ interactive.setElevatorState(typedElevatorId, {
+ currentLevelId: currentEntry.id as AnyNodeId,
+ carY: currentEntry.baseY,
+ targetLevelId: null,
+ phase: 'idle',
+ phaseStartedAt: null,
+ queue: [],
+ doorOpen: 0,
+ })
+ continue
+ }
+
+ const targetEntry = state.targetLevelId
+ ? entries.find((entry) => entry.id === state.targetLevelId)
+ : state.queue[0]
+ ? entries.find((entry) => entry.id === state.queue[0])
+ : null
+
+ const doorDurationMs = Math.max(elevator.doorDurationMs ?? 900, 1)
+ const doorStep = (delta * 1000) / doorDurationMs
+
+ switch (state.phase) {
+ case 'idle': {
+ const nextLevelId = state.queue[0] ?? null
+ if (!nextLevelId) {
+ if (state.doorOpen > EPSILON) {
+ interactive.setElevatorState(typedElevatorId, {
+ doorOpen: Math.max(0, state.doorOpen - doorStep),
+ })
+ }
+ break
+ }
+
+ interactive.setElevatorState(typedElevatorId, {
+ targetLevelId: nextLevelId,
+ phase:
+ state.doorOpen > EPSILON
+ ? 'closing'
+ : nextLevelId === state.currentLevelId
+ ? 'opening'
+ : 'moving',
+ phaseStartedAt: now,
+ })
+ break
+ }
+
+ case 'closing': {
+ const doorOpen = Math.max(0, state.doorOpen - doorStep)
+ interactive.setElevatorState(typedElevatorId, {
+ doorOpen,
+ phase: doorOpen <= EPSILON ? (state.targetLevelId ? 'moving' : 'idle') : 'closing',
+ phaseStartedAt: doorOpen <= EPSILON ? now : state.phaseStartedAt,
+ })
+ break
+ }
+
+ case 'moving': {
+ if (!targetEntry) {
+ interactive.setElevatorState(typedElevatorId, {
+ targetLevelId: null,
+ phase: 'idle',
+ queue: [],
+ })
+ break
+ }
+
+ const speed = Math.max(elevator.speed ?? 2.2, 0.1)
+ const nextY = moveToward(state.carY, targetEntry.baseY, speed * delta)
+ const arrived = Math.abs(nextY - targetEntry.baseY) <= EPSILON
+ interactive.setElevatorState(typedElevatorId, {
+ carY: nextY,
+ currentLevelId: arrived ? (targetEntry.id as AnyNodeId) : state.currentLevelId,
+ phase: arrived ? 'opening' : 'moving',
+ phaseStartedAt: arrived ? now : state.phaseStartedAt,
+ })
+ break
+ }
+
+ case 'opening': {
+ const doorOpen = Math.min(1, state.doorOpen + doorStep)
+ interactive.setElevatorState(typedElevatorId, {
+ doorOpen,
+ phase: doorOpen >= 1 - EPSILON ? 'open' : 'opening',
+ phaseStartedAt: doorOpen >= 1 - EPSILON ? now : state.phaseStartedAt,
+ targetLevelId: doorOpen >= 1 - EPSILON ? null : state.targetLevelId,
+ queue:
+ doorOpen >= 1 - EPSILON && state.queue[0] === state.currentLevelId
+ ? state.queue.slice(1)
+ : state.queue,
+ })
+ break
+ }
+
+ case 'open': {
+ const elapsed = now - (state.phaseStartedAt ?? now)
+ if (elapsed < Math.max(elevator.dwellMs ?? 1400, 0)) break
+
+ interactive.setElevatorState(typedElevatorId, {
+ phase: 'closing',
+ phaseStartedAt: now,
+ targetLevelId: state.queue[0] ?? null,
+ })
+ break
+ }
+ }
+ }
+ }, 2)
+
+ return null
+}
diff --git a/packages/viewer/src/systems/elevator/elevator-opening-system.tsx b/packages/viewer/src/systems/elevator/elevator-opening-system.tsx
new file mode 100644
index 00000000..559f9a3b
--- /dev/null
+++ b/packages/viewer/src/systems/elevator/elevator-opening-system.tsx
@@ -0,0 +1,54 @@
+import { type AnyNode, syncAutoElevatorOpenings, useScene } from '@pascal-app/core'
+import { useEffect, useRef } from 'react'
+
+function isOpeningRelevantNode(node: AnyNode | undefined) {
+ return (
+ node?.type === 'building' ||
+ node?.type === 'ceiling' ||
+ node?.type === 'elevator' ||
+ node?.type === 'level' ||
+ node?.type === 'slab'
+ )
+}
+
+function hasOpeningRelevantNodeChange(
+ nextNodes: Record,
+ prevNodes: Record,
+) {
+ if (nextNodes === prevNodes) return false
+
+ const ids = new Set([...Object.keys(nextNodes), ...Object.keys(prevNodes)])
+ for (const id of ids) {
+ const nextNode = nextNodes[id]
+ const prevNode = prevNodes[id]
+ if (nextNode === prevNode) continue
+ if (isOpeningRelevantNode(nextNode) || isOpeningRelevantNode(prevNode)) return true
+ }
+
+ return false
+}
+
+export const ElevatorOpeningSystem = () => {
+ const syncingAutoOpeningsRef = useRef(false)
+
+ useEffect(() => {
+ const applyUpdates = (updates: ReturnType) => {
+ if (updates.length === 0) return
+ syncingAutoOpeningsRef.current = true
+ useScene.getState().updateNodes(updates)
+ queueMicrotask(() => {
+ syncingAutoOpeningsRef.current = false
+ })
+ }
+
+ applyUpdates(syncAutoElevatorOpenings(useScene.getState().nodes))
+
+ return useScene.subscribe((state, prevState) => {
+ if (syncingAutoOpeningsRef.current) return
+ if (!hasOpeningRelevantNodeChange(state.nodes, prevState.nodes)) return
+ applyUpdates(syncAutoElevatorOpenings(state.nodes))
+ })
+ }, [])
+
+ return null
+}
diff --git a/packages/viewer/src/systems/elevator/elevator-utils.ts b/packages/viewer/src/systems/elevator/elevator-utils.ts
new file mode 100644
index 00000000..4c0c03fa
--- /dev/null
+++ b/packages/viewer/src/systems/elevator/elevator-utils.ts
@@ -0,0 +1,68 @@
+import {
+ resolveElevatorBuildingLevels,
+ resolveElevatorServiceLevels,
+ type AnyNode,
+ type AnyNodeId,
+ type ElevatorNode,
+ type LevelNode,
+} from '@pascal-app/core'
+import { getLevelHeight } from '../level/level-utils'
+
+export type ElevatorLevelEntry = {
+ id: LevelNode['id']
+ label: string
+ baseY: number
+}
+
+export function resolveElevatorLevels(
+ elevator: ElevatorNode,
+ nodes: Record,
+): {
+ entries: ElevatorLevelEntry[]
+ defaultEntry: ElevatorLevelEntry | null
+ shaftBaseY: number
+ shaftTopY: number
+ totalHeight: number
+} {
+ const allLevels = resolveElevatorBuildingLevels(elevator, nodes)
+
+ const baseYByLevelId = new Map()
+ let cumulativeY = 0
+ for (const level of allLevels) {
+ baseYByLevelId.set(level.id, cumulativeY)
+ cumulativeY += getLevelHeight(level.id, nodes)
+ }
+
+ const serviceLevels = resolveElevatorServiceLevels(elevator, nodes)
+ const entries = serviceLevels.map((level) => ({
+ id: level.id,
+ label: String(level.level),
+ baseY: baseYByLevelId.get(level.id) ?? 0,
+ }))
+
+ const defaultEntry =
+ entries.find((entry) => entry.id === elevator.defaultLevelId) ??
+ entries.find((entry) => entry.id === elevator.fromLevelId) ??
+ entries[0] ??
+ null
+ const firstServedLevel = serviceLevels[0] ?? null
+ const lastServedLevel = serviceLevels[serviceLevels.length - 1] ?? null
+ const shaftBaseY = firstServedLevel ? (baseYByLevelId.get(firstServedLevel.id) ?? 0) : 0
+ const lastServedIndex = lastServedLevel
+ ? allLevels.findIndex((level) => level.id === lastServedLevel.id)
+ : -1
+ const nextLevel = lastServedIndex >= 0 ? allLevels[lastServedIndex + 1] : null
+ const shaftTopY = nextLevel
+ ? (baseYByLevelId.get(nextLevel.id) ?? cumulativeY)
+ : lastServedLevel
+ ? cumulativeY
+ : elevator.cabHeight + 0.3
+
+ return {
+ entries,
+ defaultEntry,
+ shaftBaseY,
+ shaftTopY,
+ totalHeight: Math.max(shaftTopY - shaftBaseY, elevator.cabHeight + 0.3),
+ }
+}
diff --git a/packages/viewer/src/systems/slab/slab-system.tsx b/packages/viewer/src/systems/slab/slab-system.tsx
index 3d866445..403f0438 100644
--- a/packages/viewer/src/systems/slab/slab-system.tsx
+++ b/packages/viewer/src/systems/slab/slab-system.tsx
@@ -8,6 +8,7 @@ import {
import { useFrame } from '@react-three/fiber'
import { useEffect } from 'react'
import * as THREE from 'three'
+import { mergeSurfaceHolePolygons } from '../surface-hole-geometry'
function ensureUv2Attribute(geometry: THREE.BufferGeometry) {
const uv = geometry.getAttribute('uv')
@@ -86,6 +87,7 @@ export function generateSlabGeometry(slabNode: SlabNode): THREE.BufferGeometry {
function generatePositiveSlabGeometry(slabNode: SlabNode): THREE.BufferGeometry {
const polygon = getRenderableSlabPolygon(slabNode)
const elevation = slabNode.elevation ?? 0.05
+ const holePolygons = mergeSurfaceHolePolygons(slabNode.holes ?? [])
if (polygon.length < 3) return new THREE.BufferGeometry()
@@ -94,7 +96,7 @@ function generatePositiveSlabGeometry(slabNode: SlabNode): THREE.BufferGeometry
for (let i = 1; i < polygon.length; i++) shape.lineTo(polygon[i]![0], -polygon[i]![1])
shape.closePath()
- for (const holePolygon of slabNode.holes ?? []) {
+ for (const holePolygon of holePolygons) {
if (holePolygon.length < 3) continue
const holePath = new THREE.Path()
holePath.moveTo(holePolygon[0]![0], -holePolygon[0]![1])
@@ -122,6 +124,7 @@ function generatePositiveSlabGeometry(slabNode: SlabNode): THREE.BufferGeometry
function generatePoolGeometry(slabNode: SlabNode): THREE.BufferGeometry {
const polygon = getRenderableSlabPolygon(slabNode)
const depth = Math.abs(slabNode.elevation ?? 0.05)
+ const holePolygons = mergeSurfaceHolePolygons(slabNode.holes ?? [])
if (polygon.length < 3) return new THREE.BufferGeometry()
@@ -134,7 +137,7 @@ function generatePoolGeometry(slabNode: SlabNode): THREE.BufferGeometry {
for (const [x, z] of polygon) {
bounds.expandByPoint(new THREE.Vector2(x, z))
}
- for (const hole of slabNode.holes ?? []) {
+ for (const hole of holePolygons) {
for (const [x, z] of hole) {
bounds.expandByPoint(new THREE.Vector2(x, z))
}
@@ -157,8 +160,8 @@ function generatePoolGeometry(slabNode: SlabNode): THREE.BufferGeometry {
for (const [x, z] of polygon) pushFloorVertex(x!, 0, z!)
const pts2d = polygon.map(([x, z]) => new THREE.Vector2(x!, z!))
- const holesPts2d = (slabNode.holes ?? []).map((h) => h.map(([x, z]) => new THREE.Vector2(x!, z!)))
- for (const hole of slabNode.holes ?? []) {
+ const holesPts2d = holePolygons.map((h) => h.map(([x, z]) => new THREE.Vector2(x!, z!)))
+ for (const hole of holePolygons) {
for (const [x, z] of hole) pushFloorVertex(x!, 0, z!)
}
diff --git a/packages/viewer/src/systems/surface-hole-geometry.ts b/packages/viewer/src/systems/surface-hole-geometry.ts
new file mode 100644
index 00000000..bd514ea0
--- /dev/null
+++ b/packages/viewer/src/systems/surface-hole-geometry.ts
@@ -0,0 +1,5 @@
+import { type Point2D, unionPolygons } from '../lib/polygon-union'
+
+export function mergeSurfaceHolePolygons(holes: Point2D[][]): Point2D[][] {
+ return unionPolygons(holes)
+}