@marble.fun/track-catalog 3.0.0

package/src/pages/play/race/japanese-sakura-castle-support-blender.ts

@@ -0,0 +1,510 @@
+import { geometryDetailModelUrl } from '../../../three/geometry-detail'
+import * as THREE from 'three'
+import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js'
+
+import {
+  UNDER_TRACK_SUPPORT_BAY_LENGTH,
+  UNDER_TRACK_SUPPORT_DEPTH,
+  UNDER_TRACK_SUPPORT_FADE_START_DEPTH,
+  UNDER_TRACK_SUPPORT_FOOTPRINT_SCALE,
+  underTrackSupportFadeAtDepth,
+} from './under-track-support-architecture'
+
+export const JAPANESE_SAKURA_CASTLE_SUPPORT_MODEL_URL = '/models/supports/japanese-sakura-castle-support-v2.glb'
+
+const AUTHORED_SUPPORT_DEPTH = 10.8
+const AUTHORED_SUPPORT_BAY_LENGTH = 5
+const DECK_UNDERSIDE_OFFSET = 0.38
+
+export interface SakuraCastleSupportFrame {
+  point: THREE.Vector3
+  tangent: THREE.Vector3
+  right: THREE.Vector3
+  up: THREE.Vector3
+  width: number
+}
+
+export interface SakuraCastleSupportOptions {
+  capStart?: boolean
+  capEnd?: boolean
+  /** Cumulative topology distance at this piece's input connector. */
+  connectionPhase?: number
+  /** Complete topology-owned bays, including connector-crossing and short-piece bays. */
+  ownedBayDistances?: readonly (readonly [start: number, end: number])[]
+}
+
+let templatePromise: Promise<THREE.Object3D> | undefined
+
+function loadTemplate(): Promise<THREE.Object3D> {
+  templatePromise ??= new GLTFLoader()
+    .loadAsync(geometryDetailModelUrl(JAPANESE_SAKURA_CASTLE_SUPPORT_MODEL_URL))
+    .then(gltf => {
+      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())
+      })
+      gltf.scene.updateMatrixWorld(true)
+      return gltf.scene
+    })
+  return templatePromise
+}
+
+const WORLD_UP = new THREE.Vector3(0, 1, 0)
+
+function reverseTriangleWinding(geometry: THREE.BufferGeometry): void {
+  const index = geometry.getIndex()
+  if (index) {
+    for (let offset = 0; offset < index.count; offset += 3) {
+      const second = index.getX(offset + 1)
+      index.setX(offset + 1, index.getX(offset + 2))
+      index.setX(offset + 2, second)
+    }
+    index.needsUpdate = true
+    return
+  }
+
+  for (const attribute of Object.values(geometry.attributes)) {
+    if (!(attribute instanceof THREE.BufferAttribute || attribute instanceof THREE.InterleavedBufferAttribute)) continue
+    for (let offset = 0; offset < attribute.count; offset += 3) {
+      for (let component = 0; component < attribute.itemSize; component += 1) {
+        const second = attribute.getComponent(offset + 1, component)
+        attribute.setComponent(offset + 1, component, attribute.getComponent(offset + 2, component))
+        attribute.setComponent(offset + 2, component, second)
+      }
+    }
+    attribute.needsUpdate = true
+  }
+}
+
+function clipLongitudinalHalf(
+  geometry: THREE.BufferGeometry,
+  half: 'negative' | 'positive',
+): THREE.BufferGeometry {
+  const position = geometry.getAttribute('position')
+  const index = geometry.getIndex()
+  const attributes = Object.entries(geometry.attributes).filter(
+    (entry): entry is [string, THREE.BufferAttribute | THREE.InterleavedBufferAttribute] =>
+      entry[1] instanceof THREE.BufferAttribute || entry[1] instanceof THREE.InterleavedBufferAttribute,
+  )
+  type Vertex = Record<string, number[]>
+  const readVertex = (vertexIndex: number): Vertex =>
+    Object.fromEntries(
+      attributes.map(([name, attribute]) => [
+        name,
+        Array.from({ length: attribute.itemSize }, (_unused, component) =>
+          attribute.getComponent(vertexIndex, component),
+        ),
+      ]),
+    )
+  const interpolate = (from: Vertex, to: Vertex, amount: number): Vertex =>
+    Object.fromEntries(
+      attributes.map(([name, attribute]) => [
+        name,
+        Array.from(
+          { length: attribute.itemSize },
+          (_unused, component) =>
+            from[name]![component]! + (to[name]![component]! - from[name]![component]!) * amount,
+        ),
+      ]),
+    )
+  const inside = (vertex: Vertex) =>
+    half === 'positive' ? vertex.position![0]! >= -0.000_001 : vertex.position![0]! <= 0.000_001
+  const clippedAttributes = new Map(attributes.map(([name]) => [name, [] as number[]]))
+  const planeEdges = new Map<string, { count: number; from: Vertex; to: Vertex }>()
+  const planeKey = (vertex: Vertex) =>
+    `${Math.round(vertex.position![1]! * 1_000_000)}:${Math.round(vertex.position![2]! * 1_000_000)}`
+  const edgeKey = (from: Vertex, to: Vertex) => [planeKey(from), planeKey(to)].sort().join('|')
+  const triangleCount = (index?.count ?? position.count) / 3
+  for (let triangle = 0; triangle < triangleCount; triangle += 1) {
+    const offset = triangle * 3
+    const polygon = [
+      readVertex(index?.getX(offset) ?? offset),
+      readVertex(index?.getX(offset + 1) ?? offset + 1),
+      readVertex(index?.getX(offset + 2) ?? offset + 2),
+    ]
+    const clipped: Vertex[] = []
+    for (let vertexIndex = 0; vertexIndex < polygon.length; vertexIndex += 1) {
+      const current = polygon[vertexIndex]!
+      const next = polygon[(vertexIndex + 1) % polygon.length]!
+      const currentInside = inside(current)
+      const nextInside = inside(next)
+      if (currentInside) clipped.push(current)
+      if (currentInside === nextInside) continue
+      const currentX = current.position![0]!
+      const nextX = next.position![0]!
+      clipped.push(interpolate(current, next, -currentX / (nextX - currentX)))
+    }
+    for (let vertexIndex = 0; vertexIndex < clipped.length; vertexIndex += 1) {
+      const from = clipped[vertexIndex]!
+      const to = clipped[(vertexIndex + 1) % clipped.length]!
+      if (Math.abs(from.position![0]!) > 0.000_01 || Math.abs(to.position![0]!) > 0.000_01) continue
+      const key = edgeKey(from, to)
+      const existing = planeEdges.get(key)
+      planeEdges.set(key, existing ? { ...existing, count: existing.count + 1 } : { count: 1, from, to })
+    }
+    for (let fan = 1; fan < clipped.length - 1; fan += 1) {
+      for (const vertex of [clipped[0]!, clipped[fan]!, clipped[fan + 1]!]) {
+        for (const [name] of attributes) clippedAttributes.get(name)!.push(...vertex[name]!)
+      }
+    }
+  }
+  const boundaryEdges = [...planeEdges.values()].filter(edge => edge.count % 2 === 1)
+  const verticesByKey = new Map<string, Vertex>()
+  const neighbours = new Map<string, Set<string>>()
+  const remainingEdges = new Set<string>()
+  for (const edge of boundaryEdges) {
+    const fromKey = planeKey(edge.from)
+    const toKey = planeKey(edge.to)
+    verticesByKey.set(fromKey, edge.from)
+    verticesByKey.set(toKey, edge.to)
+    const fromNeighbours = neighbours.get(fromKey) ?? new Set<string>()
+    const toNeighbours = neighbours.get(toKey) ?? new Set<string>()
+    fromNeighbours.add(toKey)
+    toNeighbours.add(fromKey)
+    neighbours.set(fromKey, fromNeighbours)
+    neighbours.set(toKey, toNeighbours)
+    remainingEdges.add([fromKey, toKey].sort().join('|'))
+  }
+  const appendCapVertex = (vertex: Vertex): void => {
+    for (const [name, attribute] of attributes) {
+      const values = [...vertex[name]!]
+      if (name === 'normal' && attribute.itemSize >= 3) values.splice(0, 3, half === 'positive' ? -1 : 1, 0, 0)
+      clippedAttributes.get(name)!.push(...values)
+    }
+  }
+  while (remainingEdges.size > 0) {
+    const firstEdge = remainingEdges.values().next().value as string
+    const [start, next] = firstEdge.split('|') as [string, string]
+    const loop = [start]
+    let previous = start
+    let current = next
+    remainingEdges.delete(firstEdge)
+    while (current !== start) {
+      loop.push(current)
+      const candidate = [...(neighbours.get(current) ?? [])].find(neighbour => {
+        if (neighbour === previous) return false
+        return remainingEdges.has([current, neighbour].sort().join('|'))
+      })
+      if (!candidate) break
+      remainingEdges.delete([current, candidate].sort().join('|'))
+      previous = current
+      current = candidate
+    }
+    if (current !== start || loop.length < 3) continue
+    const contour = loop.map(key => {
+      const vertex = verticesByKey.get(key)!
+      return new THREE.Vector2(vertex.position![1]!, vertex.position![2]!)
+    })
+    for (const triangle of THREE.ShapeUtils.triangulateShape(contour, [])) {
+      const vertices = triangle.map(vertexIndex => verticesByKey.get(loop[vertexIndex]!)!)
+      const [a, b, c] = vertices
+      const crossX =
+        (b!.position![1]! - a!.position![1]!) * (c!.position![2]! - a!.position![2]!) -
+        (b!.position![2]! - a!.position![2]!) * (c!.position![1]! - a!.position![1]!)
+      const outwardX = half === 'positive' ? -1 : 1
+      if (crossX * outwardX < 0) [vertices[1], vertices[2]] = [vertices[2]!, vertices[1]!]
+      vertices.forEach(appendCapVertex)
+    }
+  }
+  const clippedGeometry = new THREE.BufferGeometry()
+  for (const [name, attribute] of attributes) {
+    clippedGeometry.setAttribute(
+      name,
+      new THREE.Float32BufferAttribute(clippedAttributes.get(name)!, attribute.itemSize, attribute.normalized),
+    )
+  }
+  return clippedGeometry
+}
+
+function cumulativeDistances(frames: readonly SakuraCastleSupportFrame[]): number[] {
+  const distances = [0]
+  for (let index = 1; index < frames.length; index += 1) {
+    distances.push(distances[index - 1]! + frames[index - 1]!.point.distanceTo(frames[index]!.point))
+  }
+  return distances
+}
+
+function frameAtDistance(
+  frames: readonly SakuraCastleSupportFrame[],
+  distances: readonly number[],
+  target: number,
+): SakuraCastleSupportFrame {
+  const length = distances.at(-1) ?? 0
+  if (target < 0) {
+    const start = frames[0]!
+    return { ...start, point: start.point.clone().addScaledVector(start.tangent, target) }
+  }
+  if (target > length) {
+    const end = frames.at(-1)!
+    return { ...end, point: end.point.clone().addScaledVector(end.tangent, target - length) }
+  }
+  const clamped = target
+  let segment = 0
+  while (segment < distances.length - 2 && distances[segment + 1]! < clamped) segment += 1
+  const span = Math.max(0.000_001, distances[segment + 1]! - distances[segment]!)
+  const progress = (clamped - distances[segment]!) / span
+  const start = frames[segment]!
+  const end = frames[segment + 1]!
+  const tangent = start.tangent.clone().lerp(end.tangent, progress).normalize()
+  const right = start.right.clone().lerp(end.right, progress)
+  right.addScaledVector(tangent, -right.dot(tangent)).normalize()
+  const up = new THREE.Vector3().crossVectors(tangent, right).normalize()
+  return {
+    point: start.point.clone().lerp(end.point, progress),
+    tangent,
+    right,
+    up,
+    width: THREE.MathUtils.lerp(start.width, end.width, progress),
+  }
+}
+
+function distanceAlongPath(
+  frames: readonly SakuraCastleSupportFrame[],
+  distances: readonly number[],
+  sampled: SakuraCastleSupportFrame,
+): number {
+  let closestDistanceSquared = Number.POSITIVE_INFINITY
+  let closestPathDistance = 0
+  for (let index = 0; index < frames.length - 1; index += 1) {
+    const start = frames[index]!.point
+    const end = frames[index + 1]!.point
+    const segment = end.clone().sub(start)
+    const lengthSquared = segment.lengthSq()
+    const interpolation =
+      lengthSquared <= 0.000_000_1
+        ? 0
+        : THREE.MathUtils.clamp(sampled.point.clone().sub(start).dot(segment) / lengthSquared, 0, 1)
+    const closest = start.clone().addScaledVector(segment, interpolation)
+    const distanceSquared = closest.distanceToSquared(sampled.point)
+    if (distanceSquared >= closestDistanceSquared) continue
+    closestDistanceSquared = distanceSquared
+    closestPathDistance =
+      distances[index]! + Math.sqrt(lengthSquared) * interpolation
+  }
+  return closestPathDistance
+}
+
+function deformModule(
+  source: THREE.Object3D,
+  pathFrames: readonly SakuraCastleSupportFrame[],
+  distances: readonly number[],
+  centerDistance: number,
+  material: THREE.Material,
+  name: string,
+  longitudinalScale = 1,
+  connectionPhase = 0,
+  longitudinalHalf?: 'negative' | 'positive',
+): THREE.Group {
+  source.updateMatrixWorld(true)
+  const group = new THREE.Group()
+  group.name = name
+  source.traverse(object => {
+    if (!(object instanceof THREE.Mesh)) return
+    let geometry = object.geometry.clone().applyMatrix4(object.matrixWorld)
+    if (longitudinalHalf) {
+      const unclipped = geometry
+      geometry = clipLongitudinalHalf(unclipped, longitudinalHalf)
+      unclipped.dispose()
+    }
+    const centerFrame = frameAtDistance(pathFrames, distances, centerDistance)
+    const deformationBasis = new THREE.Matrix4().makeBasis(
+      centerFrame.tangent.clone().multiplyScalar(longitudinalScale),
+      WORLD_UP.clone().multiplyScalar(UNDER_TRACK_SUPPORT_DEPTH / AUTHORED_SUPPORT_DEPTH),
+      centerFrame.right.clone().multiplyScalar(UNDER_TRACK_SUPPORT_FOOTPRINT_SCALE),
+    )
+    if (deformationBasis.determinant() * object.matrixWorld.determinant() < 0) {
+      reverseTriangleWinding(geometry)
+    }
+    const position = geometry.getAttribute('position')
+    const local = new THREE.Vector3()
+    const normal = geometry.getAttribute('normal')
+    const fades = new Float32Array(position.count)
+    const fadeDepthModes = new Float32Array(position.count)
+    const fadeDepths = new Float32Array(position.count)
+    const fadeStarts = new Float32Array(position.count)
+    const fadeEnds = new Float32Array(position.count)
+    const metric = new Float32Array(position.count * 4)
+    const orientedUvs = new Float32Array(position.count * 2)
+    for (let index = 0; index < position.count; index += 1) {
+      local.fromBufferAttribute(position, index)
+      const scaledLocalY = local.y * (UNDER_TRACK_SUPPORT_DEPTH / AUTHORED_SUPPORT_DEPTH)
+      const supportDepth = Math.max(0, -scaledLocalY)
+      const pathDistance = centerDistance + local.x * longitudinalScale
+      const pathFrame = frameAtDistance(pathFrames, distances, pathDistance)
+      const world = pathFrame.point
+        .clone()
+        .addScaledVector(pathFrame.right, local.z * UNDER_TRACK_SUPPORT_FOOTPRINT_SCALE)
+        .addScaledVector(WORLD_UP, scaledLocalY - DECK_UNDERSIDE_OFFSET)
+      position.setXYZ(index, world.x, world.y, world.z)
+      fades[index] = underTrackSupportFadeAtDepth(supportDepth)
+      fadeDepthModes[index] = 1
+      fadeDepths[index] = supportDepth
+      fadeStarts[index] = UNDER_TRACK_SUPPORT_FADE_START_DEPTH
+      fadeEnds[index] = UNDER_TRACK_SUPPORT_DEPTH
+      orientedUvs.set(
+        [connectionPhase + pathDistance, world.clone().sub(pathFrame.point).dot(pathFrame.up)],
+        index * 2,
+      )
+      // z=1 selects directional UVs; w=0 declares those UVs in world units so
+      // the recipe retains ownership of scale while the path owns orientation.
+      metric.set([0, 0, 1, 0], index * 4)
+    }
+    position.needsUpdate = true
+    if (normal) geometry.deleteAttribute('normal')
+    geometry.computeVertexNormals()
+    geometry.setAttribute('uv', new THREE.BufferAttribute(orientedUvs, 2))
+    geometry.setAttribute('supportFade', new THREE.BufferAttribute(fades, 1))
+    geometry.setAttribute('supportFadeDepthMode', new THREE.BufferAttribute(fadeDepthModes, 1))
+    geometry.setAttribute('supportFadeDepth', new THREE.BufferAttribute(fadeDepths, 1))
+    geometry.setAttribute('supportFadeStart', new THREE.BufferAttribute(fadeStarts, 1))
+    geometry.setAttribute('supportFadeEnd', new THREE.BufferAttribute(fadeEnds, 1))
+    geometry.setAttribute('themeNetUv', new THREE.BufferAttribute(metric, 4))
+    geometry.computeBoundingBox()
+    geometry.computeBoundingSphere()
+    const mesh = new THREE.Mesh(geometry, material)
+    mesh.name = `${name}-${object.name}`
+    mesh.castShadow = true
+    mesh.receiveShadow = true
+    mesh.userData.decorative = true
+    mesh.userData.visualOnly = true
+    mesh.userData.supportStyle = 'path-deformed-approved-japanese-sakura-castle-v2'
+    group.add(mesh)
+  })
+  return group
+}
+
+function addTerminalHalfArch(
+  host: THREE.Group,
+  arch: THREE.Object3D,
+  pathFrames: readonly SakuraCastleSupportFrame[],
+  distances: readonly number[],
+  spanLength: number,
+  terminalDistance: number,
+  half: 'negative' | 'positive',
+  connectionPhase: number,
+  material: THREE.Material,
+  name: string,
+): void {
+  if (spanLength <= 0.000_001) return
+  const terminal = deformModule(
+    arch,
+    pathFrames,
+    distances,
+    terminalDistance,
+    material,
+    name,
+    (spanLength * 2) / AUTHORED_SUPPORT_BAY_LENGTH,
+    connectionPhase,
+    half,
+  )
+  terminal.userData.supportRole = 'exposed-terminal-half-arch'
+  host.add(terminal)
+}
+
+export function addJapaneseSakuraCastleSupportModel(
+  host: THREE.Group,
+  pieceId: string,
+  pathFrames: readonly SakuraCastleSupportFrame[],
+  sampledFrames: readonly SakuraCastleSupportFrame[],
+  fallbackMaterial: THREE.Material,
+  options: SakuraCastleSupportOptions,
+  template?: THREE.Object3D,
+): Promise<THREE.Group> {
+  host.userData.modelUrl = JAPANESE_SAKURA_CASTLE_SUPPORT_MODEL_URL
+  host.userData.constructionContract = 'approved-japanese-sakura-castle-blender-v2'
+  host.userData.endpointRule = 'cap-exposed-ends;outgoing-piece-owns-connected-arch'
+  host.userData.supportBentCount = sampledFrames.length
+  host.userData.supportDepth = UNDER_TRACK_SUPPORT_DEPTH
+  host.userData.supportBayLength = UNDER_TRACK_SUPPORT_BAY_LENGTH
+  host.userData.hasDragonHero = false
+  host.userData.dragonSideCoverage = 'none'
+
+  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) : loadTemplate()
+  host.userData.modelReady = ready.then(source => {
+    if (host.userData.supportDisposed === true) return host
+    const pier = source.getObjectByName('Pier_Module')
+    const arch = source.getObjectByName('ArchSpan_Module')
+    if (!pier || !arch) throw new Error('Japanese Sakura castle support GLB is missing its authored modules')
+
+    const distances = cumulativeDistances(pathFrames)
+    const sampledDistances = sampledFrames.map(frame => distanceAlongPath(pathFrames, distances, frame))
+    sampledFrames.forEach((_frame, index) => {
+      host.add(
+        deformModule(
+          pier,
+          pathFrames,
+          distances,
+          sampledDistances[index]!,
+          fallbackMaterial,
+          `${pieceId}-castle-pier-${index + 1}`,
+          UNDER_TRACK_SUPPORT_FOOTPRINT_SCALE,
+          options.connectionPhase,
+        ),
+      )
+    })
+    const ownedBays = options.ownedBayDistances
+      ? [...options.ownedBayDistances]
+      : sampledDistances.slice(0, -1).map((start, index) => [start, sampledDistances[index + 1]!] as const)
+    if (!options.ownedBayDistances && options.capEnd === false && sampledDistances.length > 0) {
+      ownedBays.push([sampledDistances.at(-1)!, sampledDistances.at(-1)! + UNDER_TRACK_SUPPORT_BAY_LENGTH])
+    }
+    for (const [index, [startDistance, endDistance]] of ownedBays.entries()) {
+      const crossesEndConnector =
+        endDistance > (distances.at(-1) ?? 0) + 0.000_001 ||
+        (!options.ownedBayDistances && options.capEnd === false && index === ownedBays.length - 1)
+      host.add(
+        deformModule(
+          arch,
+          pathFrames,
+          distances,
+          (startDistance + endDistance) / 2,
+          fallbackMaterial,
+          crossesEndConnector ? `${pieceId}-castle-connector-arch` : `${pieceId}-castle-arch-${index + 1}`,
+          (endDistance - startDistance) / AUTHORED_SUPPORT_BAY_LENGTH,
+          options.connectionPhase,
+        ),
+      )
+    }
+
+    const stoneMaterial = fallbackMaterial
+    const pathLength = distances.at(-1) ?? 0
+    const firstPierDistance = sampledDistances[0] ?? pathLength * 0.5
+    const lastPierDistance = sampledDistances.at(-1) ?? pathLength * 0.5
+    if (options.capStart !== false) {
+      addTerminalHalfArch(
+        host,
+        arch,
+        pathFrames,
+        distances,
+        firstPierDistance,
+        0,
+        'positive',
+        options.connectionPhase ?? 0,
+        stoneMaterial,
+        `${pieceId}-castle-start-half-arch`,
+      )
+    }
+    if (options.capEnd !== false) {
+      addTerminalHalfArch(
+        host,
+        arch,
+        pathFrames,
+        distances,
+        pathLength - lastPierDistance,
+        pathLength,
+        'negative',
+        options.connectionPhase ?? 0,
+        stoneMaterial,
+        `${pieceId}-castle-end-half-arch`,
+      )
+    }
+    return host
+  })
+  return host.userData.modelReady as Promise<THREE.Group>
+}