@marble.fun/track-catalog 3.0.0

package/src/pages/play/race/track-appearance-space-station-wall.ts

@@ -0,0 +1,497 @@
+import * as THREE from 'three'
+
+import { VisualCircleGeometry } from '../../../three/visual-geometry'
+import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js'
+
+import { TRACK_RAIL_WALL_THICKNESS } from './track-definition'
+import {
+  canonicalWallFrameAt,
+  type CanonicalWallRun,
+  type RawWallFrame,
+} from './track-surface-topology'
+
+export type SpaceStationWallPathFrame = RawWallFrame
+export type SpaceStationWallPathRun = CanonicalWallRun
+
+export interface SpaceStationWallMaterials {
+  chassis: THREE.Material
+  panel: THREE.Material
+  rib: THREE.Material
+  trim: THREE.Material
+  light: THREE.Material
+}
+
+interface BandBatch {
+  name: string
+  material: THREE.Material
+  geometries: THREE.BufferGeometry[]
+  castShadow: boolean
+  receiveShadow: boolean
+}
+
+const BAY_TARGET = 3.2
+const SAMPLE_SPACING = 0.9
+const SAMPLE_MAXIMUM_TURN = THREE.MathUtils.degToRad(8)
+const RIB_WIDTH = 0.2
+const RIB_DEPTH = 0.03
+const RIB_BACKING_WIDTH = 0.29
+const RIB_BACKING_DEPTH = 0.024
+const MAX_FACADE_LIFT = 0.029
+const WORLD_UP = new THREE.Vector3(0, 1, 0)
+
+/** Adds the visual-only, two-sided armored facade over the existing wall collider. */
+export function addSpaceStationWallVisual(
+  root: THREE.Group,
+  id: string,
+  runs: readonly SpaceStationWallPathRun[],
+  wallHeight: number,
+  materials: SpaceStationWallMaterials,
+): THREE.Group | undefined {
+  if (wallHeight <= 0.18) return undefined
+  const group = new THREE.Group()
+  group.name = `${id}-space-station-armored-wall`
+  group.userData.themeOnly = 'intergalactic-space-station'
+  group.userData.decorative = true
+  group.userData.visualOnly = true
+  group.userData.appearance = 'space-station-armored-wall'
+
+  const ribMatrices: THREE.Matrix4[] = []
+  const ribBackingMatrices: THREE.Matrix4[] = []
+  const ribSpineMatrices: THREE.Matrix4[] = []
+  const clampMatrices: THREE.Matrix4[] = []
+  const headerPlateMatrices: THREE.Matrix4[] = []
+  const boltMatrices: THREE.Matrix4[] = []
+  const panelBands: BandBatch = {
+    name: `${id}-space-wall-panel-batch`,
+    material: materials.panel,
+    geometries: [],
+    castShadow: true,
+    receiveShadow: true,
+  }
+  const chassisBands: BandBatch = {
+    name: `${id}-space-wall-chassis-batch`,
+    material: materials.chassis,
+    geometries: [],
+    castShadow: true,
+    receiveShadow: true,
+  }
+  const trimBands: BandBatch = {
+    name: `${id}-space-wall-trim-batch`,
+    material: materials.trim,
+    geometries: [],
+    castShadow: true,
+    receiveShadow: true,
+  }
+  const lightBands: BandBatch = {
+    name: `${id}-space-wall-light-batch`,
+    material: materials.light,
+    geometries: [],
+    castShadow: false,
+    receiveShadow: false,
+  }
+  let bayCount = 0
+  let runCount = 0
+
+  for (const run of runs) {
+    if (run.frames.length < 2) continue
+    const canonicalRun = run
+    const totalLength = canonicalRun.length
+    if (totalLength <= 0.08) continue
+    runCount += 1
+    const count = Math.max(1, Math.round(totalLength / BAY_TARGET))
+    const bayLength = totalLength / count
+    bayCount += count
+    const chassisFrames = sampleCanonicalRange(canonicalRun, 0, totalLength)
+    for (const face of [-1, 1] as const) {
+      queueBand(chassisBands, chassisFrames, face, 0.03, wallHeight - 0.01, 0.001)
+    }
+
+    for (let bayIndex = 0; bayIndex < count; bayIndex += 1) {
+      const bayStart = bayIndex * bayLength
+      const bayEnd = (bayIndex + 1) * bayLength
+      const border = Math.min(0.11, bayLength * 0.12)
+      const panelFrames = sampleCanonicalRange(canonicalRun, bayStart + border, bayEnd - border)
+      const lightInset = Math.min(0.2, bayLength * 0.18)
+      const lightFrames = sampleCanonicalRange(
+        canonicalRun,
+        bayStart + border + lightInset,
+        bayEnd - border - lightInset,
+      )
+      for (const face of [-1, 1] as const) {
+        queueBand(
+          panelBands,
+          panelFrames,
+          face,
+          0.16,
+          wallHeight - 0.16,
+          0.006,
+          0.07,
+        )
+        for (const [, bottom, top, lift, material] of [
+          ['footer', 0.07, 0.16, 0.008, materials.panel],
+          ['lower-bezel', 0.15, 0.245, 0.012, materials.trim],
+          ['upper-bezel', wallHeight - 0.245, wallHeight - 0.15, 0.012, materials.trim],
+          ['header', wallHeight - 0.16, wallHeight - 0.07, 0.008, materials.panel],
+        ] as const) {
+          queueBand(
+            material === materials.panel ? panelBands : trimBands,
+            panelFrames,
+            face,
+            bottom,
+            top,
+            lift,
+            0.035,
+          )
+        }
+        for (const center of [0.215, wallHeight - 0.215]) {
+          queueBand(
+            trimBands,
+            lightFrames,
+            face,
+            center - 0.035,
+            center + 0.035,
+            0.018,
+            0.012,
+          )
+          queueBand(
+            lightBands,
+            lightFrames,
+            face,
+            center - 0.014,
+            center + 0.014,
+            0.022,
+            0.007,
+          )
+        }
+        queueBand(
+          trimBands,
+          lightFrames,
+          face,
+          wallHeight - 0.132,
+          wallHeight - 0.118,
+          0.015,
+          0.006,
+        )
+        queueBand(
+          trimBands,
+          panelFrames,
+          face,
+          wallHeight - 0.072,
+          wallHeight - 0.035,
+          0.014,
+          0.014,
+        )
+
+        const headerFrame = canonicalWallFrameAt(canonicalRun, (bayStart + bayEnd) / 2)
+        const headerOutward = horizontalWallOutward(
+          headerFrame,
+          headerFrame.outward.clone().multiplyScalar(face),
+        )
+        const headerRotation = verticalFrameQuaternion(headerFrame, headerOutward)
+        const headerTangent = horizontalFrameTangent(headerFrame, headerOutward)
+        const headerPosition = headerFrame.base
+          .clone()
+          .addScaledVector(WORLD_UP, wallHeight - 0.105)
+          .addScaledVector(headerOutward, TRACK_RAIL_WALL_THICKNESS / 2 + 0.023)
+        headerPlateMatrices.push(
+          new THREE.Matrix4().compose(headerPosition, headerRotation, new THREE.Vector3(0.16, 0.052, 0.008)),
+        )
+        for (const tangentOffset of [-0.052, 0.052]) {
+          const boltPosition = headerPosition
+            .clone()
+            .addScaledVector(headerTangent, tangentOffset)
+            .addScaledVector(headerOutward, 0.007)
+          const boltRotation = new THREE.Quaternion().setFromUnitVectors(new THREE.Vector3(0, 1, 0), headerOutward)
+          boltMatrices.push(
+            new THREE.Matrix4().compose(boltPosition, boltRotation, new THREE.Vector3(0.72, 0.72, 0.72)),
+          )
+        }
+      }
+    }
+
+    for (let boundary = 0; boundary <= count; boundary += 1) {
+      const frame = canonicalWallFrameAt(canonicalRun, Math.min(totalLength, boundary * bayLength))
+      for (const face of [-1, 1] as const) {
+        const outward = horizontalWallOutward(frame, frame.outward.clone().multiplyScalar(face))
+        const rotation = verticalFrameQuaternion(frame, outward)
+        const ribHeight = wallHeight + 0.08
+        const position = frame.base
+          .clone()
+          .addScaledVector(WORLD_UP, ribHeight / 2 - 0.025)
+          .addScaledVector(outward, TRACK_RAIL_WALL_THICKNESS / 2 + RIB_DEPTH / 2 + 0.006)
+        ribMatrices.push(
+          new THREE.Matrix4().compose(position, rotation, new THREE.Vector3(1, ribHeight / wallHeight, 1)),
+        )
+        const backingPosition = frame.base
+          .clone()
+          .addScaledVector(WORLD_UP, ribHeight / 2 - 0.025)
+          .addScaledVector(outward, TRACK_RAIL_WALL_THICKNESS / 2 + RIB_BACKING_DEPTH / 2 + 0.002)
+        ribBackingMatrices.push(
+          new THREE.Matrix4().compose(backingPosition, rotation, new THREE.Vector3(1, ribHeight / wallHeight, 1)),
+        )
+        const spinePosition = frame.base
+          .clone()
+          .addScaledVector(WORLD_UP, ribHeight / 2 - 0.025)
+          .addScaledVector(outward, TRACK_RAIL_WALL_THICKNESS / 2 + MAX_FACADE_LIFT - 0.004)
+        ribSpineMatrices.push(
+          new THREE.Matrix4().compose(
+            spinePosition,
+            rotation,
+            new THREE.Vector3(0.075, Math.max(0.3, ribHeight - 0.46), 0.008),
+          ),
+        )
+
+        for (const clampHeight of [0.2, wallHeight - 0.2]) {
+          const clampPosition = frame.base
+            .clone()
+            .addScaledVector(WORLD_UP, clampHeight)
+            .addScaledVector(outward, TRACK_RAIL_WALL_THICKNESS / 2 + MAX_FACADE_LIFT)
+          clampMatrices.push(
+            new THREE.Matrix4().compose(clampPosition, rotation, new THREE.Vector3(0.105, 0.12, 0.008)),
+          )
+          for (const boltOffset of [-0.045, 0.045]) {
+            const boltPosition = clampPosition
+              .clone()
+              .addScaledVector(WORLD_UP, boltOffset)
+              .addScaledVector(outward, 0.005)
+            const boltRotation = new THREE.Quaternion().setFromUnitVectors(new THREE.Vector3(0, 1, 0), outward)
+            boltMatrices.push(new THREE.Matrix4().compose(boltPosition, boltRotation, new THREE.Vector3(1, 1, 1)))
+          }
+        }
+      }
+    }
+  }
+
+  if (runCount === 0) return undefined
+  addBandBatch(group, chassisBands)
+  addBandBatch(group, panelBands)
+  addBandBatch(group, trimBands)
+  addBandBatch(group, lightBands)
+  if (ribBackingMatrices.length > 0)
+    group.add(
+      instancedBatch(
+        `${id}-space-wall-rib-backings`,
+        createWrappedRibGeometry(wallHeight, RIB_BACKING_WIDTH, RIB_BACKING_DEPTH),
+        materials.trim,
+        ribBackingMatrices,
+      ),
+    )
+  if (ribMatrices.length > 0)
+    group.add(
+      instancedBatch(
+        `${id}-space-wall-ribs`,
+        createWrappedRibGeometry(wallHeight, RIB_WIDTH, RIB_DEPTH),
+        materials.rib,
+        ribMatrices,
+      ),
+    )
+  if (ribSpineMatrices.length > 0)
+    group.add(
+      instancedBatch(`${id}-space-wall-rib-spines`, new THREE.BoxGeometry(1, 1, 1), materials.panel, ribSpineMatrices),
+    )
+  if (clampMatrices.length > 0)
+    group.add(instancedBatch(`${id}-space-wall-clamps`, new THREE.BoxGeometry(1, 1, 1), materials.trim, clampMatrices))
+  if (headerPlateMatrices.length > 0)
+    group.add(
+      instancedBatch(
+        `${id}-space-wall-header-service-plates`,
+        new THREE.BoxGeometry(1, 1, 1),
+        materials.trim,
+        headerPlateMatrices,
+      ),
+    )
+  if (boltMatrices.length > 0)
+    group.add(
+      instancedBatch(
+        `${id}-space-wall-bolts`,
+        // Six sides are already sub-pixel at the authored bolt radius.
+        new VisualCircleGeometry(0.009, 6).rotateX(-Math.PI / 2).translate(0, 0.004, 0),
+        materials.trim,
+        boltMatrices,
+      ),
+    )
+
+  group.userData.runCount = runCount
+  group.userData.bayCount = bayCount
+  group.userData.ribCount = ribMatrices.length
+  root.add(group)
+  return group
+}
+
+function queueBand(
+  batch: BandBatch,
+  frames: readonly SpaceStationWallPathFrame[],
+  face: -1 | 1,
+  bottom: number,
+  top: number,
+  lift: number,
+  chamfer = 0,
+): void {
+  if (frames.length < 2 || top <= bottom) return
+  batch.geometries.push(createBandGeometry(frames, face, bottom, top, lift, chamfer))
+}
+
+function addBandBatch(group: THREE.Group, batch: BandBatch): void {
+  if (batch.geometries.length === 0) return
+  const geometry = mergeGeometries(batch.geometries, false)
+  batch.geometries.forEach(part => part.dispose())
+  if (!geometry) throw new Error(`Could not merge ${batch.name}`)
+  geometry.name = 'space-station-armored-wall-batched-band-geometry'
+  geometry.computeBoundingBox()
+  geometry.computeBoundingSphere()
+  const mesh = new THREE.Mesh(geometry, batch.material)
+  mesh.name = batch.name
+  mesh.userData.decorative = true
+  mesh.userData.visualOnly = true
+  mesh.userData.bandCount = batch.geometries.length
+  mesh.castShadow = batch.castShadow
+  mesh.receiveShadow = batch.receiveShadow
+  group.add(mesh)
+}
+
+function createBandGeometry(
+  frames: readonly SpaceStationWallPathFrame[],
+  face: -1 | 1,
+  bottom: number,
+  top: number,
+  lift: number,
+  chamfer: number,
+): THREE.BufferGeometry {
+  const distances = bandPathDistances(frames)
+  const totalLength = distances.at(-1) ?? 1
+  const positions: number[] = []
+  const uvs: number[] = []
+  const metricUvs: number[] = []
+  const indices: number[] = []
+  frames.forEach((frame, index) => {
+    const outward = horizontalWallOutward(frame, frame.outward.clone().multiplyScalar(face))
+    const endChamfer = index === 0 || index === frames.length - 1 ? chamfer : 0
+    for (const height of [bottom + endChamfer, top - endChamfer]) {
+      const point = frame.base
+        .clone()
+        .addScaledVector(outward, TRACK_RAIL_WALL_THICKNESS / 2 + lift)
+        .addScaledVector(WORLD_UP, height - 0.03)
+      positions.push(point.x, point.y, point.z)
+      uvs.push(distances[index]! / totalLength, (height - bottom) / Math.max(0.001, top - bottom))
+      metricUvs.push(distances[index]!, height, 1, totalLength)
+    }
+  })
+  for (let index = 0; index < frames.length - 1; index += 1) {
+    const a = index * 2
+    const b = a + 1
+    const c = a + 2
+    const d = a + 3
+    const desired = horizontalWallOutward(frames[index]!, frames[index]!.outward.clone().multiplyScalar(face))
+    appendOrientedTriangle(indices, positions, a, b, c, desired)
+    appendOrientedTriangle(indices, positions, b, d, c, desired)
+  }
+  const geometry = new THREE.BufferGeometry()
+  geometry.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3))
+  geometry.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2))
+  geometry.setAttribute('themeNetUv', new THREE.Float32BufferAttribute(metricUvs, 4))
+  geometry.setIndex(indices)
+  geometry.computeVertexNormals()
+  geometry.computeBoundingBox()
+  geometry.computeBoundingSphere()
+  geometry.name = 'space-station-armored-wall-band-geometry'
+  return geometry
+}
+
+function appendOrientedTriangle(
+  indices: number[],
+  positions: readonly number[],
+  a: number,
+  b: number,
+  c: number,
+  desired: THREE.Vector3,
+): void {
+  const point = (index: number) =>
+    new THREE.Vector3(positions[index * 3]!, positions[index * 3 + 1]!, positions[index * 3 + 2]!)
+  const normal = point(b)
+    .sub(point(a))
+    .cross(point(c).sub(point(a)))
+  if (normal.dot(desired) >= 0) indices.push(a, b, c)
+  else indices.push(a, c, b)
+}
+
+function createWrappedRibGeometry(wallHeight: number, width: number, depth: number): THREE.BoxGeometry {
+  // The repeated ribs are millimetres deep: a closed rectangular strip keeps
+  // their silhouette without bevel loops on thousands of instances.
+  const geometry = new THREE.BoxGeometry(width, wallHeight, depth)
+  geometry.name = 'space-station-wrapped-rib-geometry'
+  return geometry
+}
+
+function verticalFrameQuaternion(frame: SpaceStationWallPathFrame, outwardHint: THREE.Vector3): THREE.Quaternion {
+  const up = WORLD_UP
+  const outward = horizontalWallOutward(frame, outwardHint)
+  const tangent = new THREE.Vector3().crossVectors(up, outward).normalize()
+  outward.crossVectors(tangent, up).normalize()
+  return new THREE.Quaternion().setFromRotationMatrix(new THREE.Matrix4().makeBasis(tangent, up, outward))
+}
+
+function horizontalWallOutward(
+  frame: SpaceStationWallPathFrame,
+  outwardHint: THREE.Vector3,
+): THREE.Vector3 {
+  const outward = outwardHint.clone().addScaledVector(WORLD_UP, -outwardHint.dot(WORLD_UP))
+  if (outward.lengthSq() < 0.000_001) outward.crossVectors(frame.tangent, WORLD_UP)
+  return outward.normalize()
+}
+
+function horizontalFrameTangent(
+  frame: SpaceStationWallPathFrame,
+  outwardHint: THREE.Vector3,
+): THREE.Vector3 {
+  const outward = horizontalWallOutward(frame, outwardHint)
+  return new THREE.Vector3().crossVectors(WORLD_UP, outward).normalize()
+}
+
+function bandPathDistances(frames: readonly SpaceStationWallPathFrame[]): number[] {
+  const distances = [0]
+  for (let index = 1; index < frames.length; index += 1) {
+    distances.push(distances[index - 1]! + frames[index]!.base.distanceTo(frames[index - 1]!.base))
+  }
+  return distances
+}
+
+function sampleCanonicalRange(
+  run: CanonicalWallRun,
+  start: number,
+  end: number,
+): SpaceStationWallPathFrame[] {
+  const rangeStart = Math.max(0, Math.min(start, end))
+  const rangeEnd = Math.min(run.length, Math.max(start, end))
+  const sampled = [canonicalWallFrameAt(run, rangeStart)]
+  let previous = sampled[0]!
+
+  for (const frame of run.frames) {
+    if (frame.distance <= rangeStart || frame.distance >= rangeEnd) continue
+    const turn = Math.acos(THREE.MathUtils.clamp(previous.tangent.dot(frame.tangent), -1, 1))
+    if (frame.distance - previous.distance < SAMPLE_SPACING && turn < SAMPLE_MAXIMUM_TURN) continue
+    sampled.push(frame)
+    previous = frame
+  }
+
+  sampled.push(canonicalWallFrameAt(run, rangeEnd))
+  return sampled
+}
+
+function instancedBatch(
+  name: string,
+  geometry: THREE.BufferGeometry,
+  material: THREE.Material,
+  matrices: readonly THREE.Matrix4[],
+): THREE.InstancedMesh {
+  const mesh = new THREE.InstancedMesh(geometry, material, matrices.length)
+  mesh.name = name
+  mesh.userData.decorative = true
+  mesh.userData.visualOnly = true
+  mesh.castShadow = true
+  mesh.receiveShadow = true
+  matrices.forEach((matrix, index) => mesh.setMatrixAt(index, matrix))
+  mesh.instanceMatrix.needsUpdate = true
+  mesh.computeBoundingBox()
+  mesh.computeBoundingSphere()
+  return mesh
+}