use glam::Vec2;
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum ScaleMode {
#[default]
Fit,
IntegerFit,
Expand,
}
#[derive(Clone, Copy, Debug)]
pub struct Viewport {
pub origin: Vec2,
pub size: Vec2,
pub logical_size: Vec2,
pub scale: f32,
}
impl Viewport {
pub fn new(window: Vec2, reference: Vec2, mode: ScaleMode) -> Option<Self> {
if !window.is_finite()
|| !reference.is_finite()
|| window.min_element() <= 0.0
|| reference.min_element() <= 0.0
{
return None;
}
let fit = (window / reference).min_element();
let scale = match mode {
ScaleMode::Fit => fit,
ScaleMode::IntegerFit if fit >= 1.0 => fit.floor(),
ScaleMode::IntegerFit => fit,
ScaleMode::Expand => window.y / reference.y,
};
let logical_size = if mode == ScaleMode::Expand {
window / scale
} else {
reference
};
let size = logical_size * scale;
Some(Self {
origin: (window - size) * 0.5,
size,
logical_size,
scale,
})
}
pub fn aspect(&self) -> f32 {
self.logical_size.x / self.logical_size.y
}
pub fn screen_to_ui(&self, screen: Vec2) -> Option<Vec2> {
let local = screen - self.origin;
if !local.is_finite()
|| local.min_element() < 0.0
|| local.x >= self.size.x
|| local.y >= self.size.y
{
None
} else {
Some(local / self.scale)
}
}
pub fn ui_to_screen(&self, ui: Vec2) -> Vec2 {
self.origin + ui * self.scale
}
pub fn render_size(&self, dpi: Vec2) -> (u32, u32) {
let physical = self.size * dpi.max(Vec2::ONE);
let physical = physical * (8192.0 / physical.max_element()).min(1.0);
(
physical.x.round().clamp(1.0, 8192.0) as u32,
physical.y.round().clamp(1.0, 8192.0) as u32,
)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn ultrawide_fit_keeps_view_and_pointer_coordinates() {
let view = Viewport::new(
Vec2::new(2400.0, 900.0),
Vec2::new(960.0, 540.0),
ScaleMode::Fit,
)
.unwrap();
assert_eq!(view.origin, Vec2::new(400.0, 0.0));
assert_eq!(view.logical_size, Vec2::new(960.0, 540.0));
assert!(view.screen_to_ui(Vec2::new(100.0, 100.0)).is_none());
let ui = Vec2::new(300.0, 120.0);
assert!(
view.screen_to_ui(view.ui_to_screen(ui))
.unwrap()
.abs_diff_eq(ui, 0.001)
);
assert_eq!(view.render_size(Vec2::splat(2.0)), (3200, 1800));
}
#[test]
fn integer_scaling_fits_even_a_small_window() {
let reference = Vec2::new(320.0, 180.0);
let large =
Viewport::new(Vec2::new(1000.0, 700.0), reference, ScaleMode::IntegerFit).unwrap();
assert_eq!(large.scale, 3.0);
let small =
Viewport::new(Vec2::new(160.0, 90.0), reference, ScaleMode::IntegerFit).unwrap();
assert_eq!(small.scale, 0.5);
}
#[test]
fn expand_changes_only_visible_width() {
let view = Viewport::new(
Vec2::new(2000.0, 1000.0),
Vec2::new(960.0, 540.0),
ScaleMode::Expand,
)
.unwrap();
assert_eq!(view.logical_size, Vec2::new(1080.0, 540.0));
assert_eq!(view.origin, Vec2::ZERO);
}
#[test]
fn minimized_and_nonfinite_sizes_are_rejected() {
assert!(Viewport::new(Vec2::ZERO, Vec2::ONE, ScaleMode::Fit).is_none());
assert!(Viewport::new(Vec2::splat(f32::NAN), Vec2::ONE, ScaleMode::Fit).is_none());
}
#[test]
fn target_limit_preserves_camera_aspect_ratio() {
let view = Viewport::new(
Vec2::new(16000.0, 9000.0),
Vec2::new(960.0, 540.0),
ScaleMode::Fit,
)
.unwrap();
assert_eq!(view.render_size(Vec2::ONE), (8192, 4608));
}
}