@marble.fun/track-catalog 3.0.0

package/src/pages/play/race/egypt-elevator-blender.ts

@@ -0,0 +1,159 @@
+import { geometryDetailModelUrl } from '../../../three/geometry-detail'
+import * as THREE from 'three'
+import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js'
+
+export const EGYPT_ELEVATOR_SHELL_MODEL_URL = '/models/elevators/egypt-elevator-shell-v5.glb'
+export const EGYPT_ELEVATOR_PLATFORM_MODEL_URL = '/models/elevators/egypt-elevator-platform-v5.glb'
+export const EGYPT_ELEVATOR_SHELL_RUNTIME_YAW = Math.PI
+
+export interface EgyptElevatorBlenderMaterials {
+  sandstone: THREE.Material
+  carvedStone: THREE.Material
+  pyramidStone: THREE.Material
+  pyramidGold: THREE.Material
+  bronze: THREE.Material
+  paving: THREE.Material
+}
+
+type EgyptRole = 'SANDSTONE' | 'CARVED' | 'LIMESTONE' | 'GOLD' | 'BRONZE' | 'PAVING'
+
+const PLACEHOLDER = new THREE.MeshBasicMaterial({ visible: false })
+let shellTemplatePromise: Promise<THREE.Object3D> | undefined
+let platformTemplatePromise: Promise<THREE.Object3D> | undefined
+
+function roleFromName(name: string): EgyptRole | undefined {
+  return (['SANDSTONE', 'CARVED', 'LIMESTONE', 'GOLD', 'BRONZE', 'PAVING'] as const).find(role =>
+    name.toUpperCase().includes(`_${role}`),
+  )
+}
+
+function loadTemplate(url: string, name: string): Promise<THREE.Object3D> {
+  return new GLTFLoader().loadAsync(geometryDetailModelUrl(url)).then(gltf => {
+    gltf.scene.name = name
+    gltf.scene.traverse(object => {
+      if (!(object instanceof THREE.Mesh)) return
+      const embedded = Array.isArray(object.material) ? object.material : [object.material]
+      embedded.forEach(material => material.dispose())
+      object.material = PLACEHOLDER
+    })
+    return gltf.scene
+  })
+}
+
+function shellTemplate(): Promise<THREE.Object3D> {
+  shellTemplatePromise ??= loadTemplate(EGYPT_ELEVATOR_SHELL_MODEL_URL, 'egypt-elevator-shell-template')
+  return shellTemplatePromise
+}
+
+function platformTemplate(): Promise<THREE.Object3D> {
+  platformTemplatePromise ??= loadTemplate(EGYPT_ELEVATOR_PLATFORM_MODEL_URL, 'egypt-elevator-platform-template')
+  return platformTemplatePromise
+}
+
+function materialForRole(role: EgyptRole, materials: EgyptElevatorBlenderMaterials): THREE.Material {
+  if (role === 'SANDSTONE') return materials.sandstone
+  if (role === 'CARVED') return materials.carvedStone
+  if (role === 'LIMESTONE') return materials.pyramidStone
+  if (role === 'GOLD') return materials.pyramidGold
+  if (role === 'BRONZE') return materials.bronze
+  return materials.paving
+}
+
+export function applyEgyptElevatorBlenderMaterials(
+  root: THREE.Object3D,
+  materials: EgyptElevatorBlenderMaterials,
+): void {
+  root.traverse(object => {
+    if (!(object instanceof THREE.Mesh)) return
+    const role = object.userData.egyptElevatorRole as EgyptRole | undefined
+    if (role) object.material = materialForRole(role, materials)
+  })
+}
+
+function attachModel(
+  host: THREE.Group,
+  template: THREE.Object3D,
+  name: string,
+  materials: EgyptElevatorBlenderMaterials,
+): THREE.Object3D {
+  const model = template.clone(true)
+  model.name = name
+  let meshCount = 0
+  let triangleCount = 0
+  model.traverse(object => {
+    object.userData.decorative = true
+    object.userData.visualOnly = true
+    object.userData.elevatorStyle = 'approved-egypt-blender-v5'
+    if (!(object instanceof THREE.Mesh)) return
+    const role = roleFromName(object.name)
+    if (!role) {
+      object.visible = false
+      return
+    }
+    object.material = materialForRole(role, materials)
+    object.castShadow = true
+    object.receiveShadow = true
+    object.frustumCulled = true
+    object.userData.egyptElevatorRole = role
+    object.userData.sharedGeometry = true
+    meshCount += 1
+    const position = object.geometry.getAttribute('position')
+    triangleCount += object.geometry.index ? object.geometry.index.count / 3 : position.count / 3
+  })
+  host.userData.loadedMeshCount = meshCount
+  host.userData.loadedTriangleCount = triangleCount
+  host.add(model)
+  return model
+}
+
+export function addEgyptElevatorBlenderShell(
+  host: THREE.Group,
+  name: string,
+  materials: EgyptElevatorBlenderMaterials,
+  scale: THREE.Vector3,
+  template?: THREE.Object3D,
+): Promise<THREE.Group> {
+  host.userData.modelUrl = EGYPT_ELEVATOR_SHELL_MODEL_URL
+  host.userData.approvedReference = '/docs/material-contracts/theme-elevator-egypt-approved-v3.png'
+  host.userData.constructionContract = 'egypt-elevator-approved-blender-v5'
+  host.userData.visualOnly = true
+  if (typeof document === 'undefined' && !template) {
+    host.userData.modelReady = Promise.resolve(host)
+    return host.userData.modelReady as Promise<THREE.Group>
+  }
+  const ready = template ? Promise.resolve(template) : shellTemplate()
+  host.userData.modelReady = ready.then(source => {
+    const model = attachModel(host, source, `${name}-egypt-approved-blender-shell`, materials)
+    model.scale.copy(scale)
+    // Blender +Y exports as Three.js -Z. The conveyor loading/front side is
+    // local +Z, so turn the authored shell around while leaving the symmetric
+    // moving platform cassettes and all mechanism physics unchanged.
+    model.rotation.y = EGYPT_ELEVATOR_SHELL_RUNTIME_YAW
+    model.userData.runtimeFront = 'local-positive-z'
+    model.userData.runtimeRelease = 'local-negative-z'
+    return host
+  })
+  return host.userData.modelReady as Promise<THREE.Group>
+}
+
+export function addEgyptElevatorBlenderPlatform(
+  host: THREE.Group,
+  name: string,
+  materials: EgyptElevatorBlenderMaterials,
+  scale: THREE.Vector3,
+  template?: THREE.Object3D,
+): Promise<THREE.Group> {
+  host.userData.modelUrl = EGYPT_ELEVATOR_PLATFORM_MODEL_URL
+  host.userData.visualOnly = true
+  if (typeof document === 'undefined' && !template) {
+    host.userData.modelReady = Promise.resolve(host)
+    return host.userData.modelReady as Promise<THREE.Group>
+  }
+  const ready = template ? Promise.resolve(template) : platformTemplate()
+  host.userData.modelReady = ready.then(source => {
+    const model = attachModel(host, source, `${name}-egypt-approved-blender-platform`, materials)
+    model.scale.copy(scale)
+    return host
+  })
+  return host.userData.modelReady as Promise<THREE.Group>
+}

package/src/pages/play/race/egypt-portal-frame.ts

@@ -0,0 +1,382 @@
+import * as THREE from 'three'
+
+import { VisualCylinderGeometry, VisualTorusGeometry, VisualCircleGeometry, VisualExtrudeGeometry, VisualBoxGeometry } from '../../../three/visual-geometry'
+import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js'
+
+import { PORTAL_APERTURE_HALF_WIDTH, PORTAL_THEME_FRAME_X_SCALE } from './portal-proportions'
+
+export const EGYPT_PORTAL_FRAME_THEME_ID = 'ancient-egypt'
+
+export interface EgyptPortalFrameMaterials {
+  sandstone: THREE.Material
+  carvedStone: THREE.Material
+  agedGold: THREE.Material
+}
+
+export interface EgyptPortalFrameOptions {
+  /** Portal-pair identity crystal and light; architectural reuse should disable this. */
+  includePairSignal?: boolean
+}
+
+interface GeometryBatch {
+  name: string
+  material: THREE.Material
+  parts: THREE.BufferGeometry[]
+}
+
+const IDENTITY_QUATERNION = new THREE.Quaternion()
+const UNIT_SCALE = new THREE.Vector3(1, 1, 1)
+const STONE_FRONT_Z = 0.5
+const CARVED_PANEL_FRONT_Z = 0.6
+
+/**
+ * Adds the visual-only Ancient Egypt housing around the shared portal aperture.
+ * The live camera surface, black aperture, rift glow and particles deliberately
+ * remain owned by portal-visual.ts.
+ */
+export function addEgyptPortalFrame(
+  root: THREE.Group,
+  name: string,
+  color: string,
+  materials: EgyptPortalFrameMaterials,
+  options: EgyptPortalFrameOptions = {},
+): THREE.Group {
+  const frame = new THREE.Group()
+  frame.name = `${name}-egypt-temple-frame`
+  frame.userData.themeOnly = EGYPT_PORTAL_FRAME_THEME_ID
+  frame.userData.decorative = true
+  frame.userData.visualOnly = true
+  frame.userData.portalFrameStyle = 'egypt-sandstone-pylon'
+  frame.scale.x = PORTAL_THEME_FRAME_X_SCALE
+  frame.userData.portalApertureClearHalfWidth = PORTAL_APERTURE_HALF_WIDTH
+  frame.userData.drawCallBudget = 4
+  frame.userData.triangleBudget = 8_000
+
+  const stone: THREE.BufferGeometry[] = []
+  const carvings: THREE.BufferGeometry[] = []
+  const gold: THREE.BufferGeometry[] = []
+
+  addPylonStone(stone)
+  addHieroglyphRelief(carvings)
+  addGoldInlays(gold)
+
+  addBatch(frame, name, { name: 'egypt-sandstone-pylon', material: materials.sandstone, parts: stone })
+  const carvedMesh = addBatch(frame, name, {
+    name: 'egypt-hieroglyph-relief',
+    material: materials.carvedStone,
+    parts: carvings,
+  })
+  carvedMesh.userData.motifs = ['ankh', 'lotus', 'reed-glyphs']
+  const goldMesh = addBatch(frame, name, {
+    name: 'egypt-aged-gold-inlays',
+    material: materials.agedGold,
+    parts: gold,
+  })
+  goldMesh.userData.motifs = ['winged-sun', 'pylon-bands', 'lotus-caps']
+  goldMesh.userData.crownTrimStyle = 'continuous-swept-gold-wings'
+  goldMesh.userData.stoneContactBackZ = STONE_FRONT_Z
+  goldMesh.userData.carvedPanelContactBackZ = CARVED_PANEL_FRONT_Z
+
+  if (options.includePairSignal !== false) addPairCrystal(frame, name, color)
+
+  frame.traverse(object => {
+    object.userData.themeOnly = EGYPT_PORTAL_FRAME_THEME_ID
+    object.userData.decorative = true
+    object.userData.visualOnly = true
+    object.userData.portalFrameStyle = 'egypt-sandstone-pylon'
+    if (object instanceof THREE.Mesh) {
+      object.castShadow = true
+      object.receiveShadow = true
+    }
+  })
+  root.add(frame)
+  return frame
+}
+
+function addPylonStone(parts: THREE.BufferGeometry[]): void {
+  parts.push(createPylonUpright(-1), createPylonUpright(1))
+  parts.push(roundedBox(4.92, 0.42, 0.9, 0.06, new THREE.Vector3(0, 1.42, 0)))
+  parts.push(roundedBox(5.22, 0.2, 1.02, 0.045, new THREE.Vector3(0, 1.73, -0.01)))
+  parts.push(roundedBox(4.76, 0.17, 0.94, 0.04, new THREE.Vector3(0, 1.12, 0.01)))
+
+  // Projecting masonry courses provide the macro depth visible in the approved
+  // pylon concept. Fine erosion remains in the aligned sandstone maps.
+  for (const side of [-1, 1] as const) {
+    for (let course = 0; course < 6; course += 1) {
+      const y = -1.42 + course * 0.47
+      const taper = (5 - course) * 0.025
+      const width = course % 2 === 0 ? 0.78 : 0.68
+      parts.push(
+        roundedBox(
+          width,
+          0.39,
+          0.98 + (course % 2) * 0.035,
+          0.055,
+          new THREE.Vector3(side * (2.16 + taper), y, 0.015 + (course % 2) * 0.018),
+        ),
+      )
+    }
+    parts.push(roundedBox(1.02, 0.28, 1.12, 0.055, new THREE.Vector3(side * 2.22, -1.67, -0.02)))
+    parts.push(roundedBox(0.9, 0.19, 1.02, 0.045, new THREE.Vector3(side * 2.18, -1.46, 0)))
+    parts.push(roundedBox(0.88, 0.24, 1.04, 0.05, new THREE.Vector3(side * 2.13, 1.18, 0)))
+  }
+
+  // Slightly uneven foot and crown blocks make the silhouette read as worn,
+  // assembled temple masonry without paying for individual wall bricks.
+  for (const side of [-1, 1] as const) {
+    parts.push(roundedBox(0.48, 0.32, 0.92, 0.045, new THREE.Vector3(side * 1.88, 1.02, 0.01)))
+  }
+}
+
+function createPylonUpright(side: -1 | 1): THREE.BufferGeometry {
+  const shape = new THREE.Shape()
+  if (side < 0) {
+    shape.moveTo(-2.56, -1.75)
+    shape.lineTo(-1.92, -1.75)
+    shape.lineTo(-1.82, 1.24)
+    shape.lineTo(-2.4, 1.24)
+  } else {
+    shape.moveTo(1.92, -1.75)
+    shape.lineTo(2.56, -1.75)
+    shape.lineTo(2.4, 1.24)
+    shape.lineTo(1.82, 1.24)
+  }
+  shape.closePath()
+  const geometry = new VisualExtrudeGeometry(shape, {
+    depth: 0.9,
+    bevelEnabled: true,
+    bevelSegments: 2,
+    bevelSize: 0.035,
+    bevelThickness: 0.025,
+    curveSegments: 1,
+    steps: 1,
+  })
+  geometry.translate(0, 0, -0.45)
+  return metricPlanarUvGeometry(geometry)
+}
+
+function addHieroglyphRelief(parts: THREE.BufferGeometry[]): void {
+  const reliefZ = 0.625
+  for (const side of [-1, 1] as const) {
+    const x = side * 2.14
+
+    // A separate recessed carved slab makes the inscription read as an
+    // architectural panel rather than lines floating on wallpaper.
+    parts.push(roundedBox(0.55, 2.2, 0.16, 0.045, new THREE.Vector3(x, -0.16, 0.52)))
+
+    // Ankh: loop, crossbar and stem.
+    parts.push(
+      transformed(
+        new VisualTorusGeometry(0.095, 0.026, 5, 14),
+        new THREE.Vector3(x, 0.58, reliefZ),
+      ),
+    )
+    parts.push(roundedBox(0.055, 0.36, 0.045, 0.012, new THREE.Vector3(x, 0.28, reliefZ)))
+    parts.push(roundedBox(0.24, 0.05, 0.045, 0.012, new THREE.Vector3(x, 0.37, reliefZ)))
+
+    // A compact reed/river glyph stack.
+    parts.push(roundedBox(0.055, 0.34, 0.045, 0.012, new THREE.Vector3(x, -0.48, reliefZ)))
+    for (const offset of [-0.13, 0.13]) {
+      parts.push(
+        roundedBox(
+          0.055,
+          0.2,
+          0.045,
+          0.012,
+          new THREE.Vector3(x + offset, -0.42, reliefZ),
+          new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 0, 1), side * offset * 2.6),
+        ),
+      )
+    }
+
+    // Shallow lotus at the foot: one stem and three low-poly petals.
+    parts.push(roundedBox(0.045, 0.28, 0.045, 0.01, new THREE.Vector3(x, -1.18, reliefZ)))
+    for (const [petalIndex, offset] of [-0.1, 0, 0.1].entries()) {
+      const rotation = (petalIndex - 1) * -0.42
+      parts.push(
+        transformed(
+          new VisualCircleGeometry(0.095, 5),
+          new THREE.Vector3(x + offset, -1.01, reliefZ + 0.024),
+          new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 0, 1), rotation),
+          new THREE.Vector3(0.66, 1.28, 1),
+        ),
+      )
+    }
+  }
+}
+
+function addGoldInlays(parts: THREE.BufferGeometry[]): void {
+  const trimDepth = 0.055
+  const stoneTrimCenterZ = STONE_FRONT_Z + trimDepth * 0.5 - 0.004
+  const panelTrimCenterZ = CARVED_PANEL_FRONT_Z + trimDepth * 0.5 - 0.004
+  for (const side of [-1, 1] as const) {
+    parts.push(
+      roundedBox(0.72, 0.085, trimDepth, 0.018, new THREE.Vector3(side * 2.17, 0.91, panelTrimCenterZ)),
+    )
+    parts.push(
+      roundedBox(0.76, 0.085, trimDepth, 0.018, new THREE.Vector3(side * 2.21, -0.86, panelTrimCenterZ)),
+    )
+  }
+  parts.push(roundedBox(4.7, 0.07, trimDepth, 0.016, new THREE.Vector3(0, 1.3, stoneTrimCenterZ)))
+  parts.push(roundedBox(4.98, 0.06, trimDepth, 0.014, new THREE.Vector3(0, 1.72, stoneTrimCenterZ)))
+
+  // Geometry-first winged sun socket: a central disc with two continuous
+  // swept wings. The previous stack of short offset bars read as a dark
+  // staircase/bridge instead of Egyptian gold ornament.
+  parts.push(
+    transformed(
+      new VisualCylinderGeometry(0.3, 0.3, 0.065, 20),
+      new THREE.Vector3(0, 1.49, STONE_FRONT_Z + 0.028),
+      new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(1, 0, 0), Math.PI / 2),
+    ),
+  )
+  for (const side of [-1, 1] as const) {
+    parts.push(createSweptGoldWing(side, STONE_FRONT_Z))
+  }
+}
+
+function createSweptGoldWing(side: -1 | 1, z: number): THREE.BufferGeometry {
+  const shape = new THREE.Shape()
+  shape.moveTo(side * 0.26, 1.48)
+  shape.quadraticCurveTo(side * 0.94, 1.68, side * 1.76, 1.59)
+  shape.lineTo(side * 1.76, 1.48)
+  shape.quadraticCurveTo(side * 0.98, 1.45, side * 0.26, 1.4)
+  shape.closePath()
+  const wing = new VisualExtrudeGeometry(shape, {
+    depth: 0.075,
+    bevelEnabled: true,
+    bevelSegments: 2,
+    bevelSize: 0.014,
+    bevelThickness: 0.012,
+    curveSegments: 8,
+    steps: 1,
+  })
+  wing.translate(0, 0, z)
+  return metricPlanarUvGeometry(wing)
+}
+
+function addPairCrystal(frame: THREE.Group, name: string, color: string): void {
+  const crystalMaterial = new THREE.MeshPhysicalMaterial({
+    color,
+    emissive: color,
+    emissiveIntensity: 1.25,
+    metalness: 0.04,
+    roughness: 0.16,
+    // A tiny decorative gem must not trigger a full-scene refraction pass.
+    transmission: 0,
+    thickness: 0.2,
+    clearcoat: 1,
+    clearcoatRoughness: 0.1,
+  })
+  crystalMaterial.name = `${name}-egypt-pair-crystal-material`
+
+  const crystalParts = [
+    transformed(
+      new THREE.OctahedronGeometry(0.22, 0),
+      new THREE.Vector3(0, 1.5, 0.66),
+      IDENTITY_QUATERNION,
+      new THREE.Vector3(0.82, 1.18, 0.56),
+    ),
+    transformed(
+      new THREE.OctahedronGeometry(0.105, 0),
+      new THREE.Vector3(-0.2, 1.46, 0.61),
+      new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 0, 1), -0.5),
+      new THREE.Vector3(0.65, 1.25, 0.5),
+    ),
+    transformed(
+      new THREE.OctahedronGeometry(0.105, 0),
+      new THREE.Vector3(0.2, 1.46, 0.61),
+      new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 0, 1), 0.5),
+      new THREE.Vector3(0.65, 1.25, 0.5),
+    ),
+  ]
+  const crystalGeometry = mergeGeometries(crystalParts, false)
+  crystalParts.forEach(part => part.dispose())
+  if (!crystalGeometry) throw new Error('Unable to merge Egypt portal pair crystal geometry.')
+  crystalGeometry.computeBoundingBox()
+  crystalGeometry.computeBoundingSphere()
+  crystalGeometry.userData.visualOnly = true
+  const crystal = new THREE.Mesh(crystalGeometry, crystalMaterial)
+  crystal.name = `${name}-egypt-pair-crystal`
+  crystal.userData.ownsMaterial = true
+  crystal.userData.portalPairColor = color
+  crystal.userData.portalLightSource = 'faceted-scarab-crystal'
+  frame.add(crystal)
+
+  const light = new THREE.PointLight(color, 0.55, 3.2, 2)
+  light.name = `${name}-egypt-pair-crystal-light`
+  light.position.set(0, 1.45, 0.78)
+  light.userData.portalPairColor = color
+  light.userData.portalLightSource = 'faceted-scarab-crystal'
+  frame.add(light)
+}
+
+function addBatch(frame: THREE.Group, name: string, batch: GeometryBatch): THREE.Mesh {
+  const geometry = mergeGeometries(batch.parts, false)
+  batch.parts.forEach(part => part.dispose())
+  if (!geometry) throw new Error(`Unable to merge Egypt portal frame batch "${batch.name}".`)
+  geometry.name = `${name}-${batch.name}-geometry`
+  geometry.computeBoundingBox()
+  geometry.computeBoundingSphere()
+  geometry.userData.visualOnly = true
+  const mesh = new THREE.Mesh(geometry, batch.material)
+  mesh.name = `${name}-${batch.name}`
+  frame.add(mesh)
+  return mesh
+}
+
+function roundedBox(
+  width: number,
+  height: number,
+  depth: number,
+  radius: number,
+  position: THREE.Vector3,
+  rotation = IDENTITY_QUATERNION,
+): THREE.BufferGeometry {
+  return transformed(
+    new VisualBoxGeometry(width, height, depth, 2, Math.min(radius, width / 4, height / 4, depth / 4)),
+    position,
+    rotation,
+  )
+}
+
+function transformed(
+  geometry: THREE.BufferGeometry,
+  position: THREE.Vector3,
+  rotation = IDENTITY_QUATERNION,
+  scale = UNIT_SCALE,
+): THREE.BufferGeometry {
+  geometry.applyMatrix4(new THREE.Matrix4().compose(position, rotation, scale))
+  return metricPlanarUvGeometry(geometry)
+}
+
+function metricPlanarUvGeometry(geometry: THREE.BufferGeometry): THREE.BufferGeometry {
+  const prepared = geometry.index ? geometry.toNonIndexed() : geometry
+  if (prepared !== geometry) geometry.dispose()
+  const position = prepared.getAttribute('position')
+  const normal = prepared.getAttribute('normal')
+  const uvs = new Float32Array(position.count * 2)
+  const metricUvs = new Float32Array(position.count * 4)
+  for (let index = 0; index < position.count; index += 1) {
+    const x = position.getX(index)
+    const y = position.getY(index)
+    const z = position.getZ(index)
+    const nx = Math.abs(normal.getX(index))
+    const ny = Math.abs(normal.getY(index))
+    const nz = Math.abs(normal.getZ(index))
+    if (nx >= ny && nx >= nz) {
+      uvs[index * 2] = z
+      uvs[index * 2 + 1] = y
+    } else if (ny >= nz) {
+      uvs[index * 2] = x
+      uvs[index * 2 + 1] = z
+    } else {
+      uvs[index * 2] = x
+      uvs[index * 2 + 1] = y
+    }
+    metricUvs[index * 4 + 2] = 1
+  }
+  prepared.setAttribute('uv', new THREE.BufferAttribute(uvs, 2))
+  prepared.setAttribute('themeNetUv', new THREE.BufferAttribute(metricUvs, 4))
+  return prepared
+}

package/src/pages/play/race/finish-detection.ts

@@ -0,0 +1 @@
+export { hasMarbleCrossedFinishPlane, type FinishPlaneCheck } from '@marble.fun/physics-engine'