@marble.fun/track-catalog 3.0.0

package/src/pages/play/race/space-station-portal-frame.ts

@@ -0,0 +1,275 @@
+import { geometryDetailModelUrl } from '../../../three/geometry-detail'
+import * as THREE from 'three'
+
+import { VisualTubeGeometry } from '../../../three/visual-geometry'
+import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js'
+import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js'
+
+import { PORTAL_FRAME_MAX_HALF_WIDTH, PORTAL_RIFT_HALF_HEIGHT, PORTAL_RIFT_HALF_WIDTH } from './portal-proportions'
+
+export const SPACE_STATION_PORTAL_FRAME_THEME_ID = 'intergalactic-space-station'
+export const SPACE_STATION_PORTAL_FRAME_MODEL_URL =
+  '/models/portals/space-station-projector-portal-v1.glb?revision=projector-arms-v17-narrow-articulated-tentacles'
+
+export interface SpaceStationPortalFrameMaterials {
+  chassis: THREE.Material
+  panel: THREE.Material
+  rib: THREE.Material
+  trim: THREE.Material
+  light: THREE.Material
+}
+
+const FRAME_STYLE = 'space-station-curved-projector-arms'
+const RIFT_CENTER_Y = -0.14
+const RIFT_FIT_SCALE = 0.9
+const PROJECTOR_POINTS = [
+  [1.4976, -0.9],
+  [1.6512, -0.28],
+  [1.6224, 0.48],
+  [1.3728, 1.16],
+] as const
+const PROJECTOR_VERTICAL_AIM = [0.18, 0.14, -0.16, -0.24] as const
+const MODEL_ROLES = ['CHASSIS', 'PANEL', 'RIB', 'TRIM', 'LIGHT'] as const
+type ModelRole = (typeof MODEL_ROLES)[number]
+
+let modelTemplatePromise: Promise<THREE.Object3D> | undefined
+const MODEL_PLACEHOLDER_MATERIAL = new THREE.MeshBasicMaterial({ visible: false })
+
+function markVisualOnly(object: THREE.Object3D, role: string): void {
+  object.userData.themeOnly = SPACE_STATION_PORTAL_FRAME_THEME_ID
+  object.userData.themeRole = role
+  object.userData.decorative = true
+  object.userData.visualOnly = true
+  object.userData.portalFrameStyle = FRAME_STYLE
+}
+
+function roleFromName(name: string): ModelRole | undefined {
+  return MODEL_ROLES.find(role => name.toUpperCase().includes(`SS_${role}`))
+}
+
+function loadModelTemplate(): Promise<THREE.Object3D> {
+  modelTemplatePromise ??= new GLTFLoader().loadAsync(geometryDetailModelUrl(SPACE_STATION_PORTAL_FRAME_MODEL_URL)).then(gltf => {
+    gltf.scene.name = 'space-station-projector-portal-template'
+    gltf.scene.traverse(object => {
+      if (!(object instanceof THREE.Mesh)) return
+      const materials = Array.isArray(object.material) ? object.material : [object.material]
+      materials.forEach(material => material.dispose())
+      object.material = MODEL_PLACEHOLDER_MATERIAL
+    })
+    return gltf.scene
+  })
+  return modelTemplatePromise
+}
+
+function createPairLightMaterial(source: THREE.Material, color: string): THREE.Material {
+  const material = source.clone()
+  if (material instanceof THREE.MeshStandardMaterial) {
+    const pairColor = new THREE.Color(color)
+    material.color.copy(pairColor)
+    material.emissive.copy(pairColor)
+    material.emissiveIntensity = Math.max(3, material.emissiveIntensity)
+  }
+  material.name = `space-station-projector-light-${color}`
+  return material
+}
+
+const PROJECTED_ENERGY_VERTEX_SHADER = /* glsl */ `
+  varying vec2 vBeamUv;
+  void main() {
+    vBeamUv = uv;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`
+
+const PROJECTED_ENERGY_FRAGMENT_SHADER = /* glsl */ `
+  uniform float uTime;
+  uniform vec3 uColor;
+  uniform float uCore;
+  varying vec2 vBeamUv;
+  void main() {
+    float travel = 0.78 + 0.22 * sin(vBeamUv.x * 22.0 - uTime * 7.0);
+    float longitudinalFade = smoothstep(0.0, 0.08, vBeamUv.x) * (1.0 - smoothstep(0.82, 1.0, vBeamUv.x));
+    float intensity = travel * longitudinalFade;
+    vec3 hotColor = mix(uColor, vec3(1.0), uCore * 0.78);
+    float layerStrength = mix(1.18, 1.62, uCore);
+    float layerAlpha = mix(0.50, 0.98, uCore);
+    gl_FragColor = vec4(hotColor * intensity * layerStrength, intensity * layerAlpha);
+  }
+`
+
+function createProjectedEnergyMaterial(name: string, color: string, core: boolean): THREE.ShaderMaterial {
+  const material = new THREE.ShaderMaterial({
+    uniforms: {
+      uTime: { value: 0 },
+      uColor: { value: new THREE.Color(color) },
+      uCore: { value: core ? 1 : 0 },
+    },
+    vertexShader: PROJECTED_ENERGY_VERTEX_SHADER,
+    fragmentShader: PROJECTED_ENERGY_FRAGMENT_SHADER,
+    transparent: true,
+    depthWrite: false,
+    blending: THREE.AdditiveBlending,
+    toneMapped: false,
+  })
+  material.name = name
+  return material
+}
+
+function riftBoundaryX(y: number): number {
+  const normalizedY = THREE.MathUtils.clamp(
+    (y - RIFT_CENTER_Y) / (PORTAL_RIFT_HALF_HEIGHT * RIFT_FIT_SCALE),
+    -0.995,
+    0.995,
+  )
+  const angle = Math.asin(normalizedY)
+  const variation =
+    Math.sin(angle * 3 + 0.7) * 0.038 +
+    Math.sin(angle * 7 - 0.4) * 0.022 +
+    Math.sin(angle * 13 + 1.2) * 0.015 +
+    Math.sin(angle * 19 - 0.3) * 0.009 +
+    Math.sin(angle * 31) * 0.006
+  return PORTAL_RIFT_HALF_WIDTH * Math.sqrt(1 - normalizedY * normalizedY) * (1 + variation) * RIFT_FIT_SCALE
+}
+
+function createProjectedRiftBeams(name: string, color: string): THREE.Group {
+  const group = new THREE.Group()
+  group.name = `${name}-projected-rift-beams`
+  const auraParts: THREE.BufferGeometry[] = []
+  const coreParts: THREE.BufferGeometry[] = []
+  for (const side of [-1, 1] as const) {
+    for (const [index, [emitterX, emitterY]] of PROJECTOR_POINTS.entries()) {
+      const targetY = emitterY + PROJECTOR_VERTICAL_AIM[index]!
+      const start = new THREE.Vector3(side * (emitterX - 0.245), emitterY, 0.02)
+      const boundary = Math.max(0.18, riftBoundaryX(targetY) - 0.055)
+      const end = new THREE.Vector3(side * boundary, targetY, 0.04)
+      const curve = new THREE.LineCurve3(start, end)
+      auraParts.push(new VisualTubeGeometry(curve, 5, 0.045, 12, false))
+      coreParts.push(new VisualTubeGeometry(curve, 5, 0.009, 10, false))
+    }
+  }
+  const auraGeometry = mergeGeometries(auraParts, false)
+  const coreGeometry = mergeGeometries(coreParts, false)
+  auraParts.forEach(geometry => geometry.dispose())
+  coreParts.forEach(geometry => geometry.dispose())
+  if (!auraGeometry || !coreGeometry) return group
+  const aura = new THREE.Mesh(auraGeometry, createProjectedEnergyMaterial(`${name}-beam-aura-material`, color, false))
+  const core = new THREE.Mesh(coreGeometry, createProjectedEnergyMaterial(`${name}-beam-core-material`, color, true))
+  aura.name = `${name}-projected-beam-aura`
+  core.name = `${name}-projected-beam-core`
+  for (const layer of [aura, core]) {
+    layer.renderOrder = 4
+    layer.frustumCulled = false
+    layer.userData.ownsMaterial = true
+    layer.userData.portalPairColor = color
+    layer.userData.portalLightRole = 'rift-matched-projection-beam'
+    markVisualOnly(layer, 'space-station-projected-rift-beam')
+    group.add(layer)
+  }
+  markVisualOnly(group, 'space-station-projected-rift-beams')
+  return group
+}
+
+function attachModel(
+  frame: THREE.Group,
+  name: string,
+  color: string,
+  materials: SpaceStationPortalFrameMaterials,
+  template: THREE.Object3D,
+): void {
+  const model = template.clone(true)
+  model.name = `${name}-space-station-projector-model`
+  const pairLight = createPairLightMaterial(materials.light, color)
+  let lightMaterialUsed = false
+  let loadedMeshCount = 0
+
+  model.traverse(object => {
+    markVisualOnly(object, 'space-station-projector-model')
+    if (!(object instanceof THREE.Mesh)) return
+    const role = roleFromName(object.name)
+    if (!role) {
+      object.visible = false
+      return
+    }
+    loadedMeshCount += 1
+    object.material =
+      role === 'CHASSIS'
+        ? materials.chassis
+        : role === 'PANEL'
+          ? materials.panel
+          : role === 'RIB'
+            ? materials.rib
+            : role === 'TRIM'
+              ? materials.trim
+              : pairLight
+    object.castShadow = role !== 'LIGHT'
+    object.receiveShadow = role !== 'LIGHT'
+    object.frustumCulled = true
+    object.userData.sharedGeometry = true
+    if (role === 'LIGHT') {
+      lightMaterialUsed = true
+      object.userData.portalPairColor = color
+      object.userData.portalLightRole = 'projector-lenses'
+      object.userData.ownsMaterial = true
+    }
+    markVisualOnly(object, `space-station-${role.toLowerCase()}`)
+  })
+  frame.userData.loadedMeshCount = loadedMeshCount
+  if (!lightMaterialUsed) pairLight.dispose()
+  frame.add(model)
+}
+
+/** Adds only the station-local projector arms. Shared aperture, rift, glow and dust stay global. */
+export function addSpaceStationPortalFrame(
+  root: THREE.Group,
+  name: string,
+  color: string,
+  materials: SpaceStationPortalFrameMaterials,
+  modelTemplate?: THREE.Object3D,
+): THREE.Group {
+  const frame = new THREE.Group()
+  frame.name = `${name}-space-station-frame`
+  frame.userData.portalApertureClearHalfWidth = 1.0
+  frame.userData.portalSupportMaxHalfWidth = PORTAL_FRAME_MAX_HALF_WIDTH
+  frame.userData.portalSupportOuterHalfWidth = 1.9
+  frame.userData.drawCallBudget = 7
+  frame.userData.modelUrl = SPACE_STATION_PORTAL_FRAME_MODEL_URL
+  frame.userData.portalMechanism = 'two-curved-projector-arms'
+  markVisualOnly(frame, 'space-station-curved-projector-arms')
+
+  const pointLight = new THREE.PointLight(color, 0.68, 4.0, 2)
+  pointLight.name = `${name}-space-station-projector-light`
+  pointLight.position.set(0, 0.15, 0.55)
+  pointLight.userData.portalPairColor = color
+  pointLight.userData.portalLightRole = 'projected-rift-source'
+  markVisualOnly(pointLight, 'projected-rift-source')
+  frame.add(pointLight)
+  frame.add(createProjectedRiftBeams(name, color))
+  root.add(frame)
+
+  if (modelTemplate) {
+    attachModel(frame, name, color, materials, modelTemplate)
+    frame.userData.modelReady = Promise.resolve(frame)
+  } else {
+    frame.userData.modelReady = loadModelTemplate()
+      .then(template => {
+        attachModel(frame, name, color, materials, template)
+        return frame
+      })
+      .catch(error => {
+        // A missing optional facade must not create an unhandled rejection in
+        // headless catalog audits or take down the shared portal/rift visual.
+        frame.userData.modelLoadError = error instanceof Error ? error.message : String(error)
+        modelTemplatePromise = undefined
+        return frame
+      })
+  }
+  return frame
+}
+
+/** Projector arms are static; the globally shared rift remains the animated element. */
+export function updateSpaceStationPortalFrame(frame: THREE.Group | undefined, timeSeconds: number): void {
+  frame?.traverse(object => {
+    if (!(object instanceof THREE.Mesh) || object.userData.portalLightRole !== 'rift-matched-projection-beam') return
+    if (object.material instanceof THREE.ShaderMaterial) object.material.uniforms.uTime!.value = timeSeconds
+  })
+}