@pascal-app/editor 1.0.1 → 1.0.4

package/src/components/editor/first-person/mechanism-targets.ts

@@ -0,0 +1,36 @@
+import {
+  type AnyNode,
+  type AnyNodeId,
+  nodeMechanism,
+  nodeRegistry,
+  sceneRegistry,
+  useInteractive,
+  useScene,
+} from '@pascal-app/core'
+import type { WalkthroughInteract } from '../../../store/use-first-person-hud'
+
+/**
+ * Mounted nodes the walkthrough runs through `capabilities.mechanism`, any kind
+ * included. `covered` holds the nodes a finer target already tested (procedural
+ * parts, catalog item toggles), so no node is targeted twice.
+ */
+export function mechanismTargetIds(covered: ReadonlySet<string>): AnyNodeId[] {
+  const nodes = useScene.getState().nodes
+  const ids: AnyNodeId[] = []
+  for (const [kind, kindIds] of Object.entries(sceneRegistry.byType)) {
+    if (!nodeRegistry.get(kind)?.capabilities.mechanism) continue
+    for (const id of kindIds) {
+      if (!covered.has(id) && nodeMechanism(nodes[id as AnyNodeId])) ids.push(id as AnyNodeId)
+    }
+  }
+  return ids
+}
+
+/** The walkthrough prompt for a mechanism target: its name and what E does next. */
+export function mechanismHudInteract(node: AnyNode): WalkthroughInteract {
+  const mechanism = nodeMechanism(node)
+  if (!mechanism) return null
+  const on = mechanism.isOn(node, useInteractive.getState())
+  const verb = mechanism.verb === 'open' ? (on ? 'close' : 'open') : on ? 'turn off' : 'turn on'
+  return { label: node.name ?? 'item', verb }
+}

package/src/components/editor/first-person-controls.tsx

@@ -18,16 +18,26 @@ import {
   getLevelDisplayName,
   getLevelElevations,
   getResolvedElevatorDoorStyle,
+  itemPrompt,
+  nodeMechanism,
   openElevatorDoor,
+  operateItem,
   pointInPolygon2D,
   requestElevatorLevel,
   resolveElevatorDispatchTarget,
   resolveElevatorLevels,
   sceneRegistry,
+  toggleNodeMechanism,
   useInteractive,
   useScene,
 } from '@pascal-app/core'
 import {
+  operablePartFor,
+  operableParts,
+  type ProceduralItemNode,
+} from '@pascal-app/core/procedural-items'
+import {
+  applyWalkthroughCameraClipping,
   BVHEcctrl,
   type BVHEcctrlApi,
   CROUCH_CAPSULE,
@@ -87,6 +97,7 @@ import {
   type FirstPersonColliderWorld,
   type FirstPersonSpawn,
 } from './first-person/build-collider-world'
+import { mechanismHudInteract, mechanismTargetIds } from './first-person/mechanism-targets'
 
 const CAMERA_EYE_OFFSET = 0.45
 const LOOK_SENSITIVITY = 0.002
@@ -159,6 +170,8 @@ const standClearanceUp = new Vector3(0, 1, 0)
 const centerScreenPoint = new Vector2(0, 0)
 const doorInteractionRaycaster = new Raycaster()
 setSurfaceRaycastLayers(doorInteractionRaycaster.layers)
+const proceduralInteractionRaycaster = new Raycaster()
+setSurfaceRaycastLayers(proceduralInteractionRaycaster.layers)
 const doorLeafBox = new Box3()
 const doorLeafInverseMatrix = new Matrix4()
 const doorLeafLocalHit = new Vector3()
@@ -226,6 +239,20 @@ type FirstPersonInteractableTarget =
       id: AnyNodeId
       type: 'door' | 'window'
     }
+  | {
+      id: AnyNodeId
+      type: 'item'
+    }
+  | {
+      id: AnyNodeId
+      partId?: string
+      kind?: 'hinge' | 'slide' | 'spin'
+      type: 'procedural'
+    }
+  | {
+      id: AnyNodeId
+      type: 'mechanism'
+    }
   | {
       action: 'open-door' | 'request-level'
       buttonKind: 'cab' | 'landing'
@@ -350,6 +377,34 @@ function resolveHudInteract(target: FirstPersonInteractableTarget | null): Walkt
   }
 
   const node = useScene.getState().nodes[target.id]
+  if (target.type === 'mechanism') return node ? mechanismHudInteract(node) : null
+  if (target.type === 'item') {
+    if (node?.type !== 'item' || !node.asset.interactive) return null
+    const { label, verb } = itemPrompt(
+      target.id,
+      node.name ?? node.asset.name,
+      node.asset.interactive,
+    )
+    return { label, verb }
+  }
+  if (target.type === 'procedural') {
+    if (node?.type !== 'procedural-item') return null
+    const procedural = node as ProceduralItemNode
+    const parts = operableParts(procedural.recipe)
+    if (parts.length === 0 && procedural.recipe.parts.some((part) => part.light)) {
+      const state = useInteractive.getState()
+      const isOn = state.procedural[target.id]?.lightsOn ?? state.lampDefault
+      return { label: procedural.name ?? 'Lights', verb: isOn ? 'turn off' : 'turn on' }
+    }
+    const part = target.partId ? parts.find((entry) => entry.id === target.partId) : undefined
+    const active = useInteractive.getState().procedural[target.id]?.parts
+    const isOn = part ? Boolean(active?.[part.id]) : parts.some((entry) => active?.[entry.id])
+    const kind = part?.kind ?? (parts.every((entry) => entry.kind === 'spin') ? 'spin' : 'hinge')
+    return {
+      label: part?.label ?? procedural.name ?? 'item',
+      verb: kind === 'spin' ? (isOn ? 'turn off' : 'turn on') : isOn ? 'close' : 'open',
+    }
+  }
   if (target.type === 'window') {
     if (node?.type !== 'window') return null
     const isOpen = getDisplayedWindowValue(target.id, node.operationState) > 0
@@ -417,7 +472,9 @@ function getInteractableTargetKey(target: FirstPersonInteractableTarget | null)
   if (!target) return null
   return target.type === 'elevator'
     ? `${target.type}:${target.id}:${target.levelId}`
-    : `${target.type}:${target.id}`
+    : target.type === 'procedural'
+      ? `${target.type}:${target.id}:${target.partId ?? 'all'}`
+      : `${target.type}:${target.id}`
 }
 
 function isDynamicElevatorCollider(kind: ElevatorColliderKind) {
@@ -699,6 +756,11 @@ export const FirstPersonControls = () => {
     yaw: number
   } | null>(null)
 
+  useEffect(() => {
+    if (!(camera as PerspectiveCamera).isPerspectiveCamera) return
+    return applyWalkthroughCameraClipping(camera as PerspectiveCamera)
+  }, [camera])
+
   useEffect(() => {
     const previousCameraMode = useViewer.getState().cameraMode
     if (previousCameraMode === 'orthographic') {
@@ -952,8 +1014,103 @@ export const FirstPersonControls = () => {
     const windowId = resolveInteractableWindowId()
     if (windowId) return { id: windowId, type: 'window' }
 
+    camera.updateMatrixWorld(true)
+    proceduralInteractionRaycaster.setFromCamera(centerScreenPoint, camera)
+    proceduralInteractionRaycaster.far = DOOR_INTERACTION_DISTANCE
+    let closest: FirstPersonInteractableTarget | null = null
+    let closestDistance = DOOR_INTERACTION_DISTANCE
+    const nodes = useScene.getState().nodes
+    const covered = new Set<string>()
+    for (const rawId of sceneRegistry.byType['procedural-item'] ?? []) {
+      covered.add(rawId)
+      const id = rawId as AnyNodeId
+      const node = nodes[id]
+      if (node?.type !== 'procedural-item') continue
+      const procedural = node as ProceduralItemNode
+      if (
+        !operableParts(procedural.recipe).length &&
+        !procedural.recipe.parts.some((part) => part.light)
+      )
+        continue
+      const object = sceneRegistry.nodes.get(id)
+      if (!object) continue
+      for (const hit of proceduralInteractionRaycaster.intersectObject(object, true)) {
+        if (hit.distance >= closestDistance) break
+        // Skip what is not drawn: a joint tree's inactive rest or joint meshes.
+        let drawn = true
+        for (let at: Object3D | null = hit.object; at && at !== object; at = at.parent)
+          if (!at.visible) drawn = false
+        if (!drawn) continue
+        let ancestor: Object3D | null = hit.object
+        while (ancestor && ancestor !== object && !ancestor.userData.proceduralMotion)
+          ancestor = ancestor.parent
+        let motion = ancestor?.userData.proceduralMotion as
+          | { nodeId?: string; partId?: string; kind?: 'hinge' | 'slide' | 'spin' }
+          | undefined
+        // An idle joint tree draws one merged mesh per slot; its face ranges name the part.
+        const ranges = hit.object.userData.proceduralRanges as
+          | { end: number; partId: string }[]
+          | undefined
+        if (!motion && ranges && hit.faceIndex != null) {
+          const face = hit.faceIndex
+          const partId = ranges.find((range) => face < range.end)?.partId
+          const part = partId ? operablePartFor(procedural.recipe, partId) : undefined
+          if (part) motion = { nodeId: id, partId: part.id, kind: part.kind }
+        }
+        closest =
+          motion?.nodeId === id && motion.partId
+            ? { id, partId: motion.partId, kind: motion.kind, type: 'procedural' }
+            : { id, type: 'procedural' }
+        closestDistance = hit.distance
+        break
+      }
+    }
+    for (const rawId of sceneRegistry.byType.item ?? []) {
+      covered.add(rawId)
+      const id = rawId as AnyNodeId
+      const node = nodes[id]
+      if (
+        node?.type !== 'item' ||
+        !node.asset.interactive?.controls.some((control) => control.kind === 'toggle')
+      )
+        continue
+      const object = sceneRegistry.nodes.get(id)
+      if (!object) continue
+      const hit = proceduralInteractionRaycaster.intersectObject(object, true)[0]
+      if (hit && hit.distance < closestDistance) {
+        closest = { id, type: 'item' }
+        closestDistance = hit.distance
+      }
+    }
+    // Doors and windows have their own walkthrough targets (resolveInteractable*Id).
+    for (const rawId of sceneRegistry.byType.door ?? []) covered.add(rawId)
+    for (const rawId of sceneRegistry.byType.window ?? []) covered.add(rawId)
+    for (const id of mechanismTargetIds(covered)) {
+      const object = sceneRegistry.nodes.get(id)
+      const hit = object && proceduralInteractionRaycaster.intersectObject(object, true)[0]
+      if (hit && hit.distance < closestDistance) {
+        closest = { id, type: 'mechanism' }
+        closestDistance = hit.distance
+      }
+    }
+    if (!closest) {
+      const selectedId = useViewer.getState().selection.selectedIds.at(-1) as AnyNodeId | undefined
+      const selected = selectedId ? nodes[selectedId] : undefined
+      if (
+        selected?.type === 'item' &&
+        selected.asset.interactive?.controls.some((control) => control.kind === 'toggle')
+      )
+        return { id: selected.id, type: 'item' }
+    }
+    if (closest) return closest
+
     return null
-  }, [resolveInteractableDoorId, resolveInteractableElevatorTarget, resolveInteractableWindowId])
+  }, [
+    camera,
+    resolveInteractableDoorId,
+    resolveInteractableElevatorTarget,
+    resolveInteractableWindowId,
+  ])
 
   const toggleInteractableTarget = useCallback(() => {
     // Drone is a camera, not an avatar: the click that re-acquires pointer lock
@@ -965,6 +1122,36 @@ export const FirstPersonControls = () => {
 
     const target = interactableTargetRef.current ?? resolveInteractableTarget()
     if (!target) return
+    if (target.type === 'mechanism') {
+      const node = useScene.getState().nodes[target.id]
+      if (node) toggleNodeMechanism(node)
+      return
+    }
+    if (target.type === 'item') {
+      const node = useScene.getState().nodes[target.id]
+      if (node?.type === 'item' && node.asset.interactive)
+        operateItem(target.id, node.asset.interactive)
+      return
+    }
+
+    if (target.type === 'procedural') {
+      const node = useScene.getState().nodes[target.id]
+      if (node?.type !== 'procedural-item') return
+      const parts = operableParts((node as ProceduralItemNode).recipe).map((part) => part.id)
+      const state = useInteractive.getState()
+      if (parts.length === 0) {
+        state.toggleProceduralLights(target.id)
+        return
+      }
+      if (target.partId) state.toggleProceduralPart(target.id, target.partId)
+      else
+        state.setProceduralParts(
+          target.id,
+          parts,
+          !parts.some((id) => state.procedural[target.id]?.parts[id]),
+        )
+      return
+    }
 
     if (target.type === 'elevator') {
       if (target.buttonKind === 'cab') {
@@ -1024,6 +1211,22 @@ export const FirstPersonControls = () => {
     const target = interactableTargetRef.current ?? resolveInteractableTarget()
     if (!target) return
 
+    if (target.type === 'mechanism') {
+      const node = useScene.getState().nodes[target.id]
+      if (node) nodeMechanism(node)?.set(node, false)
+      return
+    }
+
+    if (target.type === 'procedural') {
+      const node = useScene.getState().nodes[target.id]
+      if (node?.type !== 'procedural-item') return
+      const parts = target.partId
+        ? [target.partId]
+        : operableParts((node as ProceduralItemNode).recipe).map((part) => part.id)
+      useInteractive.getState().setProceduralParts(target.id, parts, false)
+      return
+    }
+
     if (target.type === 'elevator') return
 
     if (target.type === 'window') {