Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
95 changes: 82 additions & 13 deletions src-tauri/src/native/mod.rs
Original file line number Diff line number Diff line change
Expand Up @@ -1031,16 +1031,17 @@ impl Renderer {
let pose_count = assets.poses.len().max(1);
let pose = ((crank.fract() * pose_count as f64) as usize) % pose_count;
// On a berm, a rider stands on the slope where they are across the trail and leans with it.
let place = |q: &Pos, d: f64, lane: f64| -> Mat {
// Riders also lean into bends, by what balances the turn at their speed.
let place = |q: &Pos, d: f64, lane: f64, speed: f64| -> Mat {
let (bank, lift) = world.bank_at(d, lane);
let at = rel([q.x + q.heading.cos() * lane, q.ele + LAYOUT.road_lift + lift, q.z - q.heading.sin() * lane]);
model_rolled(at, q.heading as f32, -(q.grade.atan()) as f32, bank.atan() as f32)
model_rolled(at, q.heading as f32, -(q.grade.atan()) as f32, (bank.atan() + lean_at(&route, d, speed)) as f32)
};
// The rider's own colour, #e9ff60, in linear light.
slots.push(Draw { model: place(&p, shown, 0.0), tint: [0.815, 1.0, 0.117, 1.0], flags: [1.0, 1.0, 0.0, 0.0] });
slots.push(Draw { model: place(&p, shown, 0.0, speed), tint: [0.815, 1.0, 0.117, 1.0], flags: [1.0, 1.0, 0.0, 0.0] });
riders.push((slots.len() - 1, pose, false));
let mut rider_tags: Vec<(String, [f64; 3])> = Vec::new();
for (i, (id, kind, color, d, _)) in rivals.iter().enumerate() {
for (i, (id, kind, color, d, rival_speed)) in rivals.iter().enumerate() {
let gap = if lap_ride { wrapped(shown, *d).abs() } else { (d - shown).abs() };
if gap > 700.0 || (!lap_ride && (*d <= 0.0 || *d >= route.total)) || slots.len() as u64 >= MAX_DRAWS {
continue;
Expand All @@ -1052,7 +1053,11 @@ impl Renderer {
let q = sample(&route, *d);
let ghost = *kind == RivalKind::Ghost;
let rgb = [((color >> 16) & 255) as f32 / 255.0, ((color >> 8) & 255) as f32 / 255.0, (color & 255) as f32 / 255.0].map(|c| c.powf(2.2));
slots.push(Draw { model: place(&q, *d, lane), tint: if ghost { [1.0, 1.0, 1.0, 0.38] } else { [rgb[0], rgb[1], rgb[2], 1.0] }, flags: [1.0, 1.0, 0.0, if ghost { 1.0 } else { 0.0 }] });
slots.push(Draw {
model: place(&q, *d, lane, *rival_speed),
tint: if ghost { [1.0, 1.0, 1.0, 0.38] } else { [rgb[0], rgb[1], rgb[2], 1.0] },
flags: [1.0, 1.0, 0.0, if ghost { 1.0 } else { 0.0 }],
});
riders.push((slots.len() - 1, (pose + i * 2) % pose_count, ghost));
if gap < 250.0 && gap > 12.0 {
rider_tags.push((id.clone(), [q.x + q.heading.cos() * lane, q.ele + 2.3, q.z - q.heading.sin() * lane]));
Expand Down Expand Up @@ -1486,14 +1491,34 @@ fn sample(route: &velopopuli_core::gpx::Route, dist: f64) -> Pos {
let i = (f.floor() as usize).min(route.n - 2);
let t = f - i as f64;
let lerp = |a: f64, b: f64| a + (b - a) * t;
let (a, b) = (i.saturating_sub(2), (i + 3).min(route.n - 1));
Pos {
x: lerp(route.x[i], route.x[i + 1]),
z: lerp(route.z[i], route.z[i + 1]),
ele: lerp(route.ele[i] as f64, route.ele[i + 1] as f64),
grade: lerp(route.grade[i] as f64, route.grade[i + 1] as f64),
heading: (route.x[b] - route.x[a]).atan2(route.z[b] - route.z[a]),
}
// On a smooth curve through the samples, as the page's `sampleAt` does it, so a tight bend
// is ridden round rather than in a kink at every sample.
let (x, dx) = curve(&route.x, i, t);
let (z, dz) = curve(&route.z, i, t);
Pos { x, z, ele: lerp(route.ele[i] as f64, route.ele[i + 1] as f64), grade: lerp(route.grade[i] as f64, route.grade[i + 1] as f64), heading: dx.atan2(dz) }
}

/// The Catmull-Rom curve through `a` between samples `i` and `i + 1`, at `t` of the way: its
/// value and its rate of change.
fn curve(a: &[f64], i: usize, t: f64) -> (f64, f64) {
let (p0, p1, p2, p3) = (a[i.saturating_sub(1)], a[i], a[i + 1], a[(i + 2).min(a.len() - 1)]);
let (b, c, d) = (p2 - p0, 2.0 * p0 - 5.0 * p1 + 4.0 * p2 - p3, -p0 + 3.0 * p1 - 3.0 * p2 + p3);
(p1 + 0.5 * t * (b + t * (c + t * d)), 0.5 * (b + t * (2.0 * c + 3.0 * t * d)))
}

/// Over how far a bend's tightness is judged, either side of the rider.
const LEAN_SPAN: f64 = 4.0;
/// The most a rider leans into a bend.
const MAX_LEAN: f64 = 40.0 * std::f64::consts::PI / 180.0;

/// How far a rider at `speed` (m/s) leans into the bend at `dist`, as the page's `leanAt`
/// gives it: the lean that balances the turn, atan(v² / g r). Negative leans left.
fn lean_at(route: &velopopuli_core::gpx::Route, dist: f64, speed: f64) -> f64 {
let h = |d: f64| sample(route, d).heading;
let dh = h(dist + LEAN_SPAN) - h(dist - LEAN_SPAN);
// Turning towards +x (heading rising) is turning left.
let lean = (speed * speed * (dh.sin().atan2(dh.cos()) / (2.0 * LEAN_SPAN)) / 9.81).atan();
-lean.clamp(-MAX_LEAN, MAX_LEAN)
}

/// Ground height from a loaded chunk, if the chunk under the point is in.
Expand All @@ -1516,3 +1541,47 @@ fn write_png(path: &std::path::Path, w: u32, h: u32, rgba: &[u8]) -> Result<(),
enc.set_depth(png::BitDepth::Eight);
enc.write_header().and_then(|mut wr| wr.write_image_data(rgba)).map_err(|e| e.to_string())
}

#[cfg(test)]
mod tests {
use velopopuli_core::gpx::{build_route, RawPoint};

/// A rider going round a tight circle turns a little for every bit ridden, never in steps,
/// moves on a path without kinks, faces along it, and leans into the turn.
#[test]
fn corners_turn_smoothly() {
// Two laps of a 30 m-radius circle anticlockwise on the map (turning left), a point every 2°.
let (lat0, lon0, r) = (51.0_f64, 0.0_f64, 30.0);
let m_lat = 111_320.0;
let raw: Vec<RawPoint> = (0..=360)
.map(|k| {
let a = (k as f64 * 2.0).to_radians();
RawPoint { lat: lat0 + r * a.sin() / m_lat, lon: lon0 + r * a.cos() / (m_lat * lat0.to_radians().cos()), ele: None }
})
.collect();
let route = build_route("Circle", &raw).unwrap();
let wrap = |d: f64| d.sin().atan2(d.cos());
let (from, to, dd) = (20.0, route.total - 20.0, 0.1);
let (mut turned, mut kinked): (f64, f64) = (0.0, 0.0);
let mut d = from;
while d < to {
let (p, q, s) = (super::sample(&route, d), super::sample(&route, d + dd), super::sample(&route, d + 2.0 * dd));
turned = turned.max(wrap(q.heading - p.heading).abs());
// The way it moves from one 10 cm to the next: a kink is a sudden change.
let (m1, m2) = ((q.x - p.x).atan2(q.z - p.z), (s.x - q.x).atan2(s.z - q.z));
kinked = kinked.max(wrap(m2 - m1).abs());
assert!(wrap(p.heading - m1).abs() < 0.02, "at {d:.1} m facing {:.3}, moving {m1:.3}", p.heading);
d += dd;
}
// Round a 30 m circle, 10 cm turns the rider by 1/300 rad; a step or kink at each 5 m
// sample would be ~50 times that.
assert!(turned < 3.0 * dd / r, "the heading jumped {turned:.4} rad in {dd} m");
assert!(kinked < 3.0 * dd / r, "the path kinked {kinked:.4} rad in {dd} m");
// At 10 m/s round 30 m, the balancing lean is atan(100 / (9.81 · 30)), about 19°, to the left.
let lean = super::lean_at(&route, route.total / 2.0, 10.0);
assert!((lean + (100.0_f64 / (9.81 * 30.0)).atan()).abs() < 0.03, "leans {:.1}°", lean.to_degrees());
// Standing still, no lean; and never past the limit, however fast.
assert!(super::lean_at(&route, route.total / 2.0, 0.0).abs() < 1e-9);
assert!((super::lean_at(&route, route.total / 2.0, 40.0) + super::MAX_LEAN).abs() < 1e-9);
}
}
43 changes: 37 additions & 6 deletions web/src/core/gpx.ts
Original file line number Diff line number Diff line change
Expand Up @@ -75,19 +75,50 @@ export interface RoutePos {
heading: number
}

/** A point along the route. The line runs on a smooth curve through the samples (Catmull-Rom)
* rather than straight from one to the next, so a tight bend is ridden round, not in a kink at
* every sample; the heading is the curve's own direction there. */
export function sampleAt(route: Route, dist: number, out?: RoutePos): RoutePos {
const f = Math.max(0, Math.min(route.n - 1, dist / route.step))
const i = Math.min(route.n - 2, Math.floor(f))
const t = f - i
const lerp = (a: Float64Array): number => a[i] + (a[i + 1] - a[i]) * t
// Heading is taken over a ~25 m baseline so GPS jitter doesn't shake the camera.
const a = Math.max(0, i - 2)
const b = Math.min(route.n - 1, i + 3)
const [x, dx] = curve(route.x, route.n, i, t)
const [z, dz] = curve(route.z, route.n, i, t)
const o = out ?? ({} as RoutePos)
o.x = lerp(route.x)
o.z = lerp(route.z)
o.x = x
o.z = z
o.ele = lerp(route.ele)
o.grade = lerp(route.grade)
o.heading = Math.atan2(route.x[b] - route.x[a], route.z[b] - route.z[a])
o.heading = Math.atan2(dx, dz)
return o
}

/** The Catmull-Rom curve through `a` between samples `i` and `i + 1`, at `t` of the way: its
* value and its rate of change. */
function curve(a: Float64Array, n: number, i: number, t: number): [number, number] {
const p0 = a[Math.max(0, i - 1)]
const p1 = a[i]
const p2 = a[i + 1]
const p3 = a[Math.min(n - 1, i + 2)]
const b = p2 - p0
const c = 2 * p0 - 5 * p1 + 4 * p2 - p3
const d = -p0 + 3 * p1 - 3 * p2 + p3
return [p1 + 0.5 * t * (b + t * (c + t * d)), 0.5 * (b + t * (2 * c + 3 * t * d))]
}

/** Over how far a bend's tightness is judged, either side of the rider. */
const LEAN_SPAN = 4
/** The most a rider leans into a bend. */
const MAX_LEAN = (40 * Math.PI) / 180

/** How far a rider at `speed` (m/s) leans into the bend at `dist`, in radians: the lean that
* balances the turn, atan(v² / g r). Negative leans left, the way `rotation.z` rolls. */
export function leanAt(route: Route, dist: number, speed: number): number {
const h = (d: number): number => sampleAt(route, d, scratch).heading
const turn = Math.atan2(Math.sin(h(dist + LEAN_SPAN) - h(dist - LEAN_SPAN)), Math.cos(h(dist + LEAN_SPAN) - h(dist - LEAN_SPAN)))
// Turning towards +x (heading rising) is turning left.
const lean = Math.atan((speed * speed * (turn / (2 * LEAN_SPAN))) / 9.81)
return -Math.max(-MAX_LEAN, Math.min(MAX_LEAN, lean))
}
const scratch = {} as RoutePos
11 changes: 6 additions & 5 deletions web/src/world/scene.ts
Original file line number Diff line number Diff line change
Expand Up @@ -2,7 +2,7 @@ import * as THREE from 'three'
import { Barriers } from './barriers'
import { SURFACES, surfaceRuns, surfaceTexture } from './surfaces'
import { api } from '../bridge'
import { bankAt, halfWidthAt, sampleAt, wrapDist, wrapGap, type Route, type RoutePos } from '../core/gpx'
import { bankAt, halfWidthAt, leanAt, sampleAt, wrapDist, wrapGap, type Route, type RoutePos } from '../core/gpx'
import type { Landmark, WorldLayout } from '../types'
import { RiderModel } from './rider'
import { Terrain } from './terrain'
Expand Down Expand Up @@ -422,15 +422,16 @@ export class World {
}

/** On a berm, a rider stands on the slope where they are across the trail and leans with it. */
private place(group: THREE.Object3D, p: RoutePos, dist: number, lane: number): void {
/** Riders also lean into bends, by what balances the turn at their speed. */
private place(group: THREE.Object3D, p: RoutePos, dist: number, lane: number, speed: number): void {
const [bank, lift] = bankAt(this.route, dist, lane)
group.position.set(p.x + Math.cos(p.heading) * lane, p.ele + this.layout.roadLift + lift, p.z - Math.sin(p.heading) * lane)
group.rotation.set(-Math.atan(p.grade), p.heading, Math.atan(bank), 'YXZ')
group.rotation.set(-Math.atan(p.grade), p.heading, Math.atan(bank) + leanAt(this.route, dist, speed), 'YXZ')
}

frame(dt: number, f: WorldFrame): void {
const p = sampleAt(this.route, f.distance, this.pos)
this.place(this.rider.group, p, f.distance, 0)
this.place(this.rider.group, p, f.distance, 0, f.speed)
this.rider.update(dt, f.speed, f.cadence)

const seen = new Set<string>()
Expand All @@ -451,7 +452,7 @@ export class World {
const op = sampleAt(this.route, r.distance, this.otherPos)
// Kept on the road where it is narrow.
const room = Math.max(0.4, halfWidthAt(this.route, r.distance) - 0.6)
this.place(other.model.group, op, r.distance, Math.sign(other.lane) * Math.min(Math.abs(other.lane), room))
this.place(other.model.group, op, r.distance, Math.sign(other.lane) * Math.min(Math.abs(other.lane), room), r.speed)
other.model.update(dt, r.speed, r.speed > 0.5 ? 85 : 0)
other.label.position.copy(other.model.group.position)
other.label.position.y += 2.3
Expand Down
Loading