@marble.fun/track-catalog 3.0.0

package/src/pages/track-lab/engine/editor-object-geometry.ts

@@ -0,0 +1,170 @@
+import * as THREE from 'three'
+
+import { isStaticTrackColorBatchSource } from '../../play/race/track-shadow-batching'
+
+const objectBounds = new THREE.Box3()
+
+export function computeEditorBounds(root: THREE.Object3D): THREE.Box3 {
+  root.updateWorldMatrix(true, true)
+  const bounds = new THREE.Box3()
+  const canonicalOverride = editorBoundsOverride(root)
+  if (canonicalOverride) {
+    bounds.min.fromArray(canonicalOverride.min)
+    bounds.max.fromArray(canonicalOverride.max)
+    return bounds.applyMatrix4(root.matrixWorld)
+  }
+
+  root.traverse(object => {
+    if (!isEditorGeometry(object)) return
+    expandByGeometryObject(bounds, object)
+  })
+
+  return bounds
+}
+
+export function collectEditorSelectables(root: THREE.Object3D): THREE.Object3D[] {
+  const selectables: THREE.Object3D[] = []
+  root.traverse(object => {
+    if (object instanceof THREE.Mesh && !hasEditorExclusion(object, 'decorative')) {
+      selectables.push(object)
+    }
+  })
+  return selectables
+}
+
+/** Builds a swept canonical selection cage when a surfaced piece provides one. */
+export function createCanonicalEditorOutlineGeometry(
+  root: THREE.Object3D,
+  relativeTo: THREE.Object3D,
+  padding: number,
+): THREE.BufferGeometry | undefined {
+  // Composite mechanisms can contain canonical lane proxies without those
+  // proxies describing the mechanism's complete footprint. In that case the
+  // caller must use the full canonical editor bounds instead of mistaking a
+  // nested entry or outlet lane for the whole selection outline.
+  if (root.userData.editorOutlineMode === 'bounds') return undefined
+
+  root.updateWorldMatrix(true, true)
+  relativeTo.updateWorldMatrix(true, true)
+  const inverseRelative = relativeTo.matrixWorld.clone().invert()
+  const positions: number[] = []
+  const right = new THREE.Vector3()
+  const up = new THREE.Vector3()
+  const transform = new THREE.Matrix4()
+  const appendSegment = (left: THREE.Vector3, rightPoint: THREE.Vector3): void => {
+    positions.push(left.x, left.y, left.z, rightPoint.x, rightPoint.y, rightPoint.z)
+  }
+
+  root.traverse(object => {
+    const rawSections = object.userData.editorBoundsSections as unknown
+    if (!Array.isArray(rawSections) || rawSections.length < 2) return
+    const sections = rawSections.flatMap(rawSection => {
+      if (!Array.isArray(rawSection) || rawSection.length !== 4) return []
+      const section = rawSection.map(rawPoint => {
+        if (!Array.isArray(rawPoint) || rawPoint.length !== 3 || !rawPoint.every(Number.isFinite)) return undefined
+        return new THREE.Vector3().fromArray(rawPoint)
+      })
+      if (section.some(candidate => candidate === undefined)) return []
+      const prepared = section as THREE.Vector3[]
+      right.copy(prepared[1]!).sub(prepared[0]!).normalize()
+      up.copy(prepared[2]!).sub(prepared[0]!).normalize()
+      prepared[0]!.addScaledVector(right, -padding).addScaledVector(up, -padding)
+      prepared[1]!.addScaledVector(right, padding).addScaledVector(up, -padding)
+      prepared[2]!.addScaledVector(right, -padding).addScaledVector(up, padding)
+      prepared[3]!.addScaledVector(right, padding).addScaledVector(up, padding)
+      return [prepared]
+    })
+    if (sections.length < 2) return
+    transform.copy(inverseRelative).multiply(object.matrixWorld)
+    sections.forEach(section => section.forEach(candidate => candidate.applyMatrix4(transform)))
+    // A swept cage needs every section to keep its four longitudinal edges on
+    // a curve or grade, but drawing a complete rectangle at every tessellation
+    // sample turns a long piece into a stack of wire boxes. Only the two real
+    // terminals own cross-sections; interior samples bend the four rails.
+    for (const section of [sections[0]!, sections.at(-1)!]) {
+      appendSegment(section[0]!, section[1]!)
+      appendSegment(section[2]!, section[3]!)
+      appendSegment(section[0]!, section[2]!)
+      appendSegment(section[1]!, section[3]!)
+    }
+    for (let index = 0; index < sections.length - 1; index += 1) {
+      for (let corner = 0; corner < 4; corner += 1) {
+        appendSegment(sections[index]![corner]!, sections[index + 1]![corner]!)
+      }
+    }
+  })
+  if (positions.length === 0) return undefined
+  const geometry = new THREE.BufferGeometry()
+  geometry.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3))
+  geometry.userData.terminalCrossSectionCount = 2
+  geometry.userData.intermediateCrossSectionCount = 0
+  geometry.computeBoundingBox()
+  return geometry
+}
+
+export function isEditorObjectVisible(object: THREE.Object3D): boolean {
+  for (let current: THREE.Object3D | null = object; current; current = current.parent) {
+    // Static color batching hides the rendered source mesh but deliberately
+    // retains it as the exact per-piece ray-picking surface.
+    if (!current.visible && !(current === object && isStaticTrackColorBatchSource(current))) return false
+  }
+  return true
+}
+
+function isEditorGeometry(object: THREE.Object3D): object is THREE.Mesh | THREE.Line | THREE.Points {
+  const visualOnly = hasEditorExclusion(object, 'visualOnly')
+  return (
+    !hasEditorExclusion(object, 'decorative') &&
+    !hasEditorExclusion(object, 'excludeFromEditorBounds') &&
+    (!visualOnly || editorBoundsOverride(object) !== undefined) &&
+    (object instanceof THREE.Mesh || object instanceof THREE.Line || object instanceof THREE.Points)
+  )
+}
+
+function hasEditorExclusion(
+  object: THREE.Object3D,
+  key: 'decorative' | 'excludeFromEditorBounds' | 'visualOnly',
+): boolean {
+  for (let current: THREE.Object3D | null = object; current; current = current.parent) {
+    if (current.userData[key] === true) return true
+  }
+  return false
+}
+
+function expandByGeometryObject(bounds: THREE.Box3, object: THREE.Mesh | THREE.Line | THREE.Points): void {
+  const override = editorBoundsOverride(object)
+  if (override) {
+    objectBounds.min.fromArray(override.min)
+    objectBounds.max.fromArray(override.max)
+    bounds.union(objectBounds.applyMatrix4(object.matrixWorld))
+    return
+  }
+  if (object instanceof THREE.InstancedMesh) {
+    if (object.boundingBox === null) object.computeBoundingBox()
+    if (object.boundingBox) bounds.union(objectBounds.copy(object.boundingBox).applyMatrix4(object.matrixWorld))
+    return
+  }
+
+  if (object.geometry.boundingBox === null) object.geometry.computeBoundingBox()
+  if (object.geometry.boundingBox) {
+    bounds.union(objectBounds.copy(object.geometry.boundingBox).applyMatrix4(object.matrixWorld))
+  }
+}
+
+function editorBoundsOverride(
+  object: THREE.Object3D,
+): { min: readonly [number, number, number]; max: readonly [number, number, number] } | undefined {
+  const override = object.userData.editorBoundsOverride as
+    { min?: readonly number[]; max?: readonly number[] } | undefined
+  if (
+    override?.min?.length !== 3 ||
+    override.max?.length !== 3 ||
+    ![...override.min, ...override.max].every(Number.isFinite)
+  ) {
+    return undefined
+  }
+  return {
+    min: override.min as readonly [number, number, number],
+    max: override.max as readonly [number, number, number],
+  }
+}

package/src/pages/track-lab/engine/track-lab-connection-state.ts

@@ -0,0 +1,123 @@
+import {
+  connectorWorldDirection,
+  connectorWorldPosition,
+  initialTrackCatalog,
+  resolveTemplateConnectors,
+  rotateTrackVector,
+  type TrackDocument,
+} from '@marble.fun/physics-engine/browser'
+
+import { fluidSurfaceStyleFromId } from '../../../three/water-appearance'
+import { underTrackSupportStylesConnect } from '../../play/race/under-track-support-architecture'
+import { createSharedRailConnectorFrame, type RailConnectorFrame } from '../track-piece-layout'
+
+export interface TrackLabVisualConnectionState {
+  connectedConnectorIdsByPiece: Map<string, Set<string>>
+  continuousFluidConnectorIdsByPiece: Map<string, Set<string>>
+  continuousSupportConnectorIdsByPiece: Map<string, Set<string>>
+  connectorFramesByPiece: Map<string, Map<string, RailConnectorFrame>>
+}
+
+function supportsCanonicalRailPorts(materialSlots: readonly string[]): boolean {
+  // Match Test Run's surfaced-piece contract. The previous editor-only
+  // runtime-kind allowlist excluded cones, elevators, starts, finishes,
+  // portals, and vortices, so Material Debug showed gaps that runtime tests
+  // could not reproduce.
+  return materialSlots.includes('lane.surface')
+}
+
+export function visualConnectionState(document: TrackDocument): TrackLabVisualConnectionState {
+  const connectedConnectorIdsByPiece = new Map<string, Set<string>>()
+  const continuousFluidConnectorIdsByPiece = new Map<string, Set<string>>()
+  const continuousSupportConnectorIdsByPiece = new Map<string, Set<string>>()
+  const connectorFramesByPiece = new Map<string, Map<string, RailConnectorFrame>>()
+  const piecesById = new Map(document.pieces.map(piece => [piece.id, piece]))
+  for (const connection of document.connections) {
+    for (const endpoint of [connection.from, connection.to]) {
+      const connectorIds = connectedConnectorIdsByPiece.get(endpoint.pieceId) ?? new Set<string>()
+      connectorIds.add(endpoint.connectorId)
+      connectedConnectorIdsByPiece.set(endpoint.pieceId, connectorIds)
+    }
+    const fromPiece = piecesById.get(connection.from.pieceId)
+    const toPiece = piecesById.get(connection.to.pieceId)
+    if (!fromPiece || !toPiece) continue
+    const fromTemplate = initialTrackCatalog.require(fromPiece)
+    const toTemplate = initialTrackCatalog.require(toPiece)
+    const fromConnector = resolveTemplateConnectors(fromTemplate, fromPiece.parameters).find(
+      connector => connector.id === connection.from.connectorId,
+    )
+    const toConnector = resolveTemplateConnectors(toTemplate, toPiece.parameters).find(
+      connector => connector.id === connection.to.connectorId,
+    )
+    const fromFluidStyle = fluidSurfaceStyleFromId(
+      fromTemplate.runtimeKind === 'vortex' && fromConnector?.kind.endsWith('input')
+        ? fromPiece.appearance?.vortexWaterId
+        : fromPiece.appearance?.waterOverlayId,
+    )
+    const toFluidStyle = fluidSurfaceStyleFromId(
+      toTemplate.runtimeKind === 'vortex' && toConnector?.kind.endsWith('input')
+        ? toPiece.appearance?.vortexWaterId
+        : toPiece.appearance?.waterOverlayId,
+    )
+    if (fromFluidStyle && fromFluidStyle === toFluidStyle) {
+      for (const endpoint of [connection.from, connection.to]) {
+        const connectorIds = continuousFluidConnectorIdsByPiece.get(endpoint.pieceId) ?? new Set<string>()
+        connectorIds.add(endpoint.connectorId)
+        continuousFluidConnectorIdsByPiece.set(endpoint.pieceId, connectorIds)
+      }
+    }
+    if (
+      underTrackSupportStylesConnect(fromPiece.appearance?.supportMaterialId, toPiece.appearance?.supportMaterialId)
+    ) {
+      for (const endpoint of [connection.from, connection.to]) {
+        const connectorIds = continuousSupportConnectorIdsByPiece.get(endpoint.pieceId) ?? new Set<string>()
+        connectorIds.add(endpoint.connectorId)
+        continuousSupportConnectorIdsByPiece.set(endpoint.pieceId, connectorIds)
+      }
+    }
+    if (!fromConnector || !toConnector) continue
+    if (fromConnector.troughProfile !== 'concave' || toConnector.troughProfile !== 'concave') continue
+    const fromSupportsCanonicalPorts = supportsCanonicalRailPorts(fromTemplate.materialSlots)
+    const toSupportsCanonicalPorts = supportsCanonicalRailPorts(toTemplate.materialSlots)
+    if (!fromSupportsCanonicalPorts && !toSupportsCanonicalPorts) continue
+    const worldFrame = createSharedRailConnectorFrame(
+      fromConnector,
+      toConnector,
+      connectorWorldDirection(fromPiece, fromConnector),
+    )
+    const fromPosition = connectorWorldPosition(fromPiece, fromConnector)
+    const toPosition = connectorWorldPosition(toPiece, toConnector)
+    const sharedWorldPosition: [number, number, number] = [
+      (fromPosition[0] + toPosition[0]) / 2,
+      (fromPosition[1] + toPosition[1]) / 2,
+      (fromPosition[2] + toPosition[2]) / 2,
+    ]
+    for (const [piece, connectorId, supportsCanonicalPorts] of [
+      [fromPiece, fromConnector.id, fromSupportsCanonicalPorts],
+      [toPiece, toConnector.id, toSupportsCanonicalPorts],
+    ] as const) {
+      if (!supportsCanonicalPorts) continue
+      const frames = connectorFramesByPiece.get(piece.id) ?? new Map<string, RailConnectorFrame>()
+      const inverseYaw = ((4 - piece.transform.yawSteps) % 4) as 0 | 1 | 2 | 3
+      frames.set(connectorId, {
+        ...worldFrame,
+        position: rotateTrackVector(
+          [
+            sharedWorldPosition[0] - piece.transform.position[0],
+            sharedWorldPosition[1] - piece.transform.position[1],
+            sharedWorldPosition[2] - piece.transform.position[2],
+          ],
+          inverseYaw,
+        ),
+        tangent: rotateTrackVector(worldFrame.tangent, inverseYaw),
+      })
+      connectorFramesByPiece.set(piece.id, frames)
+    }
+  }
+  return {
+    connectedConnectorIdsByPiece,
+    continuousFluidConnectorIdsByPiece,
+    continuousSupportConnectorIdsByPiece,
+    connectorFramesByPiece,
+  }
+}