// A tiny 3D "film camera" for the highway: perspective projection with yaw, // near-plane clipping, a road with lamps, and car sprites chosen by viewing // angle (rear / front / side). Lets us shoot the duels like a director: // POV through the windscreen, chase cams, a camera that spins with the car. import { carRear, carSide, heroCarFront, rivalCarFront, roadsterFront, roadsterRear, roadsterSide, truckRear, truckSide, type CarKind } from './cars' import { PULSE, glowBlob } from './draw' import type { SceneCtx } from './types' import { PALETTE, clamp, hash } from './util' type C2D = CanvasRenderingContext2D export interface Cam { x: number y: number z: number yaw: number f: number hy: number roll: number /** true downward tilt in radians (for aerial / drone shots) */ tilt: number } export function makeCam(s: SceneCtx, x: number, y: number, z: number, yaw: number, pitch = 0, fov = 1, roll = 0, tilt = 0): Cam { const f = s.W * 0.62 * fov return { x, y, z, yaw, f, hy: s.H * 0.5 + pitch * f, roll, tilt } } interface P3 { x: number y: number z: number } function toCam(c: Cam, X: number, Y: number, Z: number): P3 { const dx = X - c.x const dz = Z - c.z const cs = Math.cos(c.yaw) const sn = Math.sin(c.yaw) const xr = dx * cs - dz * sn const zr = dx * sn + dz * cs const yr = Y - c.y if (!c.tilt) return { x: xr, y: yr, z: zr } const ct = Math.cos(c.tilt) const st = Math.sin(c.tilt) return { x: xr, y: yr * ct + zr * st, z: -yr * st + zr * ct } } export function proj(c: Cam, s: SceneCtx, X: number, Y: number, Z: number) { const p = toCam(c, X, Y, Z) if (p.z < 0.3) return null const k = c.f / p.z return { x: s.W / 2 + p.x * k, y: c.hy - p.y * k, z: p.z, k } } const NEAR = 0.35 /** fill a world-space polygon with near-plane clipping */ export function poly3(ctx: C2D, c: Cam, s: SceneCtx, pts: [number, number, number][], fill: string) { const cam = pts.map(([X, Y, Z]) => toCam(c, X, Y, Z)) const out: P3[] = [] for (let i = 0; i < cam.length; i++) { const a = cam[i] const b = cam[(i + 1) % cam.length] const ain = a.z >= NEAR const bin = b.z >= NEAR if (ain) out.push(a) if (ain !== bin) { const t = (NEAR - a.z) / (b.z - a.z) out.push({ x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t, z: NEAR }) } } if (out.length < 3) return ctx.fillStyle = fill ctx.beginPath() out.forEach((p, i) => { const k = c.f / p.z const x = s.W / 2 + p.x * k const y = c.hy - p.y * k if (i) ctx.lineTo(x, y) else ctx.moveTo(x, y) }) ctx.closePath() ctx.fill() } // ------------------------------------------------------------------ the world export interface WorldOpts { /** colour of the sky near the horizon */ glow?: string /** police lights far away */ police?: boolean } export function drawHighway(s: SceneCtx, c: Cam, o: WorldOpts = {}) { const { ctx, W, H, t } = s ctx.save() if (c.roll) { ctx.translate(W / 2, H / 2) ctx.rotate(c.roll) ctx.translate(-W / 2, -H / 2) } const hy = c.hy - Math.tan(c.tilt || 0) * c.f // sky const g = ctx.createLinearGradient(0, hy - H * 0.6, 0, hy) g.addColorStop(0, '#04050c') g.addColorStop(0.7, '#141a36') g.addColorStop(1, o.glow ?? '#3a1530') ctx.fillStyle = g ctx.fillRect(-W, -H, W * 3, hy + H) glowBlob(ctx, W / 2, hy, Math.max(W, H) * 0.55, '#ff4a6a', 0.16) // city panorama at infinity (rotates correctly with yaw) const fovH = Math.atan(W / 2 / c.f) + 0.3 for (let i = 0; i < 240; i++) { const az = (i / 240) * Math.PI * 2 let rel = az - c.yaw rel = Math.atan2(Math.sin(rel), Math.cos(rel)) if (Math.abs(rel) > fovH) continue const x = W / 2 + Math.tan(rel) * c.f const bw = c.f * 0.03 const band = i % 3 === 0 ? PULSE.low : i % 3 === 1 ? PULSE.mid : PULSE.high const bh = H * (0.03 + 0.12 * Math.pow(hash(i * 3.1), 2)) * (1 + (0.3 * band + 0.2 * PULSE.kick) * (0.4 + 0.6 * hash(i * 5.3))) ctx.fillStyle = '#07070e' ctx.fillRect(x - bw / 2, hy - bh, bw, bh + 2) ctx.fillStyle = hash(i * 7.7) > 0.5 ? PALETTE.sodium : '#7fc8d8' ctx.globalAlpha = 0.5 for (let w = 0; w < 4; w++) if (hash(i * 13 + w) > 0.5) ctx.fillRect(x - bw * 0.3 + (w % 2) * bw * 0.35, hy - bh + bh * (0.2 + 0.18 * Math.floor(w / 2)), bw * 0.15, bh * 0.08) ctx.globalAlpha = 1 } // ground ctx.fillStyle = '#07080b' ctx.fillRect(-W, hy, W * 3, H * 2) // road segments around the camera const z0 = Math.floor((c.z - 90) / 4) * 4 for (let z = z0; z < c.z + 260; z += 4) { poly3(ctx, c, s, [ [-7.2, 0, z], [7.2, 0, z], [7.2, 0, z + 4.05], [-7.2, 0, z + 4.05], ], z % 8 === 0 ? '#15171c' : '#17191e') } for (let z = z0; z < c.z + 260; z += 4) { for (const ex of [-5.55, 5.4]) poly3(ctx, c, s, [ [ex, 0.01, z], [ex + 0.15, 0.01, z], [ex + 0.15, 0.01, z + 4.05], [ex, 0.01, z + 4.05], ], 'rgba(235,230,215,0.8)') } const d0 = Math.floor((c.z - 90) / 12) * 12 for (let z = d0; z < c.z + 260; z += 12) { for (const lx of [-1.8, 1.8]) poly3(ctx, c, s, [ [lx - 0.08, 0.01, z], [lx + 0.08, 0.01, z], [lx + 0.08, 0.01, z + 5], [lx - 0.08, 0.01, z + 5], ], 'rgba(235,230,215,0.85)') } // lamp posts + light pools + guard rails const l0 = Math.floor((c.z - 90) / 30) * 30 const lamps: { x: number; y: number; k: number; z: number }[] = [] for (let z = l0; z < c.z + 260; z += 30) { for (const sd of [-1, 1]) { poly3(ctx, c, s, [ [sd * 2.5, 0.02, z - 7], [sd * 7.5, 0.02, z - 7], [sd * 7.5, 0.02, z + 7], [sd * 2.5, 0.02, z + 7], ], 'rgba(255,179,92,0.07)') const base = proj(c, s, sd * 8.2, 0, z) const top = proj(c, s, sd * 8.2, 8, z) const head = proj(c, s, sd * 5.8, 8, z) if (base && top && head) { ctx.strokeStyle = '#1c1f26' ctx.lineWidth = Math.max(1, 0.25 * base.k) ctx.beginPath() ctx.moveTo(base.x, base.y) ctx.lineTo(top.x, top.y) ctx.lineTo(head.x, head.y) ctx.stroke() lamps.push({ x: head.x, y: head.y, k: head.k, z: head.z }) } } } for (const L of lamps) glowBlob(ctx, L.x, L.y, Math.max(4, 2.2 * L.k), PALETTE.sodium, 0.95) for (const sd of [-1, 1]) { for (let z = z0; z < c.z + 260; z += 4) poly3(ctx, c, s, [ [sd * 7.6, 0.6, z], [sd * 7.6, 0.85, z], [sd * 7.6, 0.85, z + 4.05], [sd * 7.6, 0.6, z + 4.05], ], '#3a3f48') } // police lights far away if (o.police) policeLights(s, c, t) ctx.restore() } export function policeLights(s: SceneCtx, c: Cam, t: number) { const { ctx } = s ctx.save() ctx.globalCompositeOperation = 'lighter' for (let i = 0; i < 3; i++) { const p = proj(c, s, -3.6 + i * 3.6, 1.6, c.z + 220 + i * 25) if (!p) continue const ph = Math.floor(t * 6 + i) % 2 glowBlob(ctx, p.x - p.k * 0.5, p.y, Math.max(6, 5 * p.k), '#ff2040', ph ? 1 : 0.25) glowBlob(ctx, p.x + p.k * 0.5, p.y, Math.max(6, 5 * p.k), '#2a6aff', ph ? 0.25 : 1) } ctx.restore() } // ------------------------------------------------------------------ actors export interface Actor { kind: CarKind x: number y?: number z: number h: number head?: number high?: number brake?: number pop?: number look?: number pitch?: number jet?: { power: number; angle: number } jetKit?: boolean shield?: number lit?: number } const LEN: Record = { hero: 4.0, rival: 4.5, roadster: 4.3, truck: 16 } const WID: Record = { hero: 1.75, rival: 1.9, roadster: 2.0, truck: 2.5 } /** headlight beams as light thrown onto the road, along each car's heading */ export function drawBeams(s: SceneCtx, c: Cam, actors: Actor[]) { const { ctx } = s ctx.save() ctx.globalCompositeOperation = 'lighter' for (const a of actors) { const head = a.head ?? 1 const high = a.high ?? 0 if (head < 0.05 && high < 0.05) continue const fx = Math.sin(a.h) const fz = Math.cos(a.h) const rx = Math.cos(a.h) const rz = -Math.sin(a.h) const half = LEN[a.kind] / 2 const ox = a.x + fx * half const oz = a.z + fz * half const y = Math.max(0.02, (a.y ?? 0) > 0.3 ? -1 : 0.03) if (y < 0) continue // airborne: no beam on the road // the beam as light on the asphalt: many short segments, falling off with // distance from the lamp, and faded out where it passes under the lens const len = 26 + 48 * high const segs = 14 for (let k = 0; k < segs; k++) { const d0 = (k / segs) * len const d1 = ((k + 1) / segs) * len const w0 = 0.8 + (d0 / len) * (3.5 + 3 * high) const w1 = 0.8 + (d1 / len) * (3.5 + 3 * high) const fall = 1 / (1 + d0 / (6 + 10 * high)) const mx = ox + fx * (d0 + d1) / 2 const mz = oz + fz * (d0 + d1) / 2 const depth = toCam(c, mx, 0, mz).z const nearFade = clamp((depth - 2) / 7) const al = (0.055 * head + 0.11 * high) * fall * nearFade if (al <= 0.003) continue poly3(ctx, c, s, [ [ox + fx * d0 - rx * w0, y, oz + fz * d0 - rz * w0], [ox + fx * d0 + rx * w0, y, oz + fz * d0 + rz * w0], [ox + fx * d1 + rx * w1, y, oz + fz * d1 + rz * w1], [ox + fx * d1 - rx * w1, y, oz + fz * d1 - rz * w1], ], `rgba(255,240,210,${al})`) } // glare at the lamps when they point roughly at the lens for (const sd of [-1, 1]) { const p = proj(c, s, ox + rx * 0.62 * sd, 0.7, oz + rz * 0.62 * sd) if (!p) continue const toCamX = c.x - ox const toCamZ = c.z - oz const facing = (toCamX * fx + toCamZ * fz) / (Math.hypot(toCamX, toCamZ) || 1) if (facing > 0.2) glowBlob(ctx, p.x, p.y, Math.min(s.W * 0.1, p.k * (0.5 + 1.2 * high)), '#fff4dc', (0.35 + 0.45 * high) * facing * clamp((p.z - 1.5) / 4)) } } ctx.restore() } export function drawActors(s: SceneCtx, c: Cam, actors: Actor[]) { const { ctx, t } = s drawBeams(s, c, actors) const sorted = actors .map((a) => ({ a, d: toCam(c, a.x, 0, a.z).z })) .filter((e) => e.d > 0.8) .sort((p, q) => q.d - p.d) for (const { a } of sorted) { const g = proj(c, s, a.x, a.y ?? 0, a.z) if (!g) continue const az = Math.atan2(a.x - c.x, a.z - c.z) let diff = a.h - az diff = Math.atan2(Math.sin(diff), Math.cos(diff)) const w = WID[a.kind] * g.k // ground shadow when airborne if ((a.y ?? 0) > 0.05) { const gg = proj(c, s, a.x, 0, a.z) if (gg) { ctx.fillStyle = `rgba(0,0,0,${0.45 - Math.min(0.3, (a.y ?? 0) * 0.08)})` ctx.beginPath() ctx.ellipse(gg.x, gg.y, WID[a.kind] * gg.k * 0.7, WID[a.kind] * gg.k * 0.15, 0, 0, Math.PI * 2) ctx.fill() } } if (a.kind === 'roadster' || a.kind === 'truck') { if (Math.abs(diff) < 0.7) { if (a.kind === 'roadster') roadsterRear(ctx, g.x, g.y, w, { brake: a.brake, jet: a.jet && a.jet.angle > 2.4 ? a.jet.power : 0, t }) else truckRear(ctx, g.x, g.y, w) } else if (Math.abs(diff) > Math.PI - 0.7) { if (a.kind === 'roadster') roadsterFront(ctx, g.x, g.y, w, { head: a.head ?? 1, t }) else truckRear(ctx, g.x, g.y, w) } else { const L = LEN[a.kind] * g.k const fs = Math.abs(Math.sin(diff)) ctx.save() ctx.translate(g.x, g.y) ctx.scale((diff > 0 ? 1 : -1) * Math.max(0.25, fs), 1) if (a.kind === 'roadster') roadsterSide(ctx, 0, 0, L, a.pitch ?? 0, { spin: t * 40, head: a.head ?? 1, brake: a.brake, t, nozzle: a.jetKit ? 1 : 0 }) else truckSide(ctx, 0, 0, L, t * 20) ctx.restore() } continue } if (Math.abs(diff) < 0.7) { carRear(ctx, a.kind, g.x, g.y, w, { brake: a.brake, pop: a.pop, jet: a.jet && a.jet.angle > 2.4 ? a.jet.power : 0, t }) } else if (Math.abs(diff) > Math.PI - 0.7) { if (a.kind === 'hero') heroCarFront(ctx, g.x, g.y, w, { head: a.head ?? 1, high: a.high ?? 0, t }) else rivalCarFront(ctx, g.x, g.y, w, { head: a.head ?? 1, t, shield: a.shield ?? 0, lit: a.lit ?? 0 }) } else { const L = LEN[a.kind] * g.k const fs = Math.abs(Math.sin(diff)) ctx.save() ctx.translate(g.x, g.y) ctx.scale((diff > 0 ? 1 : -1) * Math.max(0.25, fs), 1) carSide(ctx, a.kind, 0, 0, L, a.pitch ?? 0, { spin: t * 40, head: a.head ?? 1, brake: a.brake, t, look: a.look, jetKit: a.jetKit, jet: a.jet, noBeam: true }) ctx.restore() } } } // ------------------------------------------------------------------ gas / smoke export interface Puff { x: number y: number z: number r: number a: number col: [number, number, number] } export function drawPuffs(s: SceneCtx, c: Cam, puffs: Puff[]) { const { ctx } = s const list = puffs .map((p) => ({ p, q: proj(c, s, p.x, p.y, p.z) })) .filter((e) => e.q) .sort((a, b) => b.q!.z - a.q!.z) for (const { p, q } of list) { const r = Math.min(p.r * q!.k, s.W * 0.32) if (r < 0.5) continue const near = clamp((q!.z - 2) / 6) / (1 + (p.r * q!.k) / (s.W * 0.25)) if (near <= 0.01) continue const g = ctx.createRadialGradient(q!.x, q!.y, 0, q!.x, q!.y, r) const [R, G, B] = p.col g.addColorStop(0, `rgba(${R},${G},${B},${clamp(p.a * near)})`) g.addColorStop(1, `rgba(${R},${G},${B},0)`) ctx.fillStyle = g ctx.fillRect(q!.x - r, q!.y - r, r * 2, r * 2) } } /** a deterministic stream of puffs from an emitter whose position is a function of time */ export function emit( out: Puff[], tNow: number, from: number, to: number, rate: number, pos: (te: number) => { x: number; y: number; z: number } | null, o: { spread: number; rise: number; grow: number; life: number; r0: number; a0: number; col: [number, number, number]; drift?: { x: number; z: number } }, ) { const dt = 1 / rate const start = Math.max(from, tNow - o.life) const end = Math.min(to, tNow) for (let te = Math.ceil(start / dt) * dt; te <= end; te += dt) { const age = tNow - te const p = pos(te) if (!p) continue const hx = hash(te * 91.7) - 0.5 const hz = hash(te * 37.3) - 0.5 const k = age / o.life out.push({ x: p.x + hx * o.spread * (0.3 + age) + (o.drift?.x ?? 0) * age, y: p.y + o.rise * age, z: p.z + hz * o.spread * (0.3 + age) + (o.drift?.z ?? 0) * age, r: o.r0 + o.grow * age, a: o.a0 * (1 - k) * (1 - k), col: o.col, }) } } /** a jet plume drawn in world space (start point, direction, length) */ export function plume3(s: SceneCtx, c: Cam, X: number, Y: number, Z: number, dx: number, dy: number, dz: number, len: number, w0: number, t: number) { const { ctx } = s const a = proj(c, s, X, Y, Z) // never let the plume reach into the lens (keeps it readable, avoids blow-out) let L2 = len for (let i = 0; i < 10; i++) { const d = toCam(c, X + dx * L2, Y + dy * L2, Z + dz * L2).z if (d >= 5) break L2 *= 0.75 } const b = proj(c, s, X + dx * L2, Math.max(0, Y + dy * L2), Z + dz * L2) ctx.save() ctx.globalCompositeOperation = 'lighter' if (a) glowBlob(ctx, a.x, a.y, Math.min(s.W * 0.25, Math.max(6, w0 * 3 * a.k)), '#8fdcff', 0.8 * clamp((a.z - 1.5) / 4)) if (a && b) { const flick = 0.85 + 0.15 * Math.sin(t * 53) ctx.globalAlpha = clamp((b.z - 2) / 8) * 0.7 + 0.3 * clamp(1 - Math.abs(dz)) for (const [col, wk] of [ ['rgba(70,150,255,0.45)', 1], ['rgba(140,225,255,0.65)', 0.6], ['rgba(255,255,255,0.9)', 0.28], ] as [string, number][]) { const wa = w0 * a.k * wk const wb = w0 * 2.4 * b.k * wk * flick const ang = Math.atan2(b.y - a.y, b.x - a.x) const px = Math.cos(ang + Math.PI / 2) const py = Math.sin(ang + Math.PI / 2) ctx.fillStyle = col ctx.beginPath() ctx.moveTo(a.x + px * wa, a.y + py * wa) ctx.lineTo(b.x + px * wb, b.y + py * wb) ctx.arc(b.x, b.y, wb, ang + Math.PI / 2, ang - Math.PI / 2, true) ctx.lineTo(a.x - px * wa, a.y - py * wa) ctx.closePath() ctx.fill() } } ctx.restore() } /** render the world again into the rear-view mirror (mirrored, looking backwards) */ export function rearMirror(s: SceneCtx, c: Cam, actors: Actor[], rect: { x: number; y: number; w: number; h: number }) { const { ctx, W } = s ctx.save() ctx.beginPath() ctx.roundRect(rect.x, rect.y, rect.w, rect.h, rect.h * 0.25) ctx.clip() ctx.translate(rect.x + rect.w / 2, rect.y + rect.h / 2) const sc = rect.w / W ctx.scale(-sc, sc) ctx.translate(-W / 2, -s.H / 2) const back: Cam = { ...c, yaw: c.yaw + Math.PI, hy: s.H * 0.5 } drawHighway(s, back) drawActors(s, back, actors) ctx.restore() ctx.strokeStyle = '#0b0c10' ctx.lineWidth = Math.max(2, rect.h * 0.08) ctx.beginPath() ctx.roundRect(rect.x, rect.y, rect.w, rect.h, rect.h * 0.25) ctx.stroke() }