1use glam::{DMat3, DQuat, DVec3, Vec2, Vec3};
30use viewport_lib_types::camera::{Pose, Projection};
31
32use crate::CameraController;
33
34use crate::Camera;
35use crate::input::action_frame::ActionFrame;
36use crate::input::context::ViewportContext;
37use crate::input::event::ViewportEvent;
38use crate::input::preset::planar_bindings;
39use crate::input::viewport_binding::ViewportBinding;
40use crate::input::viewport_input::ViewportInput;
41
42#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Default)]
50#[non_exhaustive]
51pub enum Plane2d {
52 #[default]
55 Xy,
56 Xz,
60}
61
62impl From<Plane2d> for viewport_lib_types::overlay::WorldPlane {
63 fn from(plane: Plane2d) -> Self {
64 match plane {
65 Plane2d::Xy => Self::Xy,
66 Plane2d::Xz => Self::Xz,
67 }
68 }
69}
70
71impl Plane2d {
72 pub fn x_axis(self) -> Vec3 {
74 Vec3::X
75 }
76
77 pub fn y_axis(self) -> Vec3 {
79 match self {
80 Plane2d::Xy => Vec3::Y,
81 Plane2d::Xz => Vec3::Z,
82 }
83 }
84
85 pub fn view_direction(self) -> Vec3 {
87 match self {
88 Plane2d::Xy => Vec3::NEG_Z,
89 Plane2d::Xz => Vec3::Y,
90 }
91 }
92
93 pub fn to_world(self, p: Vec2) -> DVec3 {
95 (self.x_axis() * p.x + self.y_axis() * p.y).as_dvec3()
96 }
97
98 pub fn from_world(self, p: DVec3) -> Vec2 {
101 match self {
102 Plane2d::Xy => Vec2::new(p.x as f32, p.y as f32),
103 Plane2d::Xz => Vec2::new(p.x as f32, p.z as f32),
104 }
105 }
106}
107
108#[derive(Clone, Copy, Debug, PartialEq, Default)]
110pub struct Rect2d {
111 pub min: Vec2,
113 pub max: Vec2,
115}
116
117impl Rect2d {
118 pub fn new(a: Vec2, b: Vec2) -> Self {
120 Self {
121 min: a.min(b),
122 max: a.max(b),
123 }
124 }
125
126 pub fn from_centre_size(centre: Vec2, size: Vec2) -> Self {
128 let half = size.abs() * 0.5;
129 Self {
130 min: centre - half,
131 max: centre + half,
132 }
133 }
134
135 pub fn centre(&self) -> Vec2 {
137 (self.min + self.max) * 0.5
138 }
139
140 pub fn size(&self) -> Vec2 {
142 self.max - self.min
143 }
144
145 pub fn contains(&self, p: Vec2) -> bool {
147 p.cmpge(self.min).all() && p.cmple(self.max).all()
148 }
149}
150
151#[derive(Clone, Copy, Debug, Default)]
153struct Shake {
154 amplitude: f32,
155 duration: f32,
156 elapsed: f32,
157 offset: Vec2,
159}
160
161impl Shake {
162 fn remaining_amplitude(&self) -> f32 {
163 if self.duration <= 0.0 || self.elapsed >= self.duration {
164 0.0
165 } else {
166 let left = 1.0 - self.elapsed / self.duration;
167 self.amplitude * left * left
168 }
169 }
170}
171
172#[derive(Clone, Debug)]
197pub struct Camera2d {
198 pub plane: Plane2d,
200 pub distance: f32,
204 pub pixels_per_point: f32,
209 pub snap_to_pixels: bool,
215 pub snap_zoom_to_texel: Option<f32>,
221 pub depth_range: Option<[f32; 2]>,
228 pub min_units_per_pixel: f32,
230 pub max_units_per_pixel: f32,
232 pub follow_time_constant: f32,
236 pub dead_zone: Rect2d,
241 centre: Vec2,
242 units_per_pixel: f32,
243 rotation: f32,
244 viewport_size: Vec2,
245 bounds: Option<Rect2d>,
246 follow_target: Option<Vec2>,
247 shake: Shake,
248 rng: u32,
249}
250
251impl Default for Camera2d {
252 fn default() -> Self {
253 Self::new(Plane2d::default())
254 }
255}
256
257impl Camera2d {
258 pub const DEFAULT_DISTANCE: f32 = 100.0;
260 pub const DEFAULT_UNITS_PER_PIXEL: f32 = 0.01;
262 pub const DEFAULT_FOLLOW_TIME_CONSTANT: f32 = 0.25;
264
265 pub fn new(plane: Plane2d) -> Self {
269 Self {
270 plane,
271 distance: Self::DEFAULT_DISTANCE,
272 pixels_per_point: 1.0,
273 snap_to_pixels: false,
274 snap_zoom_to_texel: None,
275 depth_range: None,
276 min_units_per_pixel: 1.0e-6,
277 max_units_per_pixel: 1.0e6,
278 follow_time_constant: Self::DEFAULT_FOLLOW_TIME_CONSTANT,
279 dead_zone: Rect2d::default(),
280 centre: Vec2::ZERO,
281 units_per_pixel: Self::DEFAULT_UNITS_PER_PIXEL,
282 rotation: 0.0,
283 viewport_size: Vec2::ONE,
284 bounds: None,
285 follow_target: None,
286 shake: Shake::default(),
287 rng: 0x9E37_79B9,
288 }
289 }
290
291 pub fn with_centre(mut self, centre: Vec2) -> Self {
293 self.set_centre(centre);
294 self
295 }
296
297 pub fn with_units_per_pixel(mut self, units_per_pixel: f32) -> Self {
299 self.set_units_per_pixel(units_per_pixel);
300 self
301 }
302
303 pub fn with_viewport_size(mut self, size: Vec2) -> Self {
305 self.set_viewport_size(size);
306 self
307 }
308
309 pub fn with_rotation(mut self, rotation: f32) -> Self {
311 self.set_rotation(rotation);
312 self
313 }
314
315 pub fn with_bounds(mut self, bounds: Rect2d) -> Self {
318 self.set_bounds(Some(bounds));
319 self
320 }
321
322 pub fn centre(&self) -> Vec2 {
328 self.centre
329 }
330
331 pub fn set_centre(&mut self, centre: Vec2) {
333 self.centre = centre;
334 self.clamp_to_bounds();
335 }
336
337 pub fn units_per_pixel(&self) -> f32 {
341 self.units_per_pixel
342 }
343
344 pub fn drawn_units_per_pixel(&self) -> f32 {
348 match self.snap_zoom_to_texel {
349 Some(units_per_texel) if units_per_texel > 0.0 => {
350 integer_scale_zoom(units_per_texel, self.pixels_per_point, self.units_per_pixel).0
351 }
352 _ => self.units_per_pixel,
353 }
354 }
355
356 pub fn set_units_per_pixel(&mut self, units_per_pixel: f32) {
359 self.units_per_pixel = self.clamp_zoom(units_per_pixel);
360 self.clamp_to_bounds();
361 }
362
363 pub fn rotation(&self) -> f32 {
367 self.rotation
368 }
369
370 pub fn set_rotation(&mut self, rotation: f32) {
372 self.rotation = rotation;
373 self.clamp_to_bounds();
374 }
375
376 pub fn viewport_size(&self) -> Vec2 {
378 self.viewport_size
379 }
380
381 pub fn set_viewport_size(&mut self, size: Vec2) {
389 self.viewport_size = size.max(Vec2::ZERO);
390 self.clamp_to_bounds();
391 }
392
393 pub fn bounds(&self) -> Option<Rect2d> {
395 self.bounds
396 }
397
398 pub fn set_bounds(&mut self, bounds: Option<Rect2d>) {
403 self.bounds = bounds;
404 self.clamp_to_bounds();
405 }
406
407 fn screen_axes(&self) -> (Vec2, Vec2) {
409 let (s, c) = self.rotation.sin_cos();
410 (Vec2::new(c, s), Vec2::new(-s, c))
411 }
412
413 fn offset_to_plane(&self, offset: Vec2) -> Vec2 {
415 let (right, up) = self.screen_axes();
416 (right * offset.x - up * offset.y) * self.drawn_units_per_pixel()
417 }
418
419 fn plane_to_offset(&self, v: Vec2) -> Vec2 {
421 let (right, up) = self.screen_axes();
422 Vec2::new(v.dot(right), -v.dot(up)) / self.drawn_units_per_pixel()
423 }
424
425 pub fn screen_to_world(&self, screen: Vec2) -> Vec2 {
427 self.centre + self.offset_to_plane(screen - self.viewport_size * 0.5)
428 }
429
430 pub fn world_to_screen(&self, world: Vec2) -> Vec2 {
432 self.viewport_size * 0.5 + self.plane_to_offset(world - self.centre)
433 }
434
435 pub fn visible_rect(&self) -> Rect2d {
438 Rect2d {
439 min: self.centre - self.visible_half_extent(),
440 max: self.centre + self.visible_half_extent(),
441 }
442 }
443
444 fn visible_half_extent(&self) -> Vec2 {
445 let (right, up) = self.screen_axes();
446 let half = self.viewport_size * 0.5 * self.drawn_units_per_pixel();
447 right.abs() * half.x + up.abs() * half.y
448 }
449
450 fn clamp_zoom(&self, units_per_pixel: f32) -> f32 {
451 let lo = self.min_units_per_pixel.max(f32::MIN_POSITIVE);
452 let hi = self.max_units_per_pixel.max(lo);
453 if units_per_pixel.is_finite() {
454 units_per_pixel.clamp(lo, hi)
455 } else {
456 self.units_per_pixel
457 }
458 }
459
460 fn clamp_to_bounds(&mut self) {
461 let Some(bounds) = self.bounds else {
462 return;
463 };
464 let half = self.visible_half_extent();
465 let size = bounds.size();
466 for axis in 0..2 {
467 self.centre[axis] = if 2.0 * half[axis] >= size[axis] {
468 bounds.centre()[axis]
469 } else {
470 self.centre[axis]
471 .clamp(bounds.min[axis] + half[axis], bounds.max[axis] - half[axis])
472 };
473 }
474 }
475
476 pub fn pan(&mut self, delta_pixels: Vec2) {
484 if delta_pixels != Vec2::ZERO {
485 self.centre -= self.offset_to_plane(delta_pixels);
486 self.clamp_to_bounds();
487 }
488 }
489
490 pub fn zoom_at(&mut self, cursor_pixels: Vec2, factor: f32) {
496 if !(factor > 0.0) || factor == 1.0 {
497 return;
498 }
499 let anchor = self.screen_to_world(cursor_pixels);
500 self.units_per_pixel = self.clamp_zoom(self.units_per_pixel / factor);
501 self.centre = anchor - self.offset_to_plane(cursor_pixels - self.viewport_size * 0.5);
502 self.clamp_to_bounds();
503 }
504
505 pub fn snap_zoom_to_integer_scale(&mut self, units_per_texel: f32) -> u32 {
515 let (units_per_pixel, scale) =
516 integer_scale_zoom(units_per_texel, self.pixels_per_point, self.units_per_pixel);
517 self.set_units_per_pixel(units_per_pixel);
518 scale
519 }
520
521 pub fn follow(&mut self, target: Vec2) {
529 self.follow_target = Some(target);
530 }
531
532 pub fn stop_following(&mut self) {
534 self.follow_target = None;
535 }
536
537 pub fn follow_target(&self) -> Option<Vec2> {
539 self.follow_target
540 }
541
542 pub fn shake(&mut self, amplitude_pixels: f32, duration: f32) {
547 if amplitude_pixels <= 0.0 || duration <= 0.0 {
548 return;
549 }
550 if self.shake.remaining_amplitude() > amplitude_pixels {
551 return;
552 }
553 self.shake = Shake {
554 amplitude: amplitude_pixels,
555 duration,
556 elapsed: 0.0,
557 offset: Vec2::ZERO,
558 };
559 self.shake.offset = self.random_offset() * amplitude_pixels;
560 }
561
562 pub fn shake_offset(&self) -> Vec2 {
564 self.shake.offset
565 }
566
567 pub fn update(&mut self, dt: f32) {
569 let dt = dt.max(0.0);
570 if let Some(target) = self.follow_target {
571 let offset = self.plane_to_offset(target - self.centre);
572 let zone = Rect2d::new(self.dead_zone.min, self.dead_zone.max);
573 let excess = offset - offset.clamp(zone.min, zone.max);
574 if excess != Vec2::ZERO {
575 let k = if self.follow_time_constant > 0.0 {
576 1.0 - (-dt / self.follow_time_constant).exp()
577 } else {
578 1.0
579 };
580 self.centre += self.offset_to_plane(excess) * k;
581 self.clamp_to_bounds();
582 }
583 }
584 if self.shake.duration > 0.0 {
585 self.shake.elapsed += dt;
586 let amplitude = self.shake.remaining_amplitude();
587 if amplitude > 0.0 {
588 self.shake.offset = self.random_offset() * amplitude;
589 } else {
590 self.shake = Shake::default();
591 }
592 }
593 }
594
595 fn random_offset(&mut self) -> Vec2 {
598 let mut next = || {
599 let mut x = self.rng;
600 x ^= x << 13;
601 x ^= x >> 17;
602 x ^= x << 5;
603 self.rng = x;
604 (x >> 8) as f32 / (1u32 << 24) as f32 * 2.0 - 1.0
605 };
606 Vec2::new(next(), next())
607 }
608
609 pub fn apply_to(&self, camera: &mut Camera) {
630 let (right, up) = self.screen_axes();
631 let centre = self.centre + self.offset_to_plane(self.shake.offset);
632
633 let plane = self.plane;
634 let world_right = plane.x_axis() * right.x + plane.y_axis() * right.y;
635 let world_up = plane.x_axis() * up.x + plane.y_axis() * up.y;
636 let back = -plane.view_direction();
637 let basis = DMat3::from_cols(world_right.as_dvec3(), world_up.as_dvec3(), back.as_dvec3());
638 let orientation = DQuat::from_mat3(&basis).normalize();
639 let distance = self.distance.max(1e-3);
640 let eye = plane.to_world(centre) + back.as_dvec3() * f64::from(distance);
641
642 let height = self.viewport_size.y * self.drawn_units_per_pixel();
643 let (near, far) = match self.depth_range {
644 Some([near, far]) => (Some(near), Some(far)),
645 None => (None, None),
646 };
647 camera.set_pose(Pose::new(eye, orientation));
648 camera.projection = Projection::Orthographic { height, near, far };
649 camera.set_aspect_ratio(self.viewport_size.x, self.viewport_size.y);
650 camera.set_focus_distance(distance);
651 if self.snap_to_pixels {
652 snap_camera_to_pixels(camera, self.viewport_size, self.pixels_per_point);
653 }
654 }
655
656 pub fn camera(&self) -> Camera {
659 let mut camera = Camera::new(Pose::IDENTITY);
660 self.apply_to(&mut camera);
661 camera
662 }
663}
664
665fn integer_scale_zoom(
669 units_per_texel: f32,
670 pixels_per_point: f32,
671 units_per_pixel: f32,
672) -> (f32, u32) {
673 let ppp = pixels_per_point.max(1e-3);
674 let device_per_texel = units_per_texel * ppp / units_per_pixel;
675 let scale = device_per_texel.round().max(1.0);
676 (units_per_texel * ppp / scale, scale as u32)
677}
678
679pub fn snap_camera_to_pixels(camera: &mut Camera, viewport_size: Vec2, pixels_per_point: f32) {
689 let Projection::Orthographic { height, .. } = camera.projection else {
690 return;
691 };
692 let ppp = pixels_per_point.max(1e-3);
693 let device = viewport_size.as_dvec2() * f64::from(ppp);
694 if !(height > 0.0) || !(device.y > 0.0) {
695 return;
696 }
697 let per_device = f64::from(height) / device.y;
698 let right = camera.pose.orientation * DVec3::X;
699 let up = camera.pose.orientation * DVec3::Y;
700 let eye = camera.pose.position;
701 let r = eye.dot(right) / per_device;
704 let u = eye.dot(up) / per_device;
705 let snapped_r = (r - device.x * 0.5).round() + device.x * 0.5;
706 let snapped_u = (u + device.y * 0.5).round() - device.y * 0.5;
707 camera.pose.position =
708 eye + right * ((snapped_r - r) * per_device) + up * ((snapped_u - u) * per_device);
709}
710
711pub struct Camera2dControl {
722 pub camera: Camera2d,
724 pub controller: Camera2dController,
726}
727
728impl Camera2dControl {
729 pub fn new(camera: Camera2d) -> Self {
731 Self {
732 camera,
733 controller: Camera2dController::new_stateless(),
734 }
735 }
736}
737
738impl CameraController for Camera2dControl {
739 fn apply(&mut self, camera: &mut Camera, frame: &ActionFrame, dt: f32) {
740 self.controller.apply(&mut self.camera, frame, dt);
741 self.camera.apply_to(camera);
742 }
743
744 fn set_viewport(&mut self, viewport_size: [f32; 2], pixels_per_point: f32) {
745 let size = Vec2::from(viewport_size);
746 if size != self.camera.viewport_size() {
747 self.camera.set_viewport_size(size);
748 }
749 self.camera.pixels_per_point = pixels_per_point;
750 }
751
752 fn as_any_mut(&mut self) -> Option<&mut dyn std::any::Any> {
753 Some(self)
754 }
755}
756
757pub struct Camera2dController {
783 input: ViewportInput,
784 pub pan_sensitivity: f32,
787 pub zoom_sensitivity: f32,
791 viewport_size: Vec2,
792}
793
794impl Default for Camera2dController {
795 fn default() -> Self {
796 Self::new()
797 }
798}
799
800impl Camera2dController {
801 pub const DEFAULT_ZOOM_SENSITIVITY: f32 = 0.002;
803
804 pub fn new() -> Self {
806 Self::from_bindings(planar_bindings())
807 }
808
809 pub fn from_bindings(bindings: Vec<ViewportBinding>) -> Self {
811 Self {
812 input: ViewportInput::new(bindings),
813 pan_sensitivity: 1.0,
814 zoom_sensitivity: Self::DEFAULT_ZOOM_SENSITIVITY,
815 viewport_size: Vec2::ZERO,
816 }
817 }
818
819 pub fn new_stateless() -> Self {
822 Self::from_bindings(Vec::new())
823 }
824
825 pub fn input_mut(&mut self) -> &mut ViewportInput {
828 &mut self.input
829 }
830
831 pub fn begin_frame(&mut self, ctx: ViewportContext) {
834 self.viewport_size = Vec2::from(ctx.viewport_size);
835 self.input.begin_frame(ctx);
836 }
837
838 pub fn begin_frame_at(&mut self, ctx: ViewportContext, time_seconds: f32) {
841 self.viewport_size = Vec2::from(ctx.viewport_size);
842 self.input.begin_frame_at(ctx, time_seconds);
843 }
844
845 pub fn push_event(&mut self, event: ViewportEvent) {
848 self.input.push_event(event);
849 }
850
851 pub fn resolve(&self) -> ActionFrame {
853 self.input.resolve()
854 }
855
856 pub fn apply_to_camera(&mut self, camera: &mut Camera2d, dt: f32) -> ActionFrame {
860 let frame = self.input.resolve();
861 if self.viewport_size != Vec2::ZERO && self.viewport_size != camera.viewport_size() {
862 camera.set_viewport_size(self.viewport_size);
863 }
864 self.apply(camera, &frame, dt);
865 frame
866 }
867
868 pub fn apply(&mut self, camera: &mut Camera2d, frame: &ActionFrame, dt: f32) {
874 let nav = &frame.navigation;
875 if nav.pan != Vec2::ZERO {
876 camera.pan(nav.pan * self.pan_sensitivity);
877 }
878 if nav.zoom != 0.0 {
879 let pointer = &frame.pointer;
880 let anchor = if pointer.contacts >= 2 {
881 pointer.touch_position.or(pointer.cursor)
882 } else {
883 pointer.cursor
884 }
885 .unwrap_or(camera.viewport_size() * 0.5);
886 camera.zoom_at(anchor, (nav.zoom * self.zoom_sensitivity).exp());
887 }
888 camera.update(dt);
889 }
890}
891
892#[cfg(test)]
893mod tests {
894 use super::*;
895 use crate::input::binding::MouseButton;
896 use crate::input::context::InputOwnership;
897 use crate::input::event::{ButtonState, ScrollUnits};
898
899 const PLANES: [Plane2d; 2] = [Plane2d::Xy, Plane2d::Xz];
900
901 fn close(a: Vec2, b: Vec2, eps: f32) -> bool {
902 (a - b).abs().max_element() <= eps
903 }
904
905 fn cam(plane: Plane2d) -> Camera2d {
906 Camera2d::new(plane)
907 .with_viewport_size(Vec2::new(800.0, 600.0))
908 .with_units_per_pixel(0.05)
909 .with_centre(Vec2::new(3.0, -2.0))
910 }
911
912 fn project(c: &Camera2d, world: Vec2) -> Vec2 {
915 let camera = c.camera();
916 let ndc = camera
917 .view_proj_matrix()
918 .project_point3(c.plane.to_world(world).as_vec3());
919 let device = c.viewport_size() * c.pixels_per_point;
920 Vec2::new(
921 (ndc.x + 1.0) * 0.5 * device.x,
922 (1.0 - ndc.y) * 0.5 * device.y,
923 )
924 }
925
926 #[test]
927 fn zoom_at_cursor_keeps_the_point_under_it() {
928 for plane in PLANES {
929 for rotation in [0.0, 0.4] {
930 let mut c = cam(plane).with_rotation(rotation);
931 let cursor = Vec2::new(620.0, 140.0);
932 let before = c.screen_to_world(cursor);
933 c.zoom_at(cursor, 1.7);
934 assert!((c.units_per_pixel() - 0.05 / 1.7).abs() < 1e-7);
935 assert!(close(c.screen_to_world(cursor), before, 1e-4));
936 assert!(close(project(&c, before), cursor, 0.05), "{plane:?}");
937 c.zoom_at(cursor, 0.3);
938 assert!(close(c.screen_to_world(cursor), before, 1e-4));
939 }
940 }
941 }
942
943 #[test]
944 fn pan_moves_by_pixels_times_units_per_pixel() {
945 let mut c = cam(Plane2d::Xy);
946 let p = Vec2::new(1.0, 1.5);
947 let on_screen = c.world_to_screen(p);
948 c.pan(Vec2::new(10.0, -4.0));
949 assert!(close(c.centre(), Vec2::new(3.0 - 0.5, -2.0 - 0.2), 1e-5));
951 assert!(close(
952 c.world_to_screen(p),
953 on_screen + Vec2::new(10.0, -4.0),
954 1e-3
955 ));
956 let mut r = cam(Plane2d::Xz).with_rotation(std::f32::consts::FRAC_PI_2);
958 r.pan(Vec2::new(10.0, 0.0));
959 assert!(close(r.centre(), Vec2::new(3.0, -2.0 - 0.5), 1e-5));
960 }
961
962 #[test]
963 fn follow_waits_for_the_dead_zone_then_converges() {
964 let mut c = Camera2d::new(Plane2d::Xy)
965 .with_viewport_size(Vec2::new(400.0, 300.0))
966 .with_units_per_pixel(0.1);
967 c.dead_zone = Rect2d::from_centre_size(Vec2::ZERO, Vec2::new(100.0, 100.0));
968 c.follow_time_constant = 0.5;
969
970 c.follow(Vec2::new(3.0, 4.0));
972 for _ in 0..30 {
973 c.update(1.0 / 60.0);
974 }
975 assert_eq!(c.centre(), Vec2::ZERO);
976
977 c.follow(Vec2::new(10.0, 0.0));
979 for _ in 0..10 {
980 c.update(0.05);
981 }
982 let left = 10.0 - 5.0 - c.centre().x;
983 let expected = 5.0 * (-1.0f32).exp();
984 assert!((left - expected).abs() < 1e-4, "{left} vs {expected}");
985 assert_eq!(c.centre().y, 0.0);
986
987 for _ in 0..200 {
988 c.update(0.05);
989 }
990 assert!(close(c.centre(), Vec2::new(5.0, 0.0), 1e-4));
992 }
993
994 #[test]
995 fn bounds_clamp_and_centre_on_small_bounds() {
996 let mut c = Camera2d::new(Plane2d::Xy)
998 .with_viewport_size(Vec2::new(200.0, 100.0))
999 .with_units_per_pixel(0.1)
1000 .with_bounds(Rect2d::new(Vec2::ZERO, Vec2::new(100.0, 50.0)));
1001 c.set_centre(Vec2::new(-50.0, 70.0));
1002 assert!(close(c.centre(), Vec2::new(10.0, 45.0), 1e-5));
1003 let v = c.visible_rect();
1004 assert!(v.min.x >= -1e-5 && v.max.y <= 50.0 + 1e-5);
1005 c.pan(Vec2::new(-1.0e5, 0.0));
1006 assert!(close(c.centre(), Vec2::new(90.0, 45.0), 1e-4));
1007
1008 c.set_bounds(Some(Rect2d::new(Vec2::ZERO, Vec2::new(10.0, 50.0))));
1010 assert!(close(c.centre(), Vec2::new(5.0, 45.0), 1e-5));
1011
1012 c.set_bounds(Some(Rect2d::new(Vec2::ZERO, Vec2::new(10.0, 5.0))));
1014 assert!(close(c.centre(), Vec2::new(5.0, 2.5), 1e-5));
1015 c.zoom_at(Vec2::new(10.0, 10.0), 0.5);
1016 assert!(close(c.centre(), Vec2::new(5.0, 2.5), 1e-5));
1017 }
1018
1019 #[test]
1020 fn shake_decays_to_zero_and_leaves_the_centre() {
1021 let mut c = cam(Plane2d::Xz);
1022 let centre = c.centre();
1023 let rest = c.camera().target();
1024 c.shake(12.0, 0.5);
1025 assert!(c.shake_offset() != Vec2::ZERO);
1026 assert!(c.camera().target() != rest);
1027 let mut t = 0.0f32;
1028 let mut moved = false;
1029 while t < 0.6 {
1030 c.update(1.0 / 60.0);
1031 t += 1.0 / 60.0;
1032 let limit = if t < 0.5 {
1033 12.0 * (1.0 - t / 0.5).powi(2) + 1e-4
1034 } else {
1035 0.0
1036 };
1037 assert!(c.shake_offset().abs().max_element() <= limit);
1038 moved |= c.shake_offset() != Vec2::ZERO;
1039 assert_eq!(c.centre(), centre);
1040 }
1041 assert!(moved);
1042 assert_eq!(c.shake_offset(), Vec2::ZERO);
1043 assert_eq!(c.camera().target(), rest);
1044 }
1045
1046 #[test]
1047 fn pixel_snapping_lands_on_whole_device_pixels() {
1048 for (size, ppp) in [
1049 (Vec2::new(201.0, 101.0), 1.0),
1050 (Vec2::new(320.0, 180.0), 2.0),
1051 ] {
1052 for plane in PLANES {
1053 let mut c = Camera2d::new(plane)
1054 .with_viewport_size(size)
1055 .with_units_per_pixel(0.013)
1056 .with_centre(Vec2::new(0.3337, -1.2345));
1057 c.pixels_per_point = ppp;
1058 let frac = |p: Vec2| (p - p.round()).abs().max_element();
1059 assert!(
1060 frac(project(&c, Vec2::ZERO)) > 0.01,
1061 "unsnapped is off-grid"
1062 );
1063 c.snap_to_pixels = true;
1064 let per_device = 0.013 / ppp;
1065 for k in [0.0, 3.0, -7.0] {
1066 let p = project(&c, Vec2::splat(k * per_device));
1067 assert!(frac(p) < 2e-3, "{plane:?} {size} {ppp}: {p}");
1068 }
1069 }
1070 }
1071 }
1072
1073 #[test]
1074 fn integer_zoom_snaps_to_a_whole_scale() {
1075 let mut c = cam(Plane2d::Xy);
1076 c.pixels_per_point = 2.0;
1077 let scale = c.snap_zoom_to_integer_scale(1.0 / 16.0);
1079 assert!(scale == 2 || scale == 3);
1080 let device_per_texel = (1.0 / 16.0) * 2.0 / c.units_per_pixel();
1081 assert!((device_per_texel - scale as f32).abs() < 1e-4);
1082 assert!(close(c.centre(), Vec2::new(3.0, -2.0), 1e-6));
1083 }
1084
1085 #[test]
1086 fn screen_and_world_round_trip() {
1087 for plane in PLANES {
1088 let c = cam(plane).with_rotation(-1.1);
1089 for p in [Vec2::ZERO, Vec2::new(12.5, -3.25), Vec2::new(-40.0, 17.0)] {
1090 assert!(close(c.screen_to_world(c.world_to_screen(p)), p, 1e-4));
1091 }
1092 }
1093 }
1094
1095 #[test]
1096 fn projection_extent_matches_the_visible_rect() {
1097 for plane in PLANES {
1098 let c = cam(plane);
1099 let camera = c.camera();
1100 assert!(camera.is_orthographic());
1101 let rect = c.visible_rect();
1102 assert!(close(rect.size(), Vec2::new(40.0, 30.0), 1e-4));
1103
1104 let corner = |ndc: Vec2| {
1106 let (origin, dir) = camera.screen_ray(ndc);
1107 assert!((dir - plane.view_direction()).length() < 1e-5);
1108 plane.from_world(origin.as_dvec3())
1109 };
1110 assert!(
1111 close(corner(Vec2::new(-1.0, -1.0)), rect.min, 1e-3),
1112 "{plane:?}"
1113 );
1114 assert!(
1115 close(corner(Vec2::new(1.0, 1.0)), rect.max, 1e-3),
1116 "{plane:?}"
1117 );
1118
1119 let vp = camera.view_proj_matrix();
1121 let ndc = |p: Vec2| {
1122 let v = vp.project_point3(plane.to_world(p).as_vec3());
1123 assert!(v.z > 0.0 && v.z < 1.0);
1124 Vec2::new(v.x, v.y)
1125 };
1126 assert!(close(ndc(rect.min), Vec2::new(-1.0, -1.0), 1e-5));
1127 assert!(close(ndc(rect.max), Vec2::new(1.0, 1.0), 1e-5));
1128 assert!((camera.up() - plane.y_axis()).length() < 1e-6);
1130 assert!((camera.right() - Vec3::X).length() < 1e-6);
1131 }
1132 }
1133
1134 #[test]
1135 fn controller_drags_to_pan_and_wheels_about_the_cursor() {
1136 let mut ctrl = Camera2dController::new();
1137 let mut c = Camera2d::new(Plane2d::Xy).with_units_per_pixel(0.1);
1138 let ctx = ViewportContext::new(InputOwnership::full_window(), [800.0, 600.0]);
1139
1140 ctrl.begin_frame(ctx);
1141 ctrl.push_event(ViewportEvent::PointerMoved {
1142 position: Vec2::new(100.0, 100.0),
1143 });
1144 ctrl.push_event(ViewportEvent::MouseButton {
1145 button: MouseButton::Left,
1146 state: ButtonState::Pressed,
1147 });
1148 ctrl.push_event(ViewportEvent::PointerMoved {
1149 position: Vec2::new(130.0, 80.0),
1150 });
1151 let frame = ctrl.apply_to_camera(&mut c, 0.0);
1152 assert_eq!(frame.navigation.orbit, Vec2::ZERO);
1153 assert_eq!(c.viewport_size(), Vec2::new(800.0, 600.0));
1154 assert!(close(c.centre(), Vec2::new(-3.0, -2.0), 1e-4));
1155
1156 ctrl.begin_frame(ctx);
1157 ctrl.push_event(ViewportEvent::MouseButton {
1158 button: MouseButton::Left,
1159 state: ButtonState::Released,
1160 });
1161 let under = c.screen_to_world(Vec2::new(130.0, 80.0));
1162 ctrl.push_event(ViewportEvent::Wheel {
1163 delta: Vec2::new(0.0, 3.0),
1164 units: ScrollUnits::Lines,
1165 });
1166 ctrl.apply_to_camera(&mut c, 0.0);
1167 assert!(c.units_per_pixel() < 0.1);
1168 assert!(close(
1169 c.screen_to_world(Vec2::new(130.0, 80.0)),
1170 under,
1171 1e-4
1172 ));
1173 }
1174
1175 fn project_camera(camera: &Camera, plane: Plane2d, world: Vec2, device: Vec2) -> Vec2 {
1177 let ndc = camera
1178 .view_proj_matrix()
1179 .project_point3(plane.to_world(world).as_vec3());
1180 Vec2::new(
1181 (ndc.x + 1.0) * 0.5 * device.x,
1182 (1.0 - ndc.y) * 0.5 * device.y,
1183 )
1184 }
1185
1186 #[test]
1187 fn apply_to_writes_the_view_into_a_host_camera() {
1188 for plane in PLANES {
1189 let c = cam(plane).with_rotation(0.3);
1190 let mut host = Camera::default();
1191 host.exposure.aperture = 2.8;
1192 c.apply_to(&mut host);
1193 let built = c.camera();
1194 assert_eq!(host.pose, built.pose);
1195 assert_eq!(host.projection, built.projection);
1196 assert_eq!(host.aspect, built.aspect);
1197 assert_eq!(host.focus_distance(), built.focus_distance());
1198 assert_eq!(host.exposure.aperture, 2.8);
1200 }
1201 }
1202
1203 #[test]
1204 fn a_camera_applied_shaken_blended_and_snapped_lands_on_a_device_pixel() {
1205 let size = Vec2::new(320.0, 180.0);
1206 for (plane, ppp) in [(Plane2d::Xy, 1.0), (Plane2d::Xz, 2.0)] {
1207 let mut c = Camera2d::new(plane)
1208 .with_viewport_size(size)
1209 .with_units_per_pixel(0.013)
1210 .with_centre(Vec2::new(0.3337, -1.2345));
1211 c.pixels_per_point = ppp;
1212 let mut host = Camera::default();
1213 c.apply_to(&mut host);
1214
1215 let shake = host.right().as_dvec3() * 0.0041 + host.up().as_dvec3() * -0.0077;
1218 host.pose.position += shake;
1219 let other = c.clone().with_centre(Vec2::new(2.71, 0.577)).camera();
1220 let mut blended = Camera::lerp(&host, &other, 0.37);
1221
1222 let device = size * ppp;
1223 let frac = |p: Vec2| (p - p.round()).abs().max_element();
1224 let origin = project_camera(&blended, plane, Vec2::ZERO, device);
1225 assert!(frac(origin) > 0.01, "the blend is off the grid");
1226
1227 snap_camera_to_pixels(&mut blended, size, ppp);
1228 let per_device = 0.013 / ppp;
1229 for k in [0.0, 5.0, -11.0] {
1230 let p = project_camera(&blended, plane, Vec2::splat(k * per_device), device);
1231 assert!(frac(p) < 2e-3, "{plane:?} {ppp}: {p}");
1232 }
1233 }
1234 }
1235
1236 #[test]
1237 fn snapping_the_written_camera_matches_snapping_it_afterwards() {
1238 for plane in PLANES {
1239 let mut c = cam(plane).with_rotation(0.7);
1240 c.pixels_per_point = 2.0;
1241 c.snap_to_pixels = true;
1242 let snapped = c.camera();
1243 c.snap_to_pixels = false;
1244 let mut after = c.camera();
1245 snap_camera_to_pixels(&mut after, c.viewport_size(), c.pixels_per_point);
1246 assert!((snapped.eye() - after.eye()).length() < 1e-9);
1247 }
1248 }
1249
1250 #[test]
1251 fn a_snapped_zoom_keeps_small_wheel_steps() {
1252 let mut c = cam(Plane2d::Xy);
1253 c.pixels_per_point = 2.0;
1254 c.snap_zoom_to_texel = Some(1.0 / 16.0);
1255 let drawn = c.drawn_units_per_pixel();
1257 let scale = (1.0 / 16.0) * 2.0 / drawn;
1258 assert!((scale - scale.round()).abs() < 1e-4);
1259 assert_eq!(c.units_per_pixel(), 0.05);
1260 let height = c.camera().view_height_at(1.0);
1261 assert!((height - 600.0 * drawn).abs() < 1e-3);
1262
1263 let centre = c.viewport_size() * 0.5;
1266 let start = scale.round();
1267 let mut steps = 0;
1268 while ((1.0 / 16.0) * 2.0 / c.drawn_units_per_pixel()).round() == start {
1269 let before = c.units_per_pixel();
1270 c.zoom_at(centre, 1.02);
1271 assert!(c.units_per_pixel() < before);
1272 steps += 1;
1273 assert!(steps < 100, "the wheel never reached the next scale");
1274 }
1275 assert!(steps > 1);
1276 }
1277
1278 #[test]
1279 fn depth_range_sets_the_written_planes() {
1280 let mut c = cam(Plane2d::Xy);
1281 c.distance = 2000.0;
1282 let auto = c.camera().depth_range();
1283 assert_eq!(auto, (0.6, 6000.0));
1284 c.depth_range = Some([100.0, 7000.0]);
1285 let camera = c.camera();
1286 assert_eq!(camera.depth_range(), (100.0, 7000.0));
1287 let v = camera
1289 .view_proj_matrix()
1290 .project_point3(glam::Vec3::new(3.0, -2.0, -1500.0));
1291 assert!(v.z > 0.0 && v.z < 1.0, "{v}");
1292 }
1293
1294 #[test]
1295 fn the_control_adapter_drives_a_host_camera() {
1296 let mut control =
1297 Camera2dControl::new(Camera2d::new(Plane2d::Xy).with_units_per_pixel(0.1));
1298 CameraController::set_viewport(&mut control, [400.0, 300.0], 2.0);
1299 assert_eq!(control.camera.viewport_size(), Vec2::new(400.0, 300.0));
1300 assert_eq!(control.camera.pixels_per_point, 2.0);
1301
1302 let mut frame = ActionFrame::default();
1303 frame.navigation.pan = Vec2::new(10.0, 0.0);
1304 let mut host = Camera::default();
1305 CameraController::apply(&mut control, &mut host, &frame, 0.0);
1306 assert!(close(control.camera.centre(), Vec2::new(-1.0, 0.0), 1e-5));
1307 assert_eq!(host.pose, control.camera.camera().pose);
1308 assert!(control.as_any_mut().is_some());
1309 }
1310
1311 #[test]
1312 fn controller_ignores_a_drag_the_viewport_does_not_own() {
1313 let mut ctrl = Camera2dController::new();
1314 let mut c = Camera2d::new(Plane2d::Xy);
1315 let ctx = ViewportContext::new(InputOwnership::default(), [800.0, 600.0]);
1316 ctrl.begin_frame(ctx);
1317 ctrl.push_event(ViewportEvent::PointerMoved {
1318 position: Vec2::new(100.0, 100.0),
1319 });
1320 ctrl.push_event(ViewportEvent::MouseButton {
1321 button: MouseButton::Left,
1322 state: ButtonState::Pressed,
1323 });
1324 ctrl.push_event(ViewportEvent::PointerMoved {
1325 position: Vec2::new(160.0, 100.0),
1326 });
1327 ctrl.apply_to_camera(&mut c, 0.0);
1328 assert_eq!(c.centre(), Vec2::ZERO);
1329 }
1330}