An indoor navigation drone's firmware and its simulator, in Rust and Dioxus
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215//! Where the view is looking.//!//! The transforms are the C renderer's: an offset in room coordinates and a//! zoom, with the y-axis flipped because the room's y grows north and a//! canvas's grows down.
use randie_sim::Vec2;
/// How far out the view can be pulled.pub const MIN_ZOOM: f64 = 0.2;/// How far in the view can be pushed.pub const MAX_ZOOM: f64 = 10.0;
/// The view onto the room.#[derive(Clone, Copy, PartialEq, Debug)]pub struct Camera { /// Canvas pixels to the centimetre. pub zoom: f64, /// The room coordinate at the canvas's top-left corner. pub offset: Vec2,}
impl Default for Camera { /// The C renderer's opening view: no magnification, with the room's origin /// five metres in from the corner. fn default() -> Self { Self { zoom: 1.0, offset: Vec2::new(-500.0, 500.0), } }}
impl Camera { /// A length in centimetres, in canvas pixels. #[must_use] pub fn scale(&self, centimetres: f64) -> f64 { centimetres * self.zoom }
/// A room coordinate, on the canvas. #[must_use] pub fn to_screen(self, world: Vec2) -> (f64, f64) { ( (world.x - self.offset.x) * self.zoom, -(world.y - self.offset.y) * self.zoom, ) }
/// A canvas coordinate, in the room. #[must_use] pub fn to_world(self, x: f64, y: f64) -> Vec2 { Vec2::new( x / self.zoom + self.offset.x, -(y / self.zoom - self.offset.y), ) }
/// Zooms by a factor about a point on the canvas, so whatever is under the /// cursor stays under it. /// /// The C's wheel handler changed the zoom on its own and let the view slide /// out from under the pointer. pub fn zoom_at(&mut self, x: f64, y: f64, factor: f64) { let before = self.to_world(x, y); self.zoom = (self.zoom * factor).clamp(MIN_ZOOM, MAX_ZOOM); let after = self.to_world(x, y);
self.offset += before - after; }
/// Slides the view by a distance in canvas pixels. pub fn pan_by_pixels(&mut self, dx: f64, dy: f64) { self.offset += Vec2::new(-dx / self.zoom, dy / self.zoom); }
/// Slides the view by a distance in centimetres. pub fn pan_by_room(&mut self, dx: f64, dy: f64) { self.offset += Vec2::new(dx, dy); }
/// Frames a region of the room inside a rectangle of the canvas. /// /// The rectangle is `(left, top, width, height)` in canvas pixels, so the /// room can be centred on the part of the canvas the panel is not sitting /// over. /// /// The C opened on a fixed offset and a zoom of one, which put a room the /// size of the default one mostly off the bottom-right of a window it /// assumed was a thousand pixels square. The canvas here is whatever size /// the browser window is, so the view is worked out instead. pub fn fit(&mut self, min: Vec2, max: Vec2, area: (f64, f64, f64, f64), margin: f64) { let (left, top, width, height) = area;
let room_width = (max.x - min.x).max(1.0); let room_height = (max.y - min.y).max(1.0);
let usable_width = (width - margin * 2.0).max(1.0); let usable_height = (height - margin * 2.0).max(1.0);
self.zoom = (usable_width / room_width) .min(usable_height / room_height) .clamp(MIN_ZOOM, MAX_ZOOM);
// Put the region's middle at the middle of the rectangle. let centre = Vec2::new((min.x + max.x) / 2.0, (min.y + max.y) / 2.0); self.offset = Vec2::new( centre.x - (left + width / 2.0) / self.zoom, centre.y + (top + height / 2.0) / self.zoom, ); }}
#[cfg(test)]mod tests { use super::*;
#[test] fn screen_and_room_coordinates_are_inverses() { let camera = Camera::default(); let world = Vec2::new(123.0, -456.0); let (x, y) = camera.to_screen(world); let back = camera.to_world(x, y);
assert!((back.x - world.x).abs() < 1e-9); assert!((back.y - world.y).abs() < 1e-9); }
#[test] fn north_is_up() { let camera = Camera::default(); let (_, high) = camera.to_screen(Vec2::new(0.0, 100.0)); let (_, low) = camera.to_screen(Vec2::new(0.0, 0.0));
assert!(high < low); }
#[test] fn zooming_keeps_the_point_under_the_cursor() { let mut camera = Camera::default(); let before = camera.to_world(300.0, 200.0);
camera.zoom_at(300.0, 200.0, 2.0); let after = camera.to_world(300.0, 200.0);
assert!((after.x - before.x).abs() < 1e-9); assert!((after.y - before.y).abs() < 1e-9); assert!((camera.zoom - 2.0).abs() < 1e-9); }
#[test] fn zooming_stops_at_the_ends_of_its_range() { let mut camera = Camera::default();
for _ in 0..50 { camera.zoom_at(0.0, 0.0, 2.0); } assert_eq!(camera.zoom, MAX_ZOOM);
for _ in 0..100 { camera.zoom_at(0.0, 0.0, 0.5); } assert_eq!(camera.zoom, MIN_ZOOM); }
#[test] fn fitting_a_room_puts_it_in_the_middle_of_the_canvas() { let mut camera = Camera::default(); let min = Vec2::new(0.0, -600.0); let max = Vec2::new(600.0, 0.0);
camera.fit(min, max, (0.0, 0.0, 1000.0, 800.0), 20.0);
let (x, y) = camera.to_screen(Vec2::new(300.0, -300.0)); assert!((x - 500.0).abs() < 1e-6, "{x}"); assert!((y - 400.0).abs() < 1e-6, "{y}");
// And the whole room is on the canvas. let (left, top) = camera.to_screen(Vec2::new(min.x, max.y)); let (right, bottom) = camera.to_screen(Vec2::new(max.x, min.y)); assert!(left >= 0.0 && top >= 0.0); assert!(right <= 1000.0 && bottom <= 800.0); }
#[test] fn fitting_into_a_rectangle_keeps_clear_of_the_rest() { let mut camera = Camera::default(); let min = Vec2::new(0.0, -600.0); let max = Vec2::new(600.0, 0.0);
// A 320-pixel panel down the left-hand side. camera.fit(min, max, (320.0, 0.0, 680.0, 800.0), 20.0);
let (left, _) = camera.to_screen(Vec2::new(min.x, max.y)); let (right, _) = camera.to_screen(Vec2::new(max.x, min.y));
assert!(left >= 320.0, "the room runs under the panel: {left}"); assert!(right <= 1000.0, "the room runs off the canvas: {right}"); // And it is centred on what is left. assert!(((left + right) / 2.0 - 660.0).abs() < 1e-6); }
#[test] fn panning_by_pixels_moves_the_view_the_other_way() { let mut camera = Camera::default(); let before = camera.to_world(500.0, 500.0);
// Dragging the room to the right shows what was to its left. camera.pan_by_pixels(100.0, 0.0); let after = camera.to_world(500.0, 500.0);
assert!((after.x - (before.x - 100.0)).abs() < 1e-9); }}