use glam::{DMat3, DQuat, DVec3, Vec2, Vec3};
use viewport_lib_types::camera::{Pose, Projection};
use crate::CameraController;
use crate::Camera;
use crate::input::action_frame::ActionFrame;
use crate::input::context::ViewportContext;
use crate::input::event::ViewportEvent;
use crate::input::preset::planar_bindings;
use crate::input::viewport_binding::ViewportBinding;
use crate::input::viewport_input::ViewportInput;
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Default)]
#[non_exhaustive]
pub enum Plane2d {
#[default]
Xy,
Xz,
}
impl From<Plane2d> for viewport_lib_types::overlay::WorldPlane {
fn from(plane: Plane2d) -> Self {
match plane {
Plane2d::Xy => Self::Xy,
Plane2d::Xz => Self::Xz,
}
}
}
impl Plane2d {
pub fn x_axis(self) -> Vec3 {
Vec3::X
}
pub fn y_axis(self) -> Vec3 {
match self {
Plane2d::Xy => Vec3::Y,
Plane2d::Xz => Vec3::Z,
}
}
pub fn view_direction(self) -> Vec3 {
match self {
Plane2d::Xy => Vec3::NEG_Z,
Plane2d::Xz => Vec3::Y,
}
}
pub fn to_world(self, p: Vec2) -> DVec3 {
(self.x_axis() * p.x + self.y_axis() * p.y).as_dvec3()
}
pub fn from_world(self, p: DVec3) -> Vec2 {
match self {
Plane2d::Xy => Vec2::new(p.x as f32, p.y as f32),
Plane2d::Xz => Vec2::new(p.x as f32, p.z as f32),
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Default)]
pub struct Rect2d {
pub min: Vec2,
pub max: Vec2,
}
impl Rect2d {
pub fn new(a: Vec2, b: Vec2) -> Self {
Self {
min: a.min(b),
max: a.max(b),
}
}
pub fn from_centre_size(centre: Vec2, size: Vec2) -> Self {
let half = size.abs() * 0.5;
Self {
min: centre - half,
max: centre + half,
}
}
pub fn centre(&self) -> Vec2 {
(self.min + self.max) * 0.5
}
pub fn size(&self) -> Vec2 {
self.max - self.min
}
pub fn contains(&self, p: Vec2) -> bool {
p.cmpge(self.min).all() && p.cmple(self.max).all()
}
}
#[derive(Clone, Copy, Debug, Default)]
struct Shake {
amplitude: f32,
duration: f32,
elapsed: f32,
offset: Vec2,
}
impl Shake {
fn remaining_amplitude(&self) -> f32 {
if self.duration <= 0.0 || self.elapsed >= self.duration {
0.0
} else {
let left = 1.0 - self.elapsed / self.duration;
self.amplitude * left * left
}
}
}
#[derive(Clone, Debug)]
pub struct Camera2d {
pub plane: Plane2d,
pub distance: f32,
pub pixels_per_point: f32,
pub snap_to_pixels: bool,
pub snap_zoom_to_texel: Option<f32>,
pub depth_range: Option<[f32; 2]>,
pub min_units_per_pixel: f32,
pub max_units_per_pixel: f32,
pub follow_time_constant: f32,
pub dead_zone: Rect2d,
centre: Vec2,
units_per_pixel: f32,
rotation: f32,
viewport_size: Vec2,
bounds: Option<Rect2d>,
follow_target: Option<Vec2>,
shake: Shake,
rng: u32,
}
impl Default for Camera2d {
fn default() -> Self {
Self::new(Plane2d::default())
}
}
impl Camera2d {
pub const DEFAULT_DISTANCE: f32 = 100.0;
pub const DEFAULT_UNITS_PER_PIXEL: f32 = 0.01;
pub const DEFAULT_FOLLOW_TIME_CONSTANT: f32 = 0.25;
pub fn new(plane: Plane2d) -> Self {
Self {
plane,
distance: Self::DEFAULT_DISTANCE,
pixels_per_point: 1.0,
snap_to_pixels: false,
snap_zoom_to_texel: None,
depth_range: None,
min_units_per_pixel: 1.0e-6,
max_units_per_pixel: 1.0e6,
follow_time_constant: Self::DEFAULT_FOLLOW_TIME_CONSTANT,
dead_zone: Rect2d::default(),
centre: Vec2::ZERO,
units_per_pixel: Self::DEFAULT_UNITS_PER_PIXEL,
rotation: 0.0,
viewport_size: Vec2::ONE,
bounds: None,
follow_target: None,
shake: Shake::default(),
rng: 0x9E37_79B9,
}
}
pub fn with_centre(mut self, centre: Vec2) -> Self {
self.set_centre(centre);
self
}
pub fn with_units_per_pixel(mut self, units_per_pixel: f32) -> Self {
self.set_units_per_pixel(units_per_pixel);
self
}
pub fn with_viewport_size(mut self, size: Vec2) -> Self {
self.set_viewport_size(size);
self
}
pub fn with_rotation(mut self, rotation: f32) -> Self {
self.set_rotation(rotation);
self
}
pub fn with_bounds(mut self, bounds: Rect2d) -> Self {
self.set_bounds(Some(bounds));
self
}
pub fn centre(&self) -> Vec2 {
self.centre
}
pub fn set_centre(&mut self, centre: Vec2) {
self.centre = centre;
self.clamp_to_bounds();
}
pub fn units_per_pixel(&self) -> f32 {
self.units_per_pixel
}
pub fn drawn_units_per_pixel(&self) -> f32 {
match self.snap_zoom_to_texel {
Some(units_per_texel) if units_per_texel > 0.0 => {
integer_scale_zoom(units_per_texel, self.pixels_per_point, self.units_per_pixel).0
}
_ => self.units_per_pixel,
}
}
pub fn set_units_per_pixel(&mut self, units_per_pixel: f32) {
self.units_per_pixel = self.clamp_zoom(units_per_pixel);
self.clamp_to_bounds();
}
pub fn rotation(&self) -> f32 {
self.rotation
}
pub fn set_rotation(&mut self, rotation: f32) {
self.rotation = rotation;
self.clamp_to_bounds();
}
pub fn viewport_size(&self) -> Vec2 {
self.viewport_size
}
pub fn set_viewport_size(&mut self, size: Vec2) {
self.viewport_size = size.max(Vec2::ZERO);
self.clamp_to_bounds();
}
pub fn bounds(&self) -> Option<Rect2d> {
self.bounds
}
pub fn set_bounds(&mut self, bounds: Option<Rect2d>) {
self.bounds = bounds;
self.clamp_to_bounds();
}
fn screen_axes(&self) -> (Vec2, Vec2) {
let (s, c) = self.rotation.sin_cos();
(Vec2::new(c, s), Vec2::new(-s, c))
}
fn offset_to_plane(&self, offset: Vec2) -> Vec2 {
let (right, up) = self.screen_axes();
(right * offset.x - up * offset.y) * self.drawn_units_per_pixel()
}
fn plane_to_offset(&self, v: Vec2) -> Vec2 {
let (right, up) = self.screen_axes();
Vec2::new(v.dot(right), -v.dot(up)) / self.drawn_units_per_pixel()
}
pub fn screen_to_world(&self, screen: Vec2) -> Vec2 {
self.centre + self.offset_to_plane(screen - self.viewport_size * 0.5)
}
pub fn world_to_screen(&self, world: Vec2) -> Vec2 {
self.viewport_size * 0.5 + self.plane_to_offset(world - self.centre)
}
pub fn visible_rect(&self) -> Rect2d {
Rect2d {
min: self.centre - self.visible_half_extent(),
max: self.centre + self.visible_half_extent(),
}
}
fn visible_half_extent(&self) -> Vec2 {
let (right, up) = self.screen_axes();
let half = self.viewport_size * 0.5 * self.drawn_units_per_pixel();
right.abs() * half.x + up.abs() * half.y
}
fn clamp_zoom(&self, units_per_pixel: f32) -> f32 {
let lo = self.min_units_per_pixel.max(f32::MIN_POSITIVE);
let hi = self.max_units_per_pixel.max(lo);
if units_per_pixel.is_finite() {
units_per_pixel.clamp(lo, hi)
} else {
self.units_per_pixel
}
}
fn clamp_to_bounds(&mut self) {
let Some(bounds) = self.bounds else {
return;
};
let half = self.visible_half_extent();
let size = bounds.size();
for axis in 0..2 {
self.centre[axis] = if 2.0 * half[axis] >= size[axis] {
bounds.centre()[axis]
} else {
self.centre[axis]
.clamp(bounds.min[axis] + half[axis], bounds.max[axis] - half[axis])
};
}
}
pub fn pan(&mut self, delta_pixels: Vec2) {
if delta_pixels != Vec2::ZERO {
self.centre -= self.offset_to_plane(delta_pixels);
self.clamp_to_bounds();
}
}
pub fn zoom_at(&mut self, cursor_pixels: Vec2, factor: f32) {
if !(factor > 0.0) || factor == 1.0 {
return;
}
let anchor = self.screen_to_world(cursor_pixels);
self.units_per_pixel = self.clamp_zoom(self.units_per_pixel / factor);
self.centre = anchor - self.offset_to_plane(cursor_pixels - self.viewport_size * 0.5);
self.clamp_to_bounds();
}
pub fn snap_zoom_to_integer_scale(&mut self, units_per_texel: f32) -> u32 {
let (units_per_pixel, scale) =
integer_scale_zoom(units_per_texel, self.pixels_per_point, self.units_per_pixel);
self.set_units_per_pixel(units_per_pixel);
scale
}
pub fn follow(&mut self, target: Vec2) {
self.follow_target = Some(target);
}
pub fn stop_following(&mut self) {
self.follow_target = None;
}
pub fn follow_target(&self) -> Option<Vec2> {
self.follow_target
}
pub fn shake(&mut self, amplitude_pixels: f32, duration: f32) {
if amplitude_pixels <= 0.0 || duration <= 0.0 {
return;
}
if self.shake.remaining_amplitude() > amplitude_pixels {
return;
}
self.shake = Shake {
amplitude: amplitude_pixels,
duration,
elapsed: 0.0,
offset: Vec2::ZERO,
};
self.shake.offset = self.random_offset() * amplitude_pixels;
}
pub fn shake_offset(&self) -> Vec2 {
self.shake.offset
}
pub fn update(&mut self, dt: f32) {
let dt = dt.max(0.0);
if let Some(target) = self.follow_target {
let offset = self.plane_to_offset(target - self.centre);
let zone = Rect2d::new(self.dead_zone.min, self.dead_zone.max);
let excess = offset - offset.clamp(zone.min, zone.max);
if excess != Vec2::ZERO {
let k = if self.follow_time_constant > 0.0 {
1.0 - (-dt / self.follow_time_constant).exp()
} else {
1.0
};
self.centre += self.offset_to_plane(excess) * k;
self.clamp_to_bounds();
}
}
if self.shake.duration > 0.0 {
self.shake.elapsed += dt;
let amplitude = self.shake.remaining_amplitude();
if amplitude > 0.0 {
self.shake.offset = self.random_offset() * amplitude;
} else {
self.shake = Shake::default();
}
}
}
fn random_offset(&mut self) -> Vec2 {
let mut next = || {
let mut x = self.rng;
x ^= x << 13;
x ^= x >> 17;
x ^= x << 5;
self.rng = x;
(x >> 8) as f32 / (1u32 << 24) as f32 * 2.0 - 1.0
};
Vec2::new(next(), next())
}
pub fn apply_to(&self, camera: &mut Camera) {
let (right, up) = self.screen_axes();
let centre = self.centre + self.offset_to_plane(self.shake.offset);
let plane = self.plane;
let world_right = plane.x_axis() * right.x + plane.y_axis() * right.y;
let world_up = plane.x_axis() * up.x + plane.y_axis() * up.y;
let back = -plane.view_direction();
let basis = DMat3::from_cols(world_right.as_dvec3(), world_up.as_dvec3(), back.as_dvec3());
let orientation = DQuat::from_mat3(&basis).normalize();
let distance = self.distance.max(1e-3);
let eye = plane.to_world(centre) + back.as_dvec3() * f64::from(distance);
let height = self.viewport_size.y * self.drawn_units_per_pixel();
let (near, far) = match self.depth_range {
Some([near, far]) => (Some(near), Some(far)),
None => (None, None),
};
camera.set_pose(Pose::new(eye, orientation));
camera.projection = Projection::Orthographic { height, near, far };
camera.set_aspect_ratio(self.viewport_size.x, self.viewport_size.y);
camera.set_focus_distance(distance);
if self.snap_to_pixels {
snap_camera_to_pixels(camera, self.viewport_size, self.pixels_per_point);
}
}
pub fn camera(&self) -> Camera {
let mut camera = Camera::new(Pose::IDENTITY);
self.apply_to(&mut camera);
camera
}
}
fn integer_scale_zoom(
units_per_texel: f32,
pixels_per_point: f32,
units_per_pixel: f32,
) -> (f32, u32) {
let ppp = pixels_per_point.max(1e-3);
let device_per_texel = units_per_texel * ppp / units_per_pixel;
let scale = device_per_texel.round().max(1.0);
(units_per_texel * ppp / scale, scale as u32)
}
pub fn snap_camera_to_pixels(camera: &mut Camera, viewport_size: Vec2, pixels_per_point: f32) {
let Projection::Orthographic { height, .. } = camera.projection else {
return;
};
let ppp = pixels_per_point.max(1e-3);
let device = viewport_size.as_dvec2() * f64::from(ppp);
if !(height > 0.0) || !(device.y > 0.0) {
return;
}
let per_device = f64::from(height) / device.y;
let right = camera.pose.orientation * DVec3::X;
let up = camera.pose.orientation * DVec3::Y;
let eye = camera.pose.position;
let r = eye.dot(right) / per_device;
let u = eye.dot(up) / per_device;
let snapped_r = (r - device.x * 0.5).round() + device.x * 0.5;
let snapped_u = (u + device.y * 0.5).round() - device.y * 0.5;
camera.pose.position =
eye + right * ((snapped_r - r) * per_device) + up * ((snapped_u - u) * per_device);
}
pub struct Camera2dControl {
pub camera: Camera2d,
pub controller: Camera2dController,
}
impl Camera2dControl {
pub fn new(camera: Camera2d) -> Self {
Self {
camera,
controller: Camera2dController::new_stateless(),
}
}
}
impl CameraController for Camera2dControl {
fn apply(&mut self, camera: &mut Camera, frame: &ActionFrame, dt: f32) {
self.controller.apply(&mut self.camera, frame, dt);
self.camera.apply_to(camera);
}
fn set_viewport(&mut self, viewport_size: [f32; 2], pixels_per_point: f32) {
let size = Vec2::from(viewport_size);
if size != self.camera.viewport_size() {
self.camera.set_viewport_size(size);
}
self.camera.pixels_per_point = pixels_per_point;
}
fn as_any_mut(&mut self) -> Option<&mut dyn std::any::Any> {
Some(self)
}
}
pub struct Camera2dController {
input: ViewportInput,
pub pan_sensitivity: f32,
pub zoom_sensitivity: f32,
viewport_size: Vec2,
}
impl Default for Camera2dController {
fn default() -> Self {
Self::new()
}
}
impl Camera2dController {
pub const DEFAULT_ZOOM_SENSITIVITY: f32 = 0.002;
pub fn new() -> Self {
Self::from_bindings(planar_bindings())
}
pub fn from_bindings(bindings: Vec<ViewportBinding>) -> Self {
Self {
input: ViewportInput::new(bindings),
pan_sensitivity: 1.0,
zoom_sensitivity: Self::DEFAULT_ZOOM_SENSITIVITY,
viewport_size: Vec2::ZERO,
}
}
pub fn new_stateless() -> Self {
Self::from_bindings(Vec::new())
}
pub fn input_mut(&mut self) -> &mut ViewportInput {
&mut self.input
}
pub fn begin_frame(&mut self, ctx: ViewportContext) {
self.viewport_size = Vec2::from(ctx.viewport_size);
self.input.begin_frame(ctx);
}
pub fn begin_frame_at(&mut self, ctx: ViewportContext, time_seconds: f32) {
self.viewport_size = Vec2::from(ctx.viewport_size);
self.input.begin_frame_at(ctx, time_seconds);
}
pub fn push_event(&mut self, event: ViewportEvent) {
self.input.push_event(event);
}
pub fn resolve(&self) -> ActionFrame {
self.input.resolve()
}
pub fn apply_to_camera(&mut self, camera: &mut Camera2d, dt: f32) -> ActionFrame {
let frame = self.input.resolve();
if self.viewport_size != Vec2::ZERO && self.viewport_size != camera.viewport_size() {
camera.set_viewport_size(self.viewport_size);
}
self.apply(camera, &frame, dt);
frame
}
pub fn apply(&mut self, camera: &mut Camera2d, frame: &ActionFrame, dt: f32) {
let nav = &frame.navigation;
if nav.pan != Vec2::ZERO {
camera.pan(nav.pan * self.pan_sensitivity);
}
if nav.zoom != 0.0 {
let pointer = &frame.pointer;
let anchor = if pointer.contacts >= 2 {
pointer.touch_position.or(pointer.cursor)
} else {
pointer.cursor
}
.unwrap_or(camera.viewport_size() * 0.5);
camera.zoom_at(anchor, (nav.zoom * self.zoom_sensitivity).exp());
}
camera.update(dt);
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::input::binding::MouseButton;
use crate::input::context::InputOwnership;
use crate::input::event::{ButtonState, ScrollUnits};
const PLANES: [Plane2d; 2] = [Plane2d::Xy, Plane2d::Xz];
fn close(a: Vec2, b: Vec2, eps: f32) -> bool {
(a - b).abs().max_element() <= eps
}
fn cam(plane: Plane2d) -> Camera2d {
Camera2d::new(plane)
.with_viewport_size(Vec2::new(800.0, 600.0))
.with_units_per_pixel(0.05)
.with_centre(Vec2::new(3.0, -2.0))
}
fn project(c: &Camera2d, world: Vec2) -> Vec2 {
let camera = c.camera();
let ndc = camera
.view_proj_matrix()
.project_point3(c.plane.to_world(world).as_vec3());
let device = c.viewport_size() * c.pixels_per_point;
Vec2::new(
(ndc.x + 1.0) * 0.5 * device.x,
(1.0 - ndc.y) * 0.5 * device.y,
)
}
#[test]
fn zoom_at_cursor_keeps_the_point_under_it() {
for plane in PLANES {
for rotation in [0.0, 0.4] {
let mut c = cam(plane).with_rotation(rotation);
let cursor = Vec2::new(620.0, 140.0);
let before = c.screen_to_world(cursor);
c.zoom_at(cursor, 1.7);
assert!((c.units_per_pixel() - 0.05 / 1.7).abs() < 1e-7);
assert!(close(c.screen_to_world(cursor), before, 1e-4));
assert!(close(project(&c, before), cursor, 0.05), "{plane:?}");
c.zoom_at(cursor, 0.3);
assert!(close(c.screen_to_world(cursor), before, 1e-4));
}
}
}
#[test]
fn pan_moves_by_pixels_times_units_per_pixel() {
let mut c = cam(Plane2d::Xy);
let p = Vec2::new(1.0, 1.5);
let on_screen = c.world_to_screen(p);
c.pan(Vec2::new(10.0, -4.0));
assert!(close(c.centre(), Vec2::new(3.0 - 0.5, -2.0 - 0.2), 1e-5));
assert!(close(
c.world_to_screen(p),
on_screen + Vec2::new(10.0, -4.0),
1e-3
));
let mut r = cam(Plane2d::Xz).with_rotation(std::f32::consts::FRAC_PI_2);
r.pan(Vec2::new(10.0, 0.0));
assert!(close(r.centre(), Vec2::new(3.0, -2.0 - 0.5), 1e-5));
}
#[test]
fn follow_waits_for_the_dead_zone_then_converges() {
let mut c = Camera2d::new(Plane2d::Xy)
.with_viewport_size(Vec2::new(400.0, 300.0))
.with_units_per_pixel(0.1);
c.dead_zone = Rect2d::from_centre_size(Vec2::ZERO, Vec2::new(100.0, 100.0));
c.follow_time_constant = 0.5;
c.follow(Vec2::new(3.0, 4.0));
for _ in 0..30 {
c.update(1.0 / 60.0);
}
assert_eq!(c.centre(), Vec2::ZERO);
c.follow(Vec2::new(10.0, 0.0));
for _ in 0..10 {
c.update(0.05);
}
let left = 10.0 - 5.0 - c.centre().x;
let expected = 5.0 * (-1.0f32).exp();
assert!((left - expected).abs() < 1e-4, "{left} vs {expected}");
assert_eq!(c.centre().y, 0.0);
for _ in 0..200 {
c.update(0.05);
}
assert!(close(c.centre(), Vec2::new(5.0, 0.0), 1e-4));
}
#[test]
fn bounds_clamp_and_centre_on_small_bounds() {
let mut c = Camera2d::new(Plane2d::Xy)
.with_viewport_size(Vec2::new(200.0, 100.0))
.with_units_per_pixel(0.1)
.with_bounds(Rect2d::new(Vec2::ZERO, Vec2::new(100.0, 50.0)));
c.set_centre(Vec2::new(-50.0, 70.0));
assert!(close(c.centre(), Vec2::new(10.0, 45.0), 1e-5));
let v = c.visible_rect();
assert!(v.min.x >= -1e-5 && v.max.y <= 50.0 + 1e-5);
c.pan(Vec2::new(-1.0e5, 0.0));
assert!(close(c.centre(), Vec2::new(90.0, 45.0), 1e-4));
c.set_bounds(Some(Rect2d::new(Vec2::ZERO, Vec2::new(10.0, 50.0))));
assert!(close(c.centre(), Vec2::new(5.0, 45.0), 1e-5));
c.set_bounds(Some(Rect2d::new(Vec2::ZERO, Vec2::new(10.0, 5.0))));
assert!(close(c.centre(), Vec2::new(5.0, 2.5), 1e-5));
c.zoom_at(Vec2::new(10.0, 10.0), 0.5);
assert!(close(c.centre(), Vec2::new(5.0, 2.5), 1e-5));
}
#[test]
fn shake_decays_to_zero_and_leaves_the_centre() {
let mut c = cam(Plane2d::Xz);
let centre = c.centre();
let rest = c.camera().target();
c.shake(12.0, 0.5);
assert!(c.shake_offset() != Vec2::ZERO);
assert!(c.camera().target() != rest);
let mut t = 0.0f32;
let mut moved = false;
while t < 0.6 {
c.update(1.0 / 60.0);
t += 1.0 / 60.0;
let limit = if t < 0.5 {
12.0 * (1.0 - t / 0.5).powi(2) + 1e-4
} else {
0.0
};
assert!(c.shake_offset().abs().max_element() <= limit);
moved |= c.shake_offset() != Vec2::ZERO;
assert_eq!(c.centre(), centre);
}
assert!(moved);
assert_eq!(c.shake_offset(), Vec2::ZERO);
assert_eq!(c.camera().target(), rest);
}
#[test]
fn pixel_snapping_lands_on_whole_device_pixels() {
for (size, ppp) in [
(Vec2::new(201.0, 101.0), 1.0),
(Vec2::new(320.0, 180.0), 2.0),
] {
for plane in PLANES {
let mut c = Camera2d::new(plane)
.with_viewport_size(size)
.with_units_per_pixel(0.013)
.with_centre(Vec2::new(0.3337, -1.2345));
c.pixels_per_point = ppp;
let frac = |p: Vec2| (p - p.round()).abs().max_element();
assert!(
frac(project(&c, Vec2::ZERO)) > 0.01,
"unsnapped is off-grid"
);
c.snap_to_pixels = true;
let per_device = 0.013 / ppp;
for k in [0.0, 3.0, -7.0] {
let p = project(&c, Vec2::splat(k * per_device));
assert!(frac(p) < 2e-3, "{plane:?} {size} {ppp}: {p}");
}
}
}
}
#[test]
fn integer_zoom_snaps_to_a_whole_scale() {
let mut c = cam(Plane2d::Xy);
c.pixels_per_point = 2.0;
let scale = c.snap_zoom_to_integer_scale(1.0 / 16.0);
assert!(scale == 2 || scale == 3);
let device_per_texel = (1.0 / 16.0) * 2.0 / c.units_per_pixel();
assert!((device_per_texel - scale as f32).abs() < 1e-4);
assert!(close(c.centre(), Vec2::new(3.0, -2.0), 1e-6));
}
#[test]
fn screen_and_world_round_trip() {
for plane in PLANES {
let c = cam(plane).with_rotation(-1.1);
for p in [Vec2::ZERO, Vec2::new(12.5, -3.25), Vec2::new(-40.0, 17.0)] {
assert!(close(c.screen_to_world(c.world_to_screen(p)), p, 1e-4));
}
}
}
#[test]
fn projection_extent_matches_the_visible_rect() {
for plane in PLANES {
let c = cam(plane);
let camera = c.camera();
assert!(camera.is_orthographic());
let rect = c.visible_rect();
assert!(close(rect.size(), Vec2::new(40.0, 30.0), 1e-4));
let corner = |ndc: Vec2| {
let (origin, dir) = camera.screen_ray(ndc);
assert!((dir - plane.view_direction()).length() < 1e-5);
plane.from_world(origin.as_dvec3())
};
assert!(
close(corner(Vec2::new(-1.0, -1.0)), rect.min, 1e-3),
"{plane:?}"
);
assert!(
close(corner(Vec2::new(1.0, 1.0)), rect.max, 1e-3),
"{plane:?}"
);
let vp = camera.view_proj_matrix();
let ndc = |p: Vec2| {
let v = vp.project_point3(plane.to_world(p).as_vec3());
assert!(v.z > 0.0 && v.z < 1.0);
Vec2::new(v.x, v.y)
};
assert!(close(ndc(rect.min), Vec2::new(-1.0, -1.0), 1e-5));
assert!(close(ndc(rect.max), Vec2::new(1.0, 1.0), 1e-5));
assert!((camera.up() - plane.y_axis()).length() < 1e-6);
assert!((camera.right() - Vec3::X).length() < 1e-6);
}
}
#[test]
fn controller_drags_to_pan_and_wheels_about_the_cursor() {
let mut ctrl = Camera2dController::new();
let mut c = Camera2d::new(Plane2d::Xy).with_units_per_pixel(0.1);
let ctx = ViewportContext::new(InputOwnership::full_window(), [800.0, 600.0]);
ctrl.begin_frame(ctx);
ctrl.push_event(ViewportEvent::PointerMoved {
position: Vec2::new(100.0, 100.0),
});
ctrl.push_event(ViewportEvent::MouseButton {
button: MouseButton::Left,
state: ButtonState::Pressed,
});
ctrl.push_event(ViewportEvent::PointerMoved {
position: Vec2::new(130.0, 80.0),
});
let frame = ctrl.apply_to_camera(&mut c, 0.0);
assert_eq!(frame.navigation.orbit, Vec2::ZERO);
assert_eq!(c.viewport_size(), Vec2::new(800.0, 600.0));
assert!(close(c.centre(), Vec2::new(-3.0, -2.0), 1e-4));
ctrl.begin_frame(ctx);
ctrl.push_event(ViewportEvent::MouseButton {
button: MouseButton::Left,
state: ButtonState::Released,
});
let under = c.screen_to_world(Vec2::new(130.0, 80.0));
ctrl.push_event(ViewportEvent::Wheel {
delta: Vec2::new(0.0, 3.0),
units: ScrollUnits::Lines,
});
ctrl.apply_to_camera(&mut c, 0.0);
assert!(c.units_per_pixel() < 0.1);
assert!(close(
c.screen_to_world(Vec2::new(130.0, 80.0)),
under,
1e-4
));
}
fn project_camera(camera: &Camera, plane: Plane2d, world: Vec2, device: Vec2) -> Vec2 {
let ndc = camera
.view_proj_matrix()
.project_point3(plane.to_world(world).as_vec3());
Vec2::new(
(ndc.x + 1.0) * 0.5 * device.x,
(1.0 - ndc.y) * 0.5 * device.y,
)
}
#[test]
fn apply_to_writes_the_view_into_a_host_camera() {
for plane in PLANES {
let c = cam(plane).with_rotation(0.3);
let mut host = Camera::default();
host.exposure.aperture = 2.8;
c.apply_to(&mut host);
let built = c.camera();
assert_eq!(host.pose, built.pose);
assert_eq!(host.projection, built.projection);
assert_eq!(host.aspect, built.aspect);
assert_eq!(host.focus_distance(), built.focus_distance());
assert_eq!(host.exposure.aperture, 2.8);
}
}
#[test]
fn a_camera_applied_shaken_blended_and_snapped_lands_on_a_device_pixel() {
let size = Vec2::new(320.0, 180.0);
for (plane, ppp) in [(Plane2d::Xy, 1.0), (Plane2d::Xz, 2.0)] {
let mut c = Camera2d::new(plane)
.with_viewport_size(size)
.with_units_per_pixel(0.013)
.with_centre(Vec2::new(0.3337, -1.2345));
c.pixels_per_point = ppp;
let mut host = Camera::default();
c.apply_to(&mut host);
let shake = host.right().as_dvec3() * 0.0041 + host.up().as_dvec3() * -0.0077;
host.pose.position += shake;
let other = c.clone().with_centre(Vec2::new(2.71, 0.577)).camera();
let mut blended = Camera::lerp(&host, &other, 0.37);
let device = size * ppp;
let frac = |p: Vec2| (p - p.round()).abs().max_element();
let origin = project_camera(&blended, plane, Vec2::ZERO, device);
assert!(frac(origin) > 0.01, "the blend is off the grid");
snap_camera_to_pixels(&mut blended, size, ppp);
let per_device = 0.013 / ppp;
for k in [0.0, 5.0, -11.0] {
let p = project_camera(&blended, plane, Vec2::splat(k * per_device), device);
assert!(frac(p) < 2e-3, "{plane:?} {ppp}: {p}");
}
}
}
#[test]
fn snapping_the_written_camera_matches_snapping_it_afterwards() {
for plane in PLANES {
let mut c = cam(plane).with_rotation(0.7);
c.pixels_per_point = 2.0;
c.snap_to_pixels = true;
let snapped = c.camera();
c.snap_to_pixels = false;
let mut after = c.camera();
snap_camera_to_pixels(&mut after, c.viewport_size(), c.pixels_per_point);
assert!((snapped.eye() - after.eye()).length() < 1e-9);
}
}
#[test]
fn a_snapped_zoom_keeps_small_wheel_steps() {
let mut c = cam(Plane2d::Xy);
c.pixels_per_point = 2.0;
c.snap_zoom_to_texel = Some(1.0 / 16.0);
let drawn = c.drawn_units_per_pixel();
let scale = (1.0 / 16.0) * 2.0 / drawn;
assert!((scale - scale.round()).abs() < 1e-4);
assert_eq!(c.units_per_pixel(), 0.05);
let height = c.camera().view_height_at(1.0);
assert!((height - 600.0 * drawn).abs() < 1e-3);
let centre = c.viewport_size() * 0.5;
let start = scale.round();
let mut steps = 0;
while ((1.0 / 16.0) * 2.0 / c.drawn_units_per_pixel()).round() == start {
let before = c.units_per_pixel();
c.zoom_at(centre, 1.02);
assert!(c.units_per_pixel() < before);
steps += 1;
assert!(steps < 100, "the wheel never reached the next scale");
}
assert!(steps > 1);
}
#[test]
fn depth_range_sets_the_written_planes() {
let mut c = cam(Plane2d::Xy);
c.distance = 2000.0;
let auto = c.camera().depth_range();
assert_eq!(auto, (0.6, 6000.0));
c.depth_range = Some([100.0, 7000.0]);
let camera = c.camera();
assert_eq!(camera.depth_range(), (100.0, 7000.0));
let v = camera
.view_proj_matrix()
.project_point3(glam::Vec3::new(3.0, -2.0, -1500.0));
assert!(v.z > 0.0 && v.z < 1.0, "{v}");
}
#[test]
fn the_control_adapter_drives_a_host_camera() {
let mut control =
Camera2dControl::new(Camera2d::new(Plane2d::Xy).with_units_per_pixel(0.1));
CameraController::set_viewport(&mut control, [400.0, 300.0], 2.0);
assert_eq!(control.camera.viewport_size(), Vec2::new(400.0, 300.0));
assert_eq!(control.camera.pixels_per_point, 2.0);
let mut frame = ActionFrame::default();
frame.navigation.pan = Vec2::new(10.0, 0.0);
let mut host = Camera::default();
CameraController::apply(&mut control, &mut host, &frame, 0.0);
assert!(close(control.camera.centre(), Vec2::new(-1.0, 0.0), 1e-5));
assert_eq!(host.pose, control.camera.camera().pose);
assert!(control.as_any_mut().is_some());
}
#[test]
fn controller_ignores_a_drag_the_viewport_does_not_own() {
let mut ctrl = Camera2dController::new();
let mut c = Camera2d::new(Plane2d::Xy);
let ctx = ViewportContext::new(InputOwnership::default(), [800.0, 600.0]);
ctrl.begin_frame(ctx);
ctrl.push_event(ViewportEvent::PointerMoved {
position: Vec2::new(100.0, 100.0),
});
ctrl.push_event(ViewportEvent::MouseButton {
button: MouseButton::Left,
state: ButtonState::Pressed,
});
ctrl.push_event(ViewportEvent::PointerMoved {
position: Vec2::new(160.0, 100.0),
});
ctrl.apply_to_camera(&mut c, 0.0);
assert_eq!(c.centre(), Vec2::ZERO);
}
}