use super::{geo, CollisionIndex, MarkView, Origin, SharedCollision};
use crate::cameras::PerspectiveCamera;
use crate::controls::{MapControls, PointerEvent};
use crate::math::Vector3;
#[derive(Debug, Clone)]
pub struct MapView {
pub controls: MapControls,
pub camera: PerspectiveCamera,
pub origin: Origin,
pub rebase_distances: f32,
pub collision: SharedCollision,
viewport: (u32, u32),
}
#[derive(Debug, Clone)]
pub struct MapFrame {
pub view: MarkView,
pub shift: Vector3,
}
impl MapView {
pub fn new(target: [f64; 3], distance: f32, viewport: (u32, u32)) -> Self {
let origin = Origin::new(target[0], target[1], target[2]);
let mut camera = PerspectiveCamera::new(
45.0,
viewport.0.max(1) as f32 / viewport.1.max(1) as f32,
1.0,
10.0,
);
let controls = MapControls::new(Vector3::new(0.0, 0.0, 0.0), distance);
controls.apply(&mut camera);
controls.fit_clip_planes(&mut camera);
Self {
controls,
camera,
origin,
rebase_distances: 100.0,
collision: CollisionIndex::new().shared(),
viewport: (viewport.0.max(1), viewport.1.max(1)),
}
}
pub fn viewport(&self) -> (u32, u32) {
self.viewport
}
pub fn set_viewport(&mut self, width: u32, height: u32) {
self.viewport = (width.max(1), height.max(1));
self.camera.aspect = self.viewport.0 as f32 / self.viewport.1 as f32;
}
pub fn handle(&mut self, ev: PointerEvent, cursor: (f32, f32)) {
let vp = (self.viewport.0 as f32, self.viewport.1 as f32);
self.controls.update(ev, cursor, &mut self.camera, vp);
}
pub fn target(&self) -> [f64; 3] {
self.origin.to_world(self.controls.target)
}
pub fn look_at(&mut self, target: [f64; 3], distance: f32) -> Vector3 {
let shift = self.origin.rebase(target);
self.controls.target = Vector3::new(0.0, 0.0, 0.0);
self.controls.ground += shift.y;
self.controls.distance =
distance.clamp(self.controls.min_distance, self.controls.max_distance);
self.sync_camera();
shift
}
pub fn ground_point(&self, x: f32, y: f32) -> Option<[f64; 3]> {
let vp = (self.viewport.0 as f32, self.viewport.1 as f32);
self.controls
.ground_point(&self.camera, x, y, vp)
.map(|p| self.origin.to_world(p))
}
pub fn rebase_if_needed(&mut self) -> Vector3 {
let t = self.controls.target;
let reach = (t.x * t.x + t.y * t.y + t.z * t.z).sqrt();
if reach <= self.controls.distance * self.rebase_distances {
return Vector3::new(0.0, 0.0, 0.0);
}
let w = self.target();
let shift = self.origin.rebase([w[0], self.origin.position[1], w[2]]);
self.controls.target = self.controls.target + shift;
self.controls.ground += shift.y;
self.sync_camera();
shift
}
fn sync_camera(&mut self) {
self.controls.apply(&mut self.camera);
self.controls.fit_clip_planes(&mut self.camera);
}
pub fn mark_view(&self) -> MarkView {
MarkView::new(&self.camera, self.origin, self.viewport)
}
pub fn begin_frame(&mut self) -> MapFrame {
let shift = self.rebase_if_needed();
self.sync_camera();
let view = self.mark_view();
self.collision.lock().unwrap().begin_frame(&view);
MapFrame { view, shift }
}
pub fn begin_frame_for(&mut self, renderer: &crate::Renderer) -> MapFrame {
let (w, h) = renderer.drawing_buffer_size();
if (w, h) != self.viewport {
self.set_viewport(w, h);
}
let shift = self.rebase_if_needed();
self.sync_camera();
let view = MarkView::from_renderer(&self.camera, self.origin, renderer);
self.collision.lock().unwrap().begin_frame(&view);
MapFrame { view, shift }
}
pub fn covering_tiles(
&self,
view: &MarkView,
max_zoom: u8,
tile_px: f64,
max_tiles: usize,
) -> Vec<geo::TileId> {
let ground = self.origin.position[1] + self.controls.ground as f64;
geo::covering_tiles(view, max_zoom, tile_px, ground, max_tiles)
}
pub fn zoom(&self, tile_px: f64) -> f64 {
let upp = self
.mark_view()
.units_per_pixel(self.target())
.unwrap_or(1.0);
geo::zoom_for_units_per_pixel(upp, tile_px)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_origin_follows_a_long_pan() {
let start = [-13_627_000.0, 0.0, 4_548_000.0];
let mut map = MapView::new(start, 500.0, (800, 600));
let first = map.origin.position;
let mut shifts = 0;
for _ in 0..1000 {
map.controls.target.x += 100.0;
let f = map.begin_frame();
if f.shift.x != 0.0 {
shifts += 1;
}
}
assert!(shifts > 0, "rebased along the way");
assert_ne!(map.origin.position, first);
let t = map.target();
assert!((t[0] - (start[0] + 100_000.0)).abs() < 1e-3, "{t:?}");
assert!(map.controls.target.x.abs() <= 500.0 * map.rebase_distances);
}
#[test]
fn the_target_projects_to_the_centre() {
let target = [2_000_000.0, 0.0, -1_000_000.0];
let mut map = MapView::new(target, 1000.0, (640, 480));
map.controls.pitch = 0.9;
map.controls.bearing = 0.4;
let f = map.begin_frame();
let p = f.view.project(target).unwrap();
assert!(
(p[0] - 320.0).abs() < 0.01 && (p[1] - 240.0).abs() < 0.01,
"{p:?}"
);
let g = map.ground_point(320.0, 240.0).unwrap();
assert!((g[0] - target[0]).abs() < 0.01 && (g[2] - target[2]).abs() < 0.01);
}
#[test]
fn a_still_frame_keeps_the_collision_boxes() {
let mut map = MapView::new([0.0; 3], 1000.0, (640, 480));
map.begin_frame();
let generation = map.collision.lock().unwrap().generation();
map.begin_frame();
assert_eq!(map.collision.lock().unwrap().generation(), generation);
map.controls.distance = 900.0;
map.begin_frame();
assert_ne!(map.collision.lock().unwrap().generation(), generation);
}
}