1use crate::{Clamp, Frame, Plane, Rigid, float};
2use glam::{Quat, Vec3};
3
4#[derive(Debug, Clone, Copy, PartialEq)]
8#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
9#[cfg_attr(
10 feature = "rkyv-08",
11 derive(rkyv_08::Archive, rkyv_08::Serialize, rkyv_08::Deserialize),
12 rkyv(crate = rkyv_08)
13)]
14pub struct Bound {
15 pub transform: Rigid,
17 pub min_target: Vec3,
19 pub max_target: Vec3,
21 pub min_eye: Vec3,
23 pub max_eye: Vec3,
25 pub min_up: Vec3,
29 pub max_up: Vec3,
33 pub min_distance: f32,
35 pub max_distance: f32,
37 pub hysteresis: f32,
43}
44
45impl Default for Bound {
46 fn default() -> Self {
47 Self {
48 transform: Rigid::IDENTITY,
49 hysteresis: float::sqrt(f32::EPSILON),
50 min_target: Vec3::MIN,
51 max_target: Vec3::MAX,
52 min_eye: Vec3::MIN,
53 max_eye: Vec3::MAX,
54 min_up: Vec3::MIN,
55 max_up: Vec3::MAX,
56 min_distance: 0.0,
57 max_distance: f32::MAX,
58 }
59 }
60}
61
62impl Clamp for Bound {
63 fn loops(&self) -> usize {
65 10
66 }
67 fn target(&self, frame: Frame) -> Option<Plane> {
69 let target = self.transform.inverse() * frame.target();
70 self.exceeded(target, self.min_target, self.max_target, Quat::IDENTITY)
71 .map(|plane| plane.transform_by(self.transform))
72 }
73 fn eye(&self, frame: Frame) -> Option<Plane> {
77 let distance = frame.distance();
78 let (target, roll_axis) = (frame.target(), frame.roll_axis());
79 if (self.min_distance - distance) > self.hysteresis {
80 return Some(Plane::with_point(
81 roll_axis,
82 target + roll_axis * self.min_distance,
83 ));
84 }
85 if (self.max_distance - distance) < -self.hysteresis {
86 return Some(Plane::with_point(
87 roll_axis,
88 target + roll_axis * self.max_distance,
89 ));
90 }
91 let eye = self.transform.inverse() * frame.eye();
92 self.exceeded(eye, self.min_eye, self.max_eye, Quat::IDENTITY)
93 .map(|plane| plane.transform_by(self.transform))
94 }
95 fn up(&self, frame: Frame) -> Option<Plane> {
103 let rotation = self.transform.rotation;
104 let pitch_axis = rotation.inverse() * frame.pitch_axis();
105 let heading = Quat::from_rotation_y(float::atan2(-pitch_axis.z, pitch_axis.x));
106 let up = heading.inverse() * rotation.inverse() * frame.yaw_axis();
107 self.exceeded(up, self.min_up, self.max_up, rotation * heading)
108 }
109}
110
111impl Bound {
112 fn exceeded(&self, position: Vec3, min: Vec3, max: Vec3, rotation: Quat) -> Option<Plane> {
114 let axes = [Vec3::X, Vec3::Y, Vec3::Z];
115 for (index, axis) in axes.into_iter().enumerate() {
116 let min_plane = Plane::new(axis, min[index]);
117 if min_plane.distance_from(position) > self.hysteresis {
118 return Some(min_plane.rotate_by(rotation));
119 }
120 let max_plane = Plane::new(axis, max[index]);
121 if max_plane.distance_from(position) < -self.hysteresis {
122 return Some(max_plane.rotate_by(rotation));
123 }
124 }
125 None
126 }
127}