use glam::{Mat4, Vec2};
use crate::canvas::letterbox::Letterbox;
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct WorldUnits {
pub pixels_per_unit: f32,
pub y_up: bool,
}
impl Default for WorldUnits {
fn default() -> Self {
Self {
pixels_per_unit: 1.0,
y_up: false,
}
}
}
impl WorldUnits {
pub(crate) fn screen_y_sign(self) -> f32 {
if self.y_up { -1.0 } else { 1.0 }
}
}
#[derive(Debug, Clone, Copy)]
pub struct Camera {
pub center: Vec2,
pub zoom: f32,
logical: Vec2,
units: WorldUnits,
}
impl Camera {
pub fn new(logical_w: u32, logical_h: u32) -> Self {
Self::with_view(Vec2::new(logical_w as f32, logical_h as f32))
}
pub fn with_view(logical: Vec2) -> Self {
Self {
center: logical * 0.5,
zoom: 1.0,
logical,
units: WorldUnits::default(),
}
}
#[must_use]
pub fn with_units(mut self, units: WorldUnits) -> Self {
assert!(
units.pixels_per_unit.is_finite() && units.pixels_per_unit > 0.0,
"WorldUnits::pixels_per_unit must be finite and > 0, got {}",
units.pixels_per_unit
);
self.units = units;
self
}
pub fn units(&self) -> WorldUnits {
self.units
}
pub fn set_view_size(&mut self, logical: Vec2) {
self.logical = logical;
}
pub fn view_size(&self) -> Vec2 {
self.logical
}
pub fn view_proj(&self) -> Mat4 {
let half = self.logical * 0.5 / self.zoom / self.units.pixels_per_unit;
let sx = 1.0 / half.x;
let sy = -self.units.screen_y_sign() / half.y;
Mat4::from_cols(
glam::Vec4::new(sx, 0.0, 0.0, 0.0),
glam::Vec4::new(0.0, sy, 0.0, 0.0),
glam::Vec4::new(0.0, 0.0, 1.0, 0.0),
glam::Vec4::new(-self.center.x * sx, -self.center.y * sy, 0.5, 1.0),
)
}
pub fn screen_view_proj(logical_w: u32, logical_h: u32) -> Mat4 {
Camera::new(logical_w, logical_h).view_proj()
}
pub fn screen_view_proj_size(logical: Vec2) -> Mat4 {
Camera::with_view(logical).view_proj()
}
pub fn screen_to_world(&self, cursor_px: Vec2, lb: &Letterbox) -> Vec2 {
let logical = Vec2::new(
(cursor_px.x - lb.x) / (lb.width / self.logical.x),
(cursor_px.y - lb.y) / (lb.height / self.logical.y),
);
let offset = (logical - self.logical * 0.5) / self.zoom;
self.center
+ Vec2::new(offset.x, offset.y * self.units.screen_y_sign())
/ self.units.pixels_per_unit
}
pub fn world_to_screen(&self, world: Vec2) -> Vec2 {
let offset = (world - self.center) * (self.zoom * self.units.pixels_per_unit);
Vec2::new(offset.x, offset.y * self.units.screen_y_sign()) + self.logical * 0.5
}
}
#[cfg(test)]
mod tests {
use super::*;
use glam::Vec4;
use wasm_bindgen_test::wasm_bindgen_test;
#[wasm_bindgen_test(unsupported = test)]
fn world_to_screen_and_screen_to_world_use_hand_computed_scales() {
let mut camera = Camera::new(200, 100).with_units(WorldUnits {
pixels_per_unit: 8.0,
y_up: true,
});
camera.center = Vec2::new(10.0, 5.0);
camera.zoom = 2.0;
assert_eq!(
camera.world_to_screen(Vec2::new(12.0, 6.0)),
Vec2::new(132.0, 34.0)
);
assert_eq!(camera.units().pixels_per_unit, 8.0);
assert!(camera.units().y_up);
let lb = Letterbox {
x: 0.0,
y: 0.0,
width: 200.0,
height: 100.0,
};
assert_eq!(
camera.screen_to_world(Vec2::new(132.0, 34.0), &lb),
Vec2::new(12.0, 6.0)
);
camera.set_view_size(Vec2::new(400.0, 200.0));
assert_eq!(camera.view_size(), Vec2::new(400.0, 200.0));
assert_eq!(
camera.world_to_screen(Vec2::new(12.0, 6.0)),
Vec2::new(232.0, 84.0)
);
}
use crate::canvas::letterbox::fit_fractional;
const W: u32 = 960;
const H: u32 = 540;
fn assert_close(a: Vec2, b: Vec2) {
assert!((a - b).length() < 1e-2, "expected {b:?}, got {a:?}");
}
fn world_to_window(world: Vec2, cam: &Camera, lb: &Letterbox) -> Vec2 {
let clip = cam.view_proj() * Vec4::new(world.x, world.y, 0.0, 1.0);
let lx = (clip.x * 0.5 + 0.5) * W as f32;
let ly = (0.5 - clip.y * 0.5) * H as f32;
Vec2::new(
lb.x + lx * (lb.width / W as f32),
lb.y + ly * (lb.height / H as f32),
)
}
#[wasm_bindgen_test(unsupported = test)]
fn default_camera_maps_logical_pixels_identically() {
let cam = Camera::new(W, H);
let top_left = cam.view_proj() * Vec4::new(0.0, 0.0, 0.0, 1.0);
assert!((top_left.x + 1.0).abs() < 1e-6);
assert!((top_left.y - 1.0).abs() < 1e-6);
let bottom_right = cam.view_proj() * Vec4::new(960.0, 540.0, 0.0, 1.0);
assert!((bottom_right.x - 1.0).abs() < 1e-6);
assert!((bottom_right.y + 1.0).abs() < 1e-6);
}
#[wasm_bindgen_test(unsupported = test)]
fn screen_projection_is_the_identity_camera() {
assert_eq!(
Camera::screen_view_proj(W, H),
Camera::new(W, H).view_proj()
);
}
#[wasm_bindgen_test(unsupported = test)]
fn screen_to_world_center_is_camera_center() {
let mut cam = Camera::new(W, H);
cam.center = Vec2::new(123.0, -45.0);
for (ww, wh) in [(960, 540), (1920, 1080), (2000, 540), (960, 1000)] {
let lb = fit_fractional(ww, wh, W, H);
let center_px = Vec2::new(ww as f32 * 0.5, wh as f32 * 0.5);
assert_close(cam.screen_to_world(center_px, &lb), cam.center);
}
}
#[wasm_bindgen_test(unsupported = test)]
fn screen_to_world_roundtrips_with_letterbox_and_zoom() {
let mut cam = Camera::new(W, H);
cam.center = Vec2::new(300.0, 800.0);
cam.zoom = 2.0;
let lb = fit_fractional(1600, 1600, W, H);
assert!(lb.y > 0.0, "expected horizontal bars");
for world in [
Vec2::new(300.0, 800.0),
Vec2::new(120.0, 700.0),
Vec2::new(500.0, 900.0),
] {
let px = world_to_window(world, &cam, &lb);
assert_close(cam.screen_to_world(px, &lb), world);
}
}
#[wasm_bindgen_test(unsupported = test)]
fn zoom_narrows_the_visible_span() {
let mut cam = Camera::new(W, H);
cam.zoom = 2.0;
let lb = fit_fractional(W, H, W, H);
let right_edge = cam.screen_to_world(Vec2::new(960.0, 270.0), &lb);
assert_close(right_edge, Vec2::new(480.0 + 240.0, 270.0));
}
#[wasm_bindgen_test(unsupported = test)]
fn world_to_screen_follows_center_and_zoom_in_pixels() {
let cam = Camera::new(W, H);
assert_close(
cam.world_to_screen(Vec2::new(100.0, 40.0)),
Vec2::new(100.0, 40.0),
);
let mut cam = Camera::new(W, H);
cam.center = Vec2::new(300.0, 800.0);
cam.zoom = 2.0;
assert_close(
cam.world_to_screen(Vec2::new(310.0, 790.0)),
Vec2::new(500.0, 250.0),
);
}
fn units32() -> WorldUnits {
WorldUnits {
pixels_per_unit: 32.0,
y_up: true,
}
}
#[wasm_bindgen_test(unsupported = test)]
fn units_view_proj_maps_one_unit_to_ppu_pixels_y_up() {
let mut cam = Camera::new(W, H).with_units(units32());
cam.center = Vec2::ZERO;
let clip = cam.view_proj() * Vec4::new(1.0, 1.0, 0.0, 1.0);
assert!((clip.x - 32.0 / 480.0).abs() < 1e-6, "{clip:?}");
assert!((clip.y - 32.0 / 270.0).abs() < 1e-6, "{clip:?}");
}
#[wasm_bindgen_test(unsupported = test)]
fn units_screen_to_world_corners_y_up() {
let mut cam = Camera::new(W, H).with_units(units32());
cam.center = Vec2::ZERO;
let lb = fit_fractional(W, H, W, H);
assert_close(
cam.screen_to_world(Vec2::ZERO, &lb),
Vec2::new(-15.0, 8.4375),
);
assert_close(
cam.screen_to_world(Vec2::new(960.0, 540.0), &lb),
Vec2::new(15.0, -8.4375),
);
}
#[wasm_bindgen_test(unsupported = test)]
fn units_world_to_screen_and_back_roundtrip_with_letterbox() {
let mut cam = Camera::new(W, H).with_units(units32());
cam.center = Vec2::new(3.0, -2.0);
cam.zoom = 2.0;
assert_close(
cam.world_to_screen(Vec2::new(3.0, -2.0)),
Vec2::new(480.0, 270.0),
);
assert_close(
cam.world_to_screen(Vec2::new(4.0, -2.0)),
Vec2::new(544.0, 270.0),
);
assert_close(
cam.world_to_screen(Vec2::new(3.0, -1.0)),
Vec2::new(480.0, 206.0),
);
let lb = fit_fractional(1600, 1600, W, H);
assert!(lb.y > 0.0, "expected horizontal bars");
for world in [
Vec2::new(3.0, -2.0),
Vec2::new(-4.5, 1.25),
Vec2::new(7.0, -6.0),
] {
let logical = cam.world_to_screen(world);
let px = Vec2::new(
lb.x + logical.x * (lb.width / W as f32),
lb.y + logical.y * (lb.height / H as f32),
);
assert_close(cam.screen_to_world(px, &lb), world);
assert_close(world_to_window(world, &cam, &lb), px);
}
}
#[wasm_bindgen_test(unsupported = test)]
#[should_panic(expected = "pixels_per_unit")]
fn with_units_rejects_zero_ppu() {
let _ = Camera::new(W, H).with_units(WorldUnits {
pixels_per_unit: 0.0,
y_up: false,
});
}
#[wasm_bindgen_test(unsupported = test)]
#[should_panic(expected = "pixels_per_unit")]
fn with_units_rejects_infinite_ppu() {
let _ = Camera::new(W, H).with_units(WorldUnits {
pixels_per_unit: f32::INFINITY,
y_up: true,
});
}
}