@marble.fun/track-catalog 3.0.0

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

@@ -0,0 +1,308 @@
+import * as THREE from 'three'
+
+import { VisualConeGeometry, VisualTubeGeometry, 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 JUNGLE_PORTAL_FRAME_THEME_ID = 'low-poly-jungle'
+
+export interface JunglePortalFrameMaterials {
+  /** Exact `jungle.temple-stone` appearance from the active registry. */
+  stone: THREE.Material
+  /** Retained for shared material-bundle compatibility; portals use stone courses on both pillars. */
+  facade?: THREE.Material
+  /** Exact `jungle.temple-bronze` appearance. */
+  bronze: THREE.Material
+  /** Existing Jungle world foliage appearance; no portal-private plant recipe. */
+  foliage: THREE.Material
+}
+
+export interface JunglePortalFrameOptions {
+  root: THREE.Group
+  name: string
+  color: string
+  materials: JunglePortalFrameMaterials
+}
+
+const FRONT_Z = 0.46
+const IDENTITY_QUATERNION = new THREE.Quaternion()
+const SHARED_SCALE = new THREE.Vector3(1, 1, 1)
+
+function markVisualOnly(object: THREE.Object3D, frameStyle = 'jungle-serpent-temple'): void {
+  object.userData.themeOnly = JUNGLE_PORTAL_FRAME_THEME_ID
+  object.userData.decorative = true
+  object.userData.visualOnly = true
+  object.userData.portalFrameStyle = frameStyle
+}
+
+/** Give repeatable stone/metal recipes stable world-sized planar coordinates. */
+function metricPlanarUvs(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 uv = new Float32Array(position.count * 2)
+  const themeNetUv = 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) {
+      uv[index * 2] = z
+      uv[index * 2 + 1] = y
+    } else if (ny >= nz) {
+      uv[index * 2] = x
+      uv[index * 2 + 1] = z
+    } else {
+      uv[index * 2] = x
+      uv[index * 2 + 1] = y
+    }
+    themeNetUv[index * 4 + 2] = 1
+  }
+  prepared.setAttribute('uv', new THREE.BufferAttribute(uv, 2))
+  prepared.setAttribute('themeNetUv', new THREE.BufferAttribute(themeNetUv, 4))
+  return prepared
+}
+
+function transformGeometry(
+  geometry: THREE.BufferGeometry,
+  position: THREE.Vector3,
+  rotation = IDENTITY_QUATERNION,
+  scale = SHARED_SCALE,
+): THREE.BufferGeometry {
+  geometry.applyMatrix4(new THREE.Matrix4().compose(position, rotation, scale))
+  return geometry
+}
+
+function roundedStone(size: THREE.Vector3, position: THREE.Vector3, radius = 0.07): THREE.BufferGeometry {
+  return transformGeometry(metricPlanarUvs(new VisualBoxGeometry(size.x, size.y, size.z, 2, radius)), position)
+}
+
+function mergeBatch(
+  frame: THREE.Group,
+  name: string,
+  material: THREE.Material,
+  parts: THREE.BufferGeometry[],
+): THREE.Mesh {
+  const geometry = mergeGeometries(parts, false)
+  parts.forEach(part => part.dispose())
+  if (!geometry) throw new Error(`Unable to merge Jungle portal batch "${name}".`)
+  geometry.name = `${name}-geometry`
+  geometry.computeBoundingBox()
+  geometry.computeBoundingSphere()
+  geometry.userData.visualOnly = true
+  const mesh = new THREE.Mesh(geometry, material)
+  mesh.name = name
+  mesh.castShadow = true
+  mesh.receiveShadow = true
+  markVisualOnly(mesh)
+  frame.add(mesh)
+  return mesh
+}
+
+function addPairCrystal(frame: THREE.Group, name: string, color: string, bronze: THREE.Material): THREE.Group {
+  const crown = new THREE.Group()
+  crown.name = `${name}-jungle-pair-crystal`
+  crown.position.set(0, 1.78, 0.68)
+  crown.userData.portalPairColor = color
+  crown.userData.portalLightRole = 'pair-color-temple-crystal'
+  markVisualOnly(crown)
+
+  const pairColor = new THREE.Color(color)
+  const crystalMaterial = new THREE.MeshPhysicalMaterial({
+    color: pairColor.clone().lerp(new THREE.Color('#ffffff'), 0.16),
+    emissive: pairColor,
+    emissiveIntensity: 2.1,
+    roughness: 0.14,
+    metalness: 0,
+    // A tiny decorative gem must not trigger a full-scene refraction pass.
+    transmission: 0,
+    thickness: 0.22,
+    transparent: true,
+    opacity: 0.94,
+    toneMapped: false,
+  })
+  const crystal = new THREE.Mesh(new THREE.OctahedronGeometry(0.25, 0), crystalMaterial)
+  crystal.name = `${name}-jungle-pair-crystal-gem`
+  crystal.scale.set(0.76, 1.25, 0.7)
+  crystal.rotation.y = Math.PI / 4
+  crystal.castShadow = false
+  crystal.userData.ownsMaterial = true
+  crystal.userData.portalPairColor = color
+  markVisualOnly(crystal)
+  crown.add(crystal)
+
+  const haloMaterial = new THREE.MeshBasicMaterial({
+    color,
+    transparent: true,
+    opacity: 0.2,
+    blending: THREE.AdditiveBlending,
+    depthWrite: false,
+    toneMapped: false,
+  })
+  const halo = new THREE.Mesh(new THREE.OctahedronGeometry(0.31, 1), haloMaterial)
+  halo.name = `${name}-jungle-pair-crystal-halo`
+  halo.scale.set(0.76, 1.25, 0.7)
+  halo.rotation.y = Math.PI / 4
+  halo.userData.ownsMaterial = true
+  halo.userData.portalPairColor = color
+  markVisualOnly(halo)
+  crown.add(halo)
+
+  const holderParts = [
+    roundedStone(new THREE.Vector3(0.56, 0.12, 0.34), new THREE.Vector3(0, -0.3, -0.03), 0.035),
+    roundedStone(new THREE.Vector3(0.12, 0.38, 0.28), new THREE.Vector3(-0.3, -0.12, -0.03), 0.025),
+    roundedStone(new THREE.Vector3(0.12, 0.38, 0.28), new THREE.Vector3(0.3, -0.12, -0.03), 0.025),
+  ]
+  mergeBatch(crown, `${name}-jungle-crystal-bronze-setting`, bronze, holderParts)
+
+  const light = new THREE.PointLight(color, 0.82, 3.2, 2)
+  light.name = `${name}-jungle-pair-crystal-light`
+  light.position.set(0, -0.04, 0.18)
+  light.userData.portalPairColor = color
+  light.userData.portalLightRole = 'pair-color-temple-crystal'
+  markVisualOnly(light)
+  crown.add(light)
+  frame.add(crown)
+  return crown
+}
+
+function addOuterPlants(frame: THREE.Group, name: string, foliage: THREE.Material): void {
+  const leafGeometry = metricPlanarUvs(new VisualConeGeometry(0.12, 0.48, 5, 1))
+  leafGeometry.translate(0, 0.24, 0)
+  leafGeometry.name = `${name}-jungle-outer-leaf-geometry`
+  const placements = [
+    [-2.58, -1.46, 0.48, -0.72, 1.16],
+    [-2.43, -1.42, 0.57, -0.32, 1.34],
+    [-2.28, -1.5, 0.51, 0.2, 1.04],
+    [-2.69, -1.51, 0.36, -1.02, 0.92],
+    [2.58, -1.47, 0.48, 0.64, 1.2],
+    [2.42, -1.43, 0.58, 0.22, 1.36],
+    [2.27, -1.51, 0.5, -0.28, 1.02],
+    [2.68, -1.5, 0.36, 0.96, 0.9],
+    [-2.42, 1.08, 0.5, -0.9, 0.84],
+    [-2.2, 1.34, 0.52, -0.34, 0.72],
+    [-2.22, 1.84, 0.48, -0.84, 0.68],
+    [2.42, 1.06, 0.5, 0.78, 0.82],
+    [2.18, 1.34, 0.52, 0.3, 0.72],
+    [2.22, 1.84, 0.48, 0.82, 0.68],
+  ] as const
+  const leaves = new THREE.InstancedMesh(leafGeometry, foliage, placements.length)
+  leaves.name = `${name}-jungle-outer-plants`
+  leaves.castShadow = true
+  leaves.receiveShadow = true
+  const matrix = new THREE.Matrix4()
+  const quaternion = new THREE.Quaternion()
+  const scale = new THREE.Vector3()
+  placements.forEach(([x, y, z, angle, size], index) => {
+    quaternion.setFromAxisAngle(new THREE.Vector3(0, 0, 1), angle)
+    scale.set(size, size, size * 0.72)
+    matrix.compose(new THREE.Vector3(x, y, z), quaternion, scale)
+    leaves.setMatrixAt(index, matrix)
+  })
+  leaves.instanceMatrix.needsUpdate = true
+  leaves.computeBoundingBox()
+  leaves.computeBoundingSphere()
+  leaves.userData.plantPlacement = 'outer-frame-only'
+  markVisualOnly(leaves)
+  frame.add(leaves)
+
+  const vineCurves = [
+    [
+      new THREE.Vector3(-2.28, 1.65, FRONT_Z + 0.08),
+      new THREE.Vector3(-2.47, 1.04, FRONT_Z + 0.12),
+      new THREE.Vector3(-2.36, 0.38, FRONT_Z + 0.14),
+      new THREE.Vector3(-2.5, -0.28, FRONT_Z + 0.1),
+    ],
+    [
+      new THREE.Vector3(2.32, 1.58, FRONT_Z + 0.07),
+      new THREE.Vector3(2.48, 1.08, FRONT_Z + 0.12),
+      new THREE.Vector3(2.36, 0.56, FRONT_Z + 0.13),
+    ],
+    [
+      new THREE.Vector3(-1.62, 1.92, FRONT_Z + 0.04),
+      new THREE.Vector3(-0.82, 1.78, FRONT_Z + 0.1),
+      new THREE.Vector3(0.12, 1.9, FRONT_Z + 0.08),
+      new THREE.Vector3(1.02, 1.74, FRONT_Z + 0.12),
+      new THREE.Vector3(1.72, 1.9, FRONT_Z + 0.05),
+    ],
+  ]
+  const vines = vineCurves.map(points =>
+    metricPlanarUvs(new VisualTubeGeometry(new THREE.CatmullRomCurve3(points), 18, 0.04, 6, false)),
+  )
+  mergeBatch(frame, `${name}-jungle-outer-vines`, foliage, vines)
+}
+
+/**
+ * Adds only the Jungle portal's theme-local architectural frame and light source.
+ * The black aperture, live camera, animated rift, glow, and particles stay owned by
+ * the shared portal visual. This function creates no physics bodies or colliders.
+ */
+export function addJunglePortalFrame(options: JunglePortalFrameOptions): THREE.Group {
+  const { root, name, color, materials } = options
+  const frame = new THREE.Group()
+  frame.name = `${name}-jungle-temple-frame`
+  frame.userData.portalPairColor = color
+  frame.scale.x = PORTAL_THEME_FRAME_X_SCALE
+  frame.userData.portalApertureClearHalfWidth = PORTAL_APERTURE_HALF_WIDTH
+  frame.userData.drawCallBudget = 7
+  frame.userData.triangleBudget = 5_500
+  frame.userData.materialReuse = {
+    stone: 'jungle.temple-stone',
+    bronze: 'jungle.temple-bronze',
+    plants: 'world.foliage',
+  }
+  markVisualOnly(frame)
+
+  const stoneParts: THREE.BufferGeometry[] = []
+  // Deliberately chunky, slightly offset courses read as an old temple without
+  // spending a draw call per block. They sit outside the shared clear aperture.
+  for (const side of [-1, 1] as const) {
+    const x = side * 2.16
+    stoneParts.push(
+      roundedStone(new THREE.Vector3(0.76, 0.54, 0.82), new THREE.Vector3(x + side * 0.03, -1.33, 0), 0.095),
+      roundedStone(new THREE.Vector3(0.68, 0.52, 0.86), new THREE.Vector3(x - side * 0.035, -0.82, 0.02), 0.09),
+      roundedStone(new THREE.Vector3(0.75, 0.5, 0.84), new THREE.Vector3(x + side * 0.025, -0.32, 0), 0.09),
+      roundedStone(new THREE.Vector3(0.69, 0.5, 0.88), new THREE.Vector3(x - side * 0.03, 0.18, 0.025), 0.09),
+      roundedStone(new THREE.Vector3(0.76, 0.5, 0.84), new THREE.Vector3(x + side * 0.025, 0.68, 0), 0.095),
+      roundedStone(new THREE.Vector3(0.72, 0.42, 0.86), new THREE.Vector3(x, 1.13, 0.015), 0.085),
+      roundedStone(new THREE.Vector3(1.02, 0.34, 1.0), new THREE.Vector3(side * 2.2, -1.66, -0.02), 0.08),
+      roundedStone(new THREE.Vector3(0.86, 0.28, 0.94), new THREE.Vector3(side * 2.16, 1.38, 0), 0.07),
+      roundedStone(new THREE.Vector3(0.68, 2.36, 0.18), new THREE.Vector3(side * 2.165, -0.08, 0.46), 0.055),
+    )
+  }
+  stoneParts.push(
+    roundedStone(new THREE.Vector3(1.18, 0.54, 0.88), new THREE.Vector3(-1.72, 1.65, 0), 0.1),
+    roundedStone(new THREE.Vector3(1.08, 0.57, 0.9), new THREE.Vector3(-0.62, 1.63, 0.02), 0.1),
+    roundedStone(new THREE.Vector3(1.08, 0.57, 0.9), new THREE.Vector3(0.62, 1.64, 0), 0.1),
+    roundedStone(new THREE.Vector3(1.18, 0.54, 0.88), new THREE.Vector3(1.72, 1.65, 0.015), 0.1),
+    roundedStone(new THREE.Vector3(0.76, 0.7, 0.96), new THREE.Vector3(0, 1.65, 0.03), 0.1),
+    roundedStone(new THREE.Vector3(5.08, 0.16, 0.98), new THREE.Vector3(0, 1.96, -0.02), 0.045),
+  )
+  mergeBatch(frame, `${name}-jungle-temple-stone`, materials.stone, stoneParts)
+
+  const bronzeParts: THREE.BufferGeometry[] = []
+  for (const side of [-1, 1] as const) {
+    for (const y of [-0.72, 0.63]) {
+      bronzeParts.push(
+        roundedStone(new THREE.Vector3(0.82, 0.15, 0.94), new THREE.Vector3(side * 2.16, y, 0.05), 0.04),
+      )
+    }
+  }
+  for (const x of [-1.48, 1.48]) {
+    bronzeParts.push(roundedStone(new THREE.Vector3(0.16, 0.72, 0.98), new THREE.Vector3(x, 1.64, 0.045), 0.04))
+  }
+  mergeBatch(frame, `${name}-jungle-temple-bronze`, materials.bronze, bronzeParts)
+
+  addPairCrystal(frame, name, color, materials.bronze)
+  addOuterPlants(frame, name, materials.foliage)
+
+  // Reassert invariant tags on every descendant, including meshes created by helpers.
+  frame.traverse(object => markVisualOnly(object))
+  root.add(frame)
+  return frame
+}

package/src/pages/play/race/jungle-temple-lift.ts

@@ -0,0 +1,366 @@
+import * as THREE from 'three'
+
+import { VisualTorusGeometry, VisualTubeGeometry, VisualBoxGeometry } from '../../../three/visual-geometry'
+import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js'
+
+export const JUNGLE_TEMPLE_THEME_ID = 'low-poly-jungle'
+
+const STONE_UV_SPAN = new THREE.Vector2(4.8, 4.8)
+const TIMBER_UV_SPAN = new THREE.Vector2(3.6, 3.6)
+const BRONZE_UV_SPAN = new THREE.Vector2(3.2, 3.2)
+
+export interface JungleTempleLiftMaterials {
+  stone: THREE.Material
+  facade: THREE.Material
+  timber: THREE.Material
+  platform: THREE.Material
+  moss: THREE.Material
+  accent: THREE.Material
+}
+
+interface JungleTempleLiftOptions {
+  id: string
+  bottom: THREE.Vector3
+  rotation: THREE.Quaternion
+  width: number
+  height: number
+  depth: number
+  releaseHeight: number
+  materials: JungleTempleLiftMaterials
+}
+
+interface GeometryBatch {
+  readonly name: string
+  readonly material: THREE.Material
+  readonly parts: THREE.BufferGeometry[]
+}
+
+function authoredUvGeometry(geometry: THREE.BufferGeometry, span: THREE.Vector2): THREE.BufferGeometry {
+  const prepared = geometry.index ? geometry.toNonIndexed() : geometry
+  if (prepared !== geometry) geometry.dispose()
+  const uv = prepared.getAttribute('uv')
+  if (uv) {
+    for (let index = 0; index < uv.count; index += 1) {
+      uv.setXY(index, uv.getX(index) * span.x, uv.getY(index) * span.y)
+    }
+    uv.needsUpdate = true
+  }
+  const position = prepared.getAttribute('position')
+  const metricUvs = new Float32Array(position.count * 4)
+  for (let index = 0; index < position.count; index += 1) metricUvs[index * 4 + 2] = 1
+  prepared.setAttribute('themeNetUv', new THREE.BufferAttribute(metricUvs, 4))
+  return prepared
+}
+
+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 normalX = Math.abs(normal.getX(index))
+    const normalY = Math.abs(normal.getY(index))
+    const normalZ = Math.abs(normal.getZ(index))
+    if (normalX >= normalY && normalX >= normalZ) {
+      uvs[index * 2] = z
+      uvs[index * 2 + 1] = y
+    } else if (normalY >= normalZ) {
+      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
+}
+
+function transformedGeometry(
+  geometry: THREE.BufferGeometry,
+  position: THREE.Vector3,
+  rotation = new THREE.Quaternion(),
+): THREE.BufferGeometry {
+  geometry.applyMatrix4(new THREE.Matrix4().compose(position, rotation, new THREE.Vector3(1, 1, 1)))
+  return geometry
+}
+
+function roundedBox(size: THREE.Vector3, radius: number, position: THREE.Vector3): THREE.BufferGeometry {
+  return transformedGeometry(
+    metricPlanarUvGeometry(new VisualBoxGeometry(size.x, size.y, size.z, 2, radius)),
+    position,
+  )
+}
+
+function addMergedBatch(group: THREE.Group, id: string, batch: GeometryBatch): THREE.Mesh | undefined {
+  if (batch.parts.length === 0) return undefined
+  const geometry = mergeGeometries(batch.parts, false)
+  batch.parts.forEach(part => part.dispose())
+  if (!geometry) throw new Error(`Unable to merge Jungle temple lift batch "${batch.name}".`)
+  geometry.name = `${id}-${batch.name}-geometry`
+  geometry.computeBoundingBox()
+  geometry.computeBoundingSphere()
+  geometry.userData.visualOnly = true
+  const mesh = new THREE.Mesh(geometry, batch.material)
+  mesh.name = `${id}-${batch.name}`
+  mesh.castShadow = true
+  mesh.receiveShadow = true
+  mesh.userData.decorative = true
+  mesh.userData.visualOnly = true
+  group.add(mesh)
+  return mesh
+}
+
+function facadeUvGeometry(
+  geometry: THREE.BufferGeometry,
+  side: -1 | 1,
+  wallDepth: number,
+  wallBottom: number,
+  wallHeight: number,
+): THREE.BufferGeometry {
+  const prepared = geometry.index ? geometry.toNonIndexed() : geometry
+  if (prepared !== geometry) geometry.dispose()
+  const position = prepared.getAttribute('position')
+  const uvs = new Float32Array(position.count * 2)
+  const metricUvs = new Float32Array(position.count * 4)
+  for (let index = 0; index < position.count; index += 1) {
+    const depthUv = THREE.MathUtils.clamp((position.getZ(index) + wallDepth / 2) / wallDepth, 0, 1)
+    uvs[index * 2] = side > 0 ? 1 - depthUv : depthUv
+    uvs[index * 2 + 1] = THREE.MathUtils.clamp((position.getY(index) - wallBottom) / wallHeight, 0, 1)
+    metricUvs[index * 4 + 2] = 1
+  }
+  prepared.setAttribute('uv', new THREE.BufferAttribute(uvs, 2))
+  prepared.setAttribute('themeNetUv', new THREE.BufferAttribute(metricUvs, 4))
+  return prepared
+}
+
+export function addJungleTempleLiftSkin(root: THREE.Group, options: JungleTempleLiftOptions): THREE.Group {
+  const { id, bottom, rotation, width, height, depth, releaseHeight, materials } = options
+  const group = new THREE.Group()
+  group.name = `${id}-jungle-temple-lift`
+  group.position.copy(bottom)
+  group.quaternion.copy(rotation)
+  group.userData.themeOnly = JUNGLE_TEMPLE_THEME_ID
+  group.userData.decorative = true
+  group.userData.visualOnly = true
+  group.userData.drawCallBudget = 5
+  group.userData.triangleBudget = 12_000
+
+  const stone: THREE.BufferGeometry[] = []
+  const facade: THREE.BufferGeometry[] = []
+  const timber: THREE.BufferGeometry[] = []
+  const bronze: THREE.BufferGeometry[] = []
+  const moss: THREE.BufferGeometry[] = []
+  const sideX = width / 2 + 0.18
+  const frontZ = depth / 2 + 0.2
+  const backZ = -depth / 2 - 0.2
+  const shellHeight = height + 1.02
+  const shellBottom = -0.35
+  const shellDepth = depth + 0.62
+  const shellCoreThickness = 0.34
+  const facadeBaseDepth = 0.04
+  const facadeFrameDepth = 0.15
+  const facadeBlockInset = 0.018
+  const facadeFrameRegions = [
+    [0.005, 0.205, 0.06, 0.94],
+    [0.795, 0.995, 0.06, 0.94],
+    [0.005, 0.995, 0.94, 0.995],
+    [0.005, 0.995, 0.005, 0.06],
+  ] as const
+
+  for (const side of [-1, 1] as const) {
+    // The full authored facade supplies the approved serpent composition. Only its
+    // matching outer frame is raised into geometry. Internal stone seams and the
+    // serpent carving stay in the aligned normal response rather than becoming
+    // guessed geometry that can drift away from the source.
+    stone.push(
+      roundedBox(
+        new THREE.Vector3(shellCoreThickness, shellHeight, shellDepth),
+        0.055,
+        new THREE.Vector3(side * sideX, shellBottom + shellHeight / 2, 0),
+      ),
+    )
+    const facadeCenterX = side * (sideX + shellCoreThickness / 2 + facadeBaseDepth / 2 - 0.008)
+    facade.push(
+      facadeUvGeometry(
+        transformedGeometry(
+          new THREE.BoxGeometry(facadeBaseDepth, shellHeight, shellDepth),
+          new THREE.Vector3(facadeCenterX, shellBottom + shellHeight / 2, 0),
+        ),
+        side,
+        shellDepth,
+        shellBottom,
+        shellHeight,
+      ),
+    )
+    for (const [u0, u1, v0, v1] of facadeFrameRegions) {
+      const blockDepth = (u1 - u0) * shellDepth - facadeBlockInset
+      const blockHeight = (v1 - v0) * shellHeight - facadeBlockInset
+      const blockCenterU = (u0 + u1) / 2
+      const blockCenterV = (v0 + v1) / 2
+      const blockCenterZ =
+        side > 0 ? shellDepth / 2 - blockCenterU * shellDepth : -shellDepth / 2 + blockCenterU * shellDepth
+      const blockRelief = facadeFrameDepth
+      const blockCenterX = side * (sideX + shellCoreThickness / 2 + facadeBaseDepth + blockRelief / 2 - 0.014)
+      facade.push(
+        facadeUvGeometry(
+          transformedGeometry(
+            new THREE.BoxGeometry(blockRelief, blockHeight, blockDepth),
+            new THREE.Vector3(blockCenterX, shellBottom + blockCenterV * shellHeight, blockCenterZ),
+          ),
+          side,
+          shellDepth,
+          shellBottom,
+          shellHeight,
+        ),
+      )
+    }
+    moss.push(
+      roundedBox(
+        new THREE.Vector3(0.12, 0.09, depth * 0.72),
+        0.035,
+        new THREE.Vector3(side * (sideX + 0.34), height + 0.66, -depth * 0.04),
+      ),
+    )
+  }
+  group.userData.sideWallRelief = 'source-aligned-outer-frame'
+  group.userData.sideWallReliefBlockCount = facadeFrameRegions.length * 2
+
+  const rearPanelZ = -depth / 2 - 0.07
+  const exitOpeningBottom = THREE.MathUtils.clamp(releaseHeight - 0.34, 0.9, height - 1.5)
+  const exitOpeningTop = Math.min(height + 0.42, releaseHeight + 1.48)
+  const rearPanelBottom = -0.12
+  const rearPanelTop = height + 0.68
+  const lowerPanelHeight = exitOpeningBottom - rearPanelBottom
+  const upperPanelHeight = Math.max(0.24, rearPanelTop - exitOpeningTop)
+  group.userData.hasBackWall = true
+  group.userData.releaseOpeningBottom = exitOpeningBottom
+  group.userData.releaseOpeningTop = exitOpeningTop
+  stone.push(
+    roundedBox(
+      new THREE.Vector3(width - 0.38, lowerPanelHeight, 0.28),
+      0.07,
+      new THREE.Vector3(0, (rearPanelBottom + exitOpeningBottom) / 2, rearPanelZ),
+    ),
+    roundedBox(
+      new THREE.Vector3(width - 0.38, upperPanelHeight, 0.28),
+      0.07,
+      new THREE.Vector3(0, (exitOpeningTop + rearPanelTop) / 2, rearPanelZ),
+    ),
+  )
+  for (const y of [exitOpeningBottom - 0.08, exitOpeningTop + 0.08]) {
+    stone.push(
+      roundedBox(new THREE.Vector3(width - 0.14, 0.26, 0.38), 0.06, new THREE.Vector3(0, y, rearPanelZ - 0.025)),
+    )
+  }
+  for (const z of [frontZ, backZ]) {
+    stone.push(roundedBox(new THREE.Vector3(width + 0.8, 0.58, 0.52), 0.09, new THREE.Vector3(0, height + 0.3, z)))
+  }
+
+  const postX = width / 2 - 0.57
+  for (const x of [-postX, postX]) {
+    timber.push(
+      roundedBox(new THREE.Vector3(0.42, height + 0.36, 0.4), 0.07, new THREE.Vector3(x, height / 2, frontZ + 0.035)),
+    )
+    for (const y of [height * 0.2, height * 0.5, height * 0.8]) {
+      timber.push(
+        transformedGeometry(
+          authoredUvGeometry(new VisualTorusGeometry(0.27, 0.045, 6, 16), TIMBER_UV_SPAN),
+          new THREE.Vector3(x, y, frontZ + 0.035),
+          new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(1, 0, 0), Math.PI / 2),
+        ),
+      )
+    }
+  }
+
+  const drumPosition = new THREE.Vector3(0, height + 0.55, depth / 2 + 0.2)
+  for (const x of [-width * 0.31, 0, width * 0.31]) {
+    bronze.push(
+      transformedGeometry(
+        authoredUvGeometry(new VisualTorusGeometry(0.59, 0.05, 7, 20), BRONZE_UV_SPAN),
+        drumPosition.clone().add(new THREE.Vector3(x, 0, 0)),
+        new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), Math.PI / 2),
+      ),
+    )
+  }
+
+  const vinePoints = [
+    new THREE.Vector3(-width * 0.42, height + 0.54, backZ),
+    new THREE.Vector3(-width * 0.12, height + 0.78, 0),
+    new THREE.Vector3(width * 0.18, height + 0.55, frontZ),
+    new THREE.Vector3(width * 0.42, height - 0.62, frontZ + 0.04),
+  ]
+  moss.push(
+    authoredUvGeometry(
+      new VisualTubeGeometry(new THREE.CatmullRomCurve3(vinePoints), 22, 0.055, 6, false),
+      STONE_UV_SPAN,
+    ),
+  )
+
+  addMergedBatch(group, id, { name: 'temple-stone-shell', material: materials.stone, parts: stone })
+  addMergedBatch(group, id, { name: 'temple-serpent-facade', material: materials.facade, parts: facade })
+  addMergedBatch(group, id, { name: 'temple-timber-frame', material: materials.timber, parts: timber })
+  addMergedBatch(group, id, { name: 'temple-bronze-details', material: materials.accent, parts: bronze })
+  addMergedBatch(group, id, { name: 'temple-moss-details', material: materials.moss, parts: moss })
+
+  root.add(group)
+  return group
+}
+
+export function decorateJungleTempleShelf(
+  shelf: THREE.Mesh,
+  id: string,
+  width: number,
+  depth: number,
+  materials: JungleTempleLiftMaterials,
+): void {
+  const decoration = new THREE.Group()
+  decoration.name = `${id}-jungle-temple-platform`
+  decoration.userData.themeOnly = JUNGLE_TEMPLE_THEME_ID
+  decoration.userData.decorative = true
+  decoration.userData.visualOnly = true
+  decoration.userData.drawCallBudget = 3
+
+  const platformGeometry = roundedBox(
+    new THREE.Vector3(width - 0.08, 0.07, depth - 0.1),
+    0.035,
+    new THREE.Vector3(0, 0.125, 0),
+  )
+  const platform = new THREE.Mesh(platformGeometry, materials.platform)
+  platform.name = `${id}-temple-bamboo-deck`
+  platform.castShadow = true
+  platform.receiveShadow = true
+  platform.userData.decorative = true
+  platform.userData.visualOnly = true
+  decoration.add(platform)
+
+  const lipGeometry = roundedBox(
+    new THREE.Vector3(width, 0.22, 0.12),
+    0.035,
+    new THREE.Vector3(0, 0.19, depth / 2 + 0.015),
+  )
+  const lip = new THREE.Mesh(lipGeometry, materials.timber)
+  lip.name = `${id}-temple-platform-lip`
+  lip.castShadow = true
+  lip.receiveShadow = true
+  lip.userData.decorative = true
+  lip.userData.visualOnly = true
+  decoration.add(lip)
+
+  const amberParts = [-width * 0.3, 0, width * 0.3].map(x =>
+    roundedBox(new THREE.Vector3(0.36, 0.1, 0.035), 0.015, new THREE.Vector3(x, 0.22, depth / 2 + 0.085)),
+  )
+  addMergedBatch(decoration, id, {
+    name: 'temple-platform-amber-inlays',
+    material: materials.accent,
+    parts: amberParts,
+  })
+  shelf.add(decoration)
+}