Spaces:
Paused
Paused
File size: 7,118 Bytes
2b0432b 3a11707 2b0432b 3a11707 2b0432b 4b7c857 2b0432b 3a11707 2b0432b c0d0800 2b0432b 3a11707 2b0432b | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 | // Camera language: every shot is a pure function of time. Each shot has a
// landscape (16:9) and a portrait (9:16) framing.
import * as THREE from 'three'
import { BRIDGE_S, GROUND_Y, PAVILION_POS, quayPoint, riverAt, riverPoint, riverSAtX, TERRACE, terrainHeight, TREE_POS, WHEEL_S, riverHalfWidth } from './layout'
import { clamp, easeInOut, easeSine, lerp, valueNoise2 } from './rng'
import { SHOTS, shotAt } from './timeline'
export interface CamPose { pos: THREE.Vector3; target: THREE.Vector3; fov: number; roll?: number; near?: number }
const V = (x: number, y: number, z: number) => new THREE.Vector3(x, y, z)
const mix = (a: THREE.Vector3, b: THREE.Vector3, f: number) => a.clone().lerp(b, f)
/** Horizontal field of view equivalence for portrait framing. */
function portraitFov(vfovLand: number, aspect: number, widen = 0.62) {
const hl = 2 * Math.atan(Math.tan(((vfovLand * Math.PI) / 180) / 2) * (16 / 9))
const hp = hl * widen
return (2 * Math.atan(Math.tan(hp / 2) / aspect) * 180) / Math.PI
}
type ShotFn = (u: number, t: number, portrait: boolean) => CamPose
const bridge = riverPoint(BRIDGE_S, 0)
const wheelP = riverPoint(WHEEL_S, riverHalfWidth(WHEEL_S) - 3)
const shots: Record<number, ShotFn> = {
// 1 · aerial establishing shot, slowly descending toward the village, sun ahead
1: (u, _t, p) => {
const e = easeSine(u)
const pos = mix(V(470, 132, 150), V(310, 70, 82), e)
const target = mix(V(-1100, 60, 160), V(-1000, 30, 130), e)
if (p) { pos.add(V(-40, 30, -10)); target.y -= 10 }
return { pos, target, fov: 38 }
},
// 2 · gliding low over the water toward the bridge
2: (u, _t, p) => {
const e = lerp(u, easeSine(u), 0.4)
const s = lerp(BRIDGE_S + 150, BRIDGE_S + 62, e)
const r = riverPoint(s, 1.2)
const ahead = riverPoint(s - 34, 0)
const pos = V(r.x, 2.0 + Math.sin(u * 3) * 0.15, r.z)
const target = V(ahead.x, 2.3, ahead.z)
if (p) { pos.y += 0.6; target.y += 1.2 }
return { pos, target, fov: 46, roll: Math.sin(u * 2.2) * 0.012 }
},
// 3 · stone arch bridge: low lateral slide, arch + reflection form a full circle
3: (u, _t, p) => {
const e = easeInOut(u)
const along = V(bridge.tx, 0, bridge.tz)
const across = V(bridge.nx, 0, bridge.nz)
const c = V(bridge.x, 0, bridge.z)
const dist = lerp(40, 33, e)
const pos = c.clone().addScaledVector(along, dist).addScaledVector(across, lerp(-3.2, 2.6, e))
pos.y = 1.05
const target = c.clone().addScaledVector(across, lerp(-1, 0.6, e))
target.y = 3.1
if (p) { pos.addScaledVector(along, 6); target.y = 3.6 }
return { pos, target, fov: 34 }
},
// 4 · water wheel close-up, slow push-in from the opposite bank
4: (u, _t, p) => {
const e = easeSine(u)
const c = V(wheelP.x, 2.2, wheelP.z)
const across = V(wheelP.nx, 0, wheelP.nz)
const along = V(wheelP.tx, 0, wheelP.tz)
const pos = c.clone().addScaledVector(across, lerp(-15.5, -12.2, e)).addScaledVector(along, lerp(7, 3.2, e))
pos.y = lerp(2.9, 2.4, e)
const target = c.clone().addScaledVector(along, lerp(-1.5, -0.8, e))
if (p) { pos.addScaledVector(across, -2.5); target.y += 0.6 }
return { pos, target, fov: 40 }
},
// 5 · market street: walking backwards ahead of the ox cart, sun behind it
5: (u, t, p) => {
const sOx = riverSAtX(-175) + (t - 28) * 0.95
const camS = sOx + lerp(15, 12.5, u)
const q = quayPoint(camS, -1.1)
const pos = V(q.x, GROUND_Y + 1.75, q.z)
const look = quayPoint(sOx - 6, 1.0)
const target = V(look.x, GROUND_Y + 1.6, look.z)
if (p) { pos.y += 0.35; target.y += 0.9 }
// the camera tracks along a busy quay at eye height: a wider near plane clips anything
// (stall awning, passer-by, hanging goods) that would otherwise fill the frame for a moment
return { pos, target, fov: 44, near: 1.6 }
},
// 6 · the ancient camphor tree at the village entrance, backlit by the low sun
6: (u, _t, p) => {
const e = easeSine(u)
const tp = V(TREE_POS.x, GROUND_Y, TREE_POS.z)
const pos = tp.clone().add(mix(V(25, 1.8, 16.5), V(19, 2.7, 12.5), e))
const target = tp.clone().add(V(-2, mix(V(0, 8, 0), V(0, 10, 0), e).y, -4))
if (p) { pos.add(V(6, 0.5, 5)); target.y += 3 }
return { pos, target, fov: 46 }
},
// 7 · telephoto pan across the terraces and bamboo hills to the pavilion
7: (u, _t, p) => {
const e = easeInOut(u)
const pos = V(lerp(110, 98, e), lerp(26, 30, e), lerp(-120, -126, e))
const terr = V(TERRACE.cx - 30, terrainHeight(TERRACE.cx - 30, TERRACE.cz + 60) + 6, TERRACE.cz + 60)
const pav = V(PAVILION_POS.x, terrainHeight(PAVILION_POS.x, PAVILION_POS.z) + 4, PAVILION_POS.z)
const target = mix(terr, pav, e)
if (p) { target.y += 6 }
return { pos, target, fov: 21 }
},
// 8 · blue hour on the market street: lanterns light up one after another
8: (u, t, p) => {
const s = riverSAtX(-150) + (t - 55) * 2.1
const q = quayPoint(s, -0.8)
const pos = V(q.x, GROUND_Y + 2.6, q.z)
const look = quayPoint(s + 26, -1.6)
const target = V(look.x, GROUND_Y + 2.4, look.z)
if (p) { pos.y += 0.2; target.y += 0.8 }
return { pos, target, fov: 48, roll: Math.sin(u * 3) * 0.006, near: 1.2 }
},
// 9 · night river: lantern reflections, the lit boat glides toward the bridge
9: (u, _t, p) => {
const e = easeSine(u)
const s = BRIDGE_S + lerp(52, 45, e)
const r = riverPoint(s, -4.6)
const pos = V(r.x, 1.25, r.z)
const target = V(bridge.x, 3.4, bridge.z).add(V(bridge.nx, 0, bridge.nz).multiplyScalar(1.5))
if (p) { pos.y += 0.5; target.y += 0.8 }
return { pos, target, fov: 42 }
},
// 10 · crane up and pull back over the glowing village under the first stars
10: (u, _t, p) => {
const e = easeInOut(clamp(u * 1.05))
const pos = mix(V(95, 9, 34), V(205, 88, 160), e)
const target = mix(V(-10, 3, -4), V(-330, 26, -150), e)
if (p) { pos.add(V(20, 25, 20)); target.y -= 8 }
return { pos, target, fov: lerp(44, 40, e) }
},
}
/** Camera pose at absolute time t. */
export function cameraAt(t: number, aspect: number): CamPose {
const s = shotAt(t)
const u = clamp((t - s.t0) / (s.t1 - s.t0))
const portrait = aspect < 1
const pose = shots[s.id](u, t, portrait)
// subtle handheld / crane drift so nothing feels perfectly static
const n = (k: number) => (valueNoise2(t * 0.35, k * 10.3, 5) - 0.5)
const shake = s.id === 7 ? 0.25 : s.id === 1 || s.id === 10 ? 0.4 : 0.05
pose.target.add(V(n(1), n(2), n(3)).multiplyScalar(shake))
if (portrait) pose.fov = portraitFov(pose.fov, aspect)
else if (aspect < 1.7) pose.fov = (2 * Math.atan(Math.tan((pose.fov * Math.PI) / 360) * (16 / 9) / aspect) * 180) / Math.PI * 0.86 + pose.fov * 0.14
return pose
}
export function applyPose(cam: THREE.PerspectiveCamera, pose: CamPose) {
cam.position.copy(pose.pos)
cam.up.set(0, 1, 0)
cam.lookAt(pose.target)
if (pose.roll) cam.rotateZ(pose.roll)
cam.fov = pose.fov
cam.near = pose.near ?? 0.4
cam.updateProjectionMatrix()
cam.updateMatrixWorld()
}
export { SHOTS, riverAt }
|