use crate::cameras::PerspectiveCamera;
use crate::math::{Quaternion, Spherical, Vector2, Vector3};
const EPS: f64 = 0.000001;
const TWO_PI: f64 = 2.0 * std::f64::consts::PI;
#[derive(Clone, Copy, PartialEq, Eq, Debug, Default)]
enum State {
#[default]
None,
Rotate,
Dolly,
Pan,
}
#[derive(Clone, Copy, PartialEq, Eq, Debug, Default)]
pub enum MouseButton {
#[default]
Left,
Middle,
Right,
Other,
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum MouseAction {
Rotate,
Dolly,
Pan,
None,
}
#[derive(Clone, Copy, Debug)]
pub struct MouseButtons {
pub left: MouseAction,
pub middle: MouseAction,
pub right: MouseAction,
}
impl Default for MouseButtons {
fn default() -> Self {
Self {
left: MouseAction::Rotate,
middle: MouseAction::Dolly,
right: MouseAction::Pan,
}
}
}
#[derive(Clone, Copy, Debug, Default)]
pub struct PointerEvent {
pub pointer_id: i32,
pub button: MouseButton,
pub client_x: f64,
pub client_y: f64,
pub ctrl_key: bool,
pub meta_key: bool,
pub shift_key: bool,
}
#[derive(Clone, Copy, PartialEq, Eq, Debug, Default)]
pub enum WheelDelta {
#[default]
Pixel,
Line,
Page,
}
#[derive(Clone, Copy, Debug, Default)]
pub struct WheelEvent {
pub client_x: f64,
pub client_y: f64,
pub delta_y: f64,
pub delta_mode: WheelDelta,
pub ctrl_key: bool,
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum Key {
ArrowLeft,
ArrowUp,
ArrowRight,
ArrowDown,
}
#[derive(Clone, Copy, Debug)]
pub struct KeyEvent {
pub key: Key,
pub ctrl_key: bool,
pub meta_key: bool,
pub shift_key: bool,
}
pub struct OrbitControls {
pub enabled: bool,
pub target: Vector3,
pub cursor: Vector3,
pub min_distance: f64,
pub max_distance: f64,
pub min_zoom: f64,
pub max_zoom: f64,
pub min_target_radius: f64,
pub max_target_radius: f64,
pub min_polar_angle: f64,
pub max_polar_angle: f64,
pub min_azimuth_angle: f64,
pub max_azimuth_angle: f64,
pub enable_damping: bool,
pub damping_factor: f64,
pub enable_zoom: bool,
pub zoom_speed: f64,
pub enable_rotate: bool,
pub rotate_speed: f64,
pub key_rotate_speed: f64,
pub enable_pan: bool,
pub pan_speed: f64,
pub screen_space_panning: bool,
pub key_pan_speed: f64,
pub zoom_to_cursor: bool,
pub auto_rotate: bool,
pub auto_rotate_speed: f64,
pub mouse_buttons: MouseButtons,
target0: Vector3,
position0: Vector3,
zoom0: f64,
state: State,
last_position: Vector3,
last_quaternion: Quaternion,
last_target_position: Vector3,
quat: Quaternion,
quat_inverse: Quaternion,
up: Vector3,
spherical: Spherical,
spherical_delta: Spherical,
scale: f64,
pan_offset: Vector3,
rotate_start: Vector2,
rotate_end: Vector2,
rotate_delta: Vector2,
pan_start: Vector2,
pan_end: Vector2,
pan_delta: Vector2,
dolly_start: Vector2,
dolly_end: Vector2,
dolly_delta: Vector2,
dolly_direction: Vector3,
mouse: Vector2,
perform_cursor_zoom: bool,
pointers: Vec<i32>,
element_width: f64,
element_height: f64,
}
impl OrbitControls {
pub fn new(camera: &mut PerspectiveCamera) -> Self {
let (position, up, zoom) = {
let object = camera.node.borrow();
(object.position, object.up, camera.zoom)
};
let mut quat = Quaternion::default();
quat.set_from_unit_vectors(&up, &Vector3::new(0.0, 1.0, 0.0));
let mut quat_inverse = quat;
quat_inverse.invert();
let mut controls = Self {
enabled: true,
target: Vector3::ZERO,
cursor: Vector3::ZERO,
min_distance: 0.0,
max_distance: f64::INFINITY,
min_zoom: 0.0,
max_zoom: f64::INFINITY,
min_target_radius: 0.0,
max_target_radius: f64::INFINITY,
min_polar_angle: 0.0,
max_polar_angle: std::f64::consts::PI,
min_azimuth_angle: f64::NEG_INFINITY,
max_azimuth_angle: f64::INFINITY,
enable_damping: false,
damping_factor: 0.05,
enable_zoom: true,
zoom_speed: 1.0,
enable_rotate: true,
rotate_speed: 1.0,
key_rotate_speed: 1.0,
enable_pan: true,
pan_speed: 1.0,
screen_space_panning: true,
key_pan_speed: 7.0,
zoom_to_cursor: false,
auto_rotate: false,
auto_rotate_speed: 2.0,
mouse_buttons: MouseButtons::default(),
target0: Vector3::ZERO,
position0: position,
zoom0: zoom,
state: State::None,
last_position: Vector3::ZERO,
last_quaternion: Quaternion::default(),
last_target_position: Vector3::ZERO,
quat,
quat_inverse,
up,
spherical: Spherical::default(),
spherical_delta: Spherical::default(),
scale: 1.0,
pan_offset: Vector3::ZERO,
rotate_start: Vector2::default(),
rotate_end: Vector2::default(),
rotate_delta: Vector2::default(),
pan_start: Vector2::default(),
pan_end: Vector2::default(),
pan_delta: Vector2::default(),
dolly_start: Vector2::default(),
dolly_end: Vector2::default(),
dolly_delta: Vector2::default(),
dolly_direction: Vector3::ZERO,
mouse: Vector2::default(),
perform_cursor_zoom: false,
pointers: Vec::new(),
element_width: 800.0,
element_height: 500.0,
};
controls.update(camera, None);
controls
}
pub fn set_element_size(&mut self, width: f64, height: f64) {
self.element_width = width.max(1.0);
self.element_height = height.max(1.0);
}
pub fn get_polar_angle(&self) -> f64 {
self.spherical.phi
}
pub fn get_azimuthal_angle(&self) -> f64 {
self.spherical.theta
}
pub fn get_distance(&self, camera: &PerspectiveCamera) -> f64 {
camera.node.borrow().position.distance_to(&self.target)
}
pub fn save_state(&mut self, camera: &PerspectiveCamera) {
self.target0 = self.target;
self.position0 = camera.node.borrow().position;
self.zoom0 = camera.zoom;
}
pub fn reset(&mut self, camera: &mut PerspectiveCamera) {
self.target = self.target0;
camera.node.borrow_mut().position = self.position0;
camera.zoom = self.zoom0;
camera.update_projection_matrix();
self.update(camera, None);
self.state = State::None;
}
pub fn update(&mut self, camera: &mut PerspectiveCamera, delta: Option<f64>) -> bool {
let up = camera.node.borrow().up;
if up != self.up {
self.up = up;
self.quat
.set_from_unit_vectors(&up, &Vector3::new(0.0, 1.0, 0.0));
self.quat_inverse = self.quat;
self.quat_inverse.invert();
}
let mut v = camera.node.borrow().position;
v.sub(&self.target);
v.apply_quaternion(&self.quat);
self.spherical.set_from_vector3(&v);
if self.auto_rotate && self.state == State::None {
self.rotate_left(self.auto_rotation_angle(delta));
}
if self.enable_damping {
self.spherical.theta += self.spherical_delta.theta * self.damping_factor;
self.spherical.phi += self.spherical_delta.phi * self.damping_factor;
} else {
self.spherical.theta += self.spherical_delta.theta;
self.spherical.phi += self.spherical_delta.phi;
}
let (mut min, mut max) = (self.min_azimuth_angle, self.max_azimuth_angle);
if min.is_finite() && max.is_finite() {
if min < -std::f64::consts::PI {
min += TWO_PI;
} else if min > std::f64::consts::PI {
min -= TWO_PI;
}
if max < -std::f64::consts::PI {
max += TWO_PI;
} else if max > std::f64::consts::PI {
max -= TWO_PI;
}
self.spherical.theta = if min <= max {
min.max(max.min(self.spherical.theta))
} else if self.spherical.theta > (min + max) / 2.0 {
min.max(self.spherical.theta)
} else {
max.min(self.spherical.theta)
};
}
self.spherical.phi = self
.min_polar_angle
.max(self.max_polar_angle.min(self.spherical.phi));
self.spherical.make_safe();
if self.enable_damping {
self.target
.add_scaled_vector(&self.pan_offset, self.damping_factor);
} else {
self.target.add(&self.pan_offset);
}
self.target.sub(&self.cursor);
self.target
.clamp_length(self.min_target_radius, self.max_target_radius);
self.target.add(&self.cursor);
let mut zoom_changed = false;
if self.zoom_to_cursor && self.perform_cursor_zoom {
self.spherical.radius = self.clamp_distance(self.spherical.radius);
} else {
let previous_radius = self.spherical.radius;
self.spherical.radius = self.clamp_distance(self.spherical.radius * self.scale);
zoom_changed = previous_radius != self.spherical.radius;
}
v.set_from_spherical_coords(
self.spherical.radius,
self.spherical.phi,
self.spherical.theta,
);
v.apply_quaternion(&self.quat_inverse);
{
let mut position = self.target;
position.add(&v);
camera.node.borrow_mut().position = position;
}
camera.look_at(&self.target);
if self.enable_damping {
self.spherical_delta.theta *= 1.0 - self.damping_factor;
self.spherical_delta.phi *= 1.0 - self.damping_factor;
self.pan_offset.multiply_scalar(1.0 - self.damping_factor);
} else {
self.spherical_delta.set(0.0, 0.0, 0.0);
self.pan_offset.set(0.0, 0.0, 0.0);
}
if self.zoom_to_cursor && self.perform_cursor_zoom {
let previous_radius = v.length();
let new_radius = self.clamp_distance(previous_radius * self.scale);
let radius_delta = previous_radius - new_radius;
{
let dolly_direction = self.dolly_direction;
camera
.node
.borrow_mut()
.position
.add_scaled_vector(&dolly_direction, radius_delta);
}
camera.update_matrix_world();
zoom_changed = radius_delta != 0.0;
if self.screen_space_panning {
let matrix = camera.node.borrow().matrix;
let mut target = Vector3::new(0.0, 0.0, -1.0);
target.transform_direction(&matrix);
target.multiply_scalar(new_radius);
target.add(&camera.node.borrow().position);
self.target = target;
} else {
let (origin, matrix, up) = {
let object = camera.node.borrow();
(object.position, object.matrix, object.up)
};
let mut direction = Vector3::new(0.0, 0.0, -1.0);
direction.transform_direction(&matrix);
if up.dot(&direction).abs() < TILT_LIMIT {
camera.look_at(&self.target);
} else {
let mut plane = crate::math::Plane::default();
plane.set_from_normal_and_coplanar_point(&up, &self.target);
let ray = crate::math::Ray::new(origin, direction);
if let Some(point) = ray.intersect_plane(&plane) {
self.target = point;
}
}
}
}
self.scale = 1.0;
self.perform_cursor_zoom = false;
let (position, quaternion) = {
let object = camera.node.borrow();
(object.position, object.quaternion)
};
if zoom_changed
|| self.last_position.distance_to_squared(&position) > EPS
|| 8.0 * (1.0 - self.last_quaternion.dot(&quaternion)) > EPS
|| self.last_target_position.distance_to_squared(&self.target) > EPS
{
self.last_position = position;
self.last_quaternion = quaternion;
self.last_target_position = self.target;
return true;
}
false
}
fn auto_rotation_angle(&self, delta: Option<f64>) -> f64 {
match delta {
Some(delta) => (TWO_PI / 60.0 * self.auto_rotate_speed) * delta,
None => TWO_PI / 60.0 / 60.0 * self.auto_rotate_speed,
}
}
fn zoom_scale(&self, delta: f64) -> f64 {
let normalized_delta = (delta * 0.01).abs();
0.95f64.powf(self.zoom_speed * normalized_delta)
}
fn rotate_left(&mut self, angle: f64) {
self.spherical_delta.theta -= angle;
}
fn rotate_up(&mut self, angle: f64) {
self.spherical_delta.phi -= angle;
}
fn pan_left(&mut self, distance: f64, object_matrix: &crate::math::Matrix4) {
let mut v = Vector3::ZERO;
v.set_from_matrix_column(object_matrix, 0);
v.multiply_scalar(-distance);
self.pan_offset.add(&v);
}
fn pan_up(&mut self, distance: f64, object_matrix: &crate::math::Matrix4, up: &Vector3) {
let mut v = Vector3::ZERO;
if self.screen_space_panning {
v.set_from_matrix_column(object_matrix, 1);
} else {
v.set_from_matrix_column(object_matrix, 0);
let column = v;
v.cross_vectors(up, &column);
}
v.multiply_scalar(distance);
self.pan_offset.add(&v);
}
fn pan(&mut self, delta_x: f64, delta_y: f64, camera: &PerspectiveCamera) {
let (position, matrix, up) = {
let object = camera.node.borrow();
(object.position, object.matrix, object.up)
};
let mut v = position;
v.sub(&self.target);
let mut target_distance = v.length();
target_distance *= ((camera.fov / 2.0) * std::f64::consts::PI / 180.0).tan();
let height = self.element_height;
self.pan_left(2.0 * delta_x * target_distance / height, &matrix);
self.pan_up(2.0 * delta_y * target_distance / height, &matrix, &up);
}
fn dolly_out(&mut self, dolly_scale: f64) {
self.scale /= dolly_scale;
}
fn dolly_in(&mut self, dolly_scale: f64) {
self.scale *= dolly_scale;
}
fn update_zoom_parameters(&mut self, x: f64, y: f64, camera: &PerspectiveCamera) {
if !self.zoom_to_cursor {
return;
}
self.perform_cursor_zoom = true;
self.mouse.x = (x / self.element_width) * 2.0 - 1.0;
self.mouse.y = -(y / self.element_height) * 2.0 + 1.0;
let mut direction = Vector3::new(self.mouse.x, self.mouse.y, 1.0);
direction.unproject(camera);
direction.sub(&camera.node.borrow().position);
direction.normalize();
self.dolly_direction = direction;
}
fn clamp_distance(&self, distance: f64) -> f64 {
self.min_distance.max(self.max_distance.min(distance))
}
pub fn pointer_down(&mut self, camera: &mut PerspectiveCamera, event: &PointerEvent) {
if !self.enabled {
return;
}
if self.pointers.contains(&event.pointer_id) {
return;
}
self.pointers.push(event.pointer_id);
if self.pointers.len() > 1 {
return;
}
let action = match event.button {
MouseButton::Left => self.mouse_buttons.left,
MouseButton::Middle => self.mouse_buttons.middle,
MouseButton::Right => self.mouse_buttons.right,
MouseButton::Other => MouseAction::None,
};
let modified = event.ctrl_key || event.meta_key || event.shift_key;
match action {
MouseAction::Dolly => {
if !self.enable_zoom {
return;
}
self.update_zoom_parameters(event.client_x, event.client_x, camera);
self.dolly_start.set(event.client_x, event.client_y);
self.state = State::Dolly;
}
MouseAction::Rotate => {
if modified {
if !self.enable_pan {
return;
}
self.pan_start.set(event.client_x, event.client_y);
self.state = State::Pan;
} else {
if !self.enable_rotate {
return;
}
self.rotate_start.set(event.client_x, event.client_y);
self.state = State::Rotate;
}
}
MouseAction::Pan => {
if modified {
if !self.enable_rotate {
return;
}
self.rotate_start.set(event.client_x, event.client_y);
self.state = State::Rotate;
} else {
if !self.enable_pan {
return;
}
self.pan_start.set(event.client_x, event.client_y);
self.state = State::Pan;
}
}
MouseAction::None => self.state = State::None,
}
}
pub fn pointer_move(&mut self, camera: &mut PerspectiveCamera, event: &PointerEvent) {
if !self.enabled {
return;
}
match self.state {
State::Rotate => {
if !self.enable_rotate {
return;
}
self.rotate_end.set(event.client_x, event.client_y);
let (end, start) = (self.rotate_end, self.rotate_start);
self.rotate_delta.sub_vectors(&end, &start);
self.rotate_delta.multiply_scalar(self.rotate_speed);
let height = self.element_height;
self.rotate_left(TWO_PI * self.rotate_delta.x / height);
self.rotate_up(TWO_PI * self.rotate_delta.y / height);
self.rotate_start = self.rotate_end;
self.update(camera, None);
}
State::Dolly => {
if !self.enable_zoom {
return;
}
self.dolly_end.set(event.client_x, event.client_y);
let (end, start) = (self.dolly_end, self.dolly_start);
self.dolly_delta.sub_vectors(&end, &start);
if self.dolly_delta.y > 0.0 {
self.dolly_out(self.zoom_scale(self.dolly_delta.y));
} else if self.dolly_delta.y < 0.0 {
self.dolly_in(self.zoom_scale(self.dolly_delta.y));
}
self.dolly_start = self.dolly_end;
self.update(camera, None);
}
State::Pan => {
if !self.enable_pan {
return;
}
self.pan_end.set(event.client_x, event.client_y);
let (end, start) = (self.pan_end, self.pan_start);
self.pan_delta.sub_vectors(&end, &start);
self.pan_delta.multiply_scalar(self.pan_speed);
self.pan(self.pan_delta.x, self.pan_delta.y, camera);
self.pan_start = self.pan_end;
self.update(camera, None);
}
State::None => {}
}
}
pub fn pointer_up(&mut self, event: &PointerEvent) {
self.pointers.retain(|id| *id != event.pointer_id);
if self.pointers.is_empty() {
self.state = State::None;
}
}
pub fn wheel(&mut self, camera: &mut PerspectiveCamera, event: &WheelEvent) -> bool {
if !self.enabled || !self.enable_zoom || self.state != State::None {
return false;
}
let mut delta_y = event.delta_y;
match event.delta_mode {
WheelDelta::Pixel => {}
WheelDelta::Line => delta_y *= 16.0,
WheelDelta::Page => delta_y *= 100.0,
}
if event.ctrl_key {
delta_y *= 10.0;
}
self.update_zoom_parameters(event.client_x, event.client_y, camera);
if delta_y < 0.0 {
self.dolly_in(self.zoom_scale(delta_y));
} else if delta_y > 0.0 {
self.dolly_out(self.zoom_scale(delta_y));
}
self.update(camera, None);
true
}
pub fn key(&mut self, camera: &mut PerspectiveCamera, event: &KeyEvent) -> bool {
if !self.enabled {
return false;
}
let modified = event.ctrl_key || event.meta_key || event.shift_key;
let height = self.element_height;
let key_rotate = TWO_PI * self.key_rotate_speed / height;
match event.key {
Key::ArrowUp => {
if modified {
if self.enable_rotate {
self.rotate_up(key_rotate);
}
} else if self.enable_pan {
self.pan(0.0, self.key_pan_speed, camera);
}
}
Key::ArrowDown => {
if modified {
if self.enable_rotate {
self.rotate_up(-key_rotate);
}
} else if self.enable_pan {
self.pan(0.0, -self.key_pan_speed, camera);
}
}
Key::ArrowLeft => {
if modified {
if self.enable_rotate {
self.rotate_left(key_rotate);
}
} else if self.enable_pan {
self.pan(self.key_pan_speed, 0.0, camera);
}
}
Key::ArrowRight => {
if modified {
if self.enable_rotate {
self.rotate_left(-key_rotate);
}
} else if self.enable_pan {
self.pan(-self.key_pan_speed, 0.0, camera);
}
}
}
self.update(camera, None);
true
}
}
const TILT_LIMIT: f64 = 0.342_020_143_325_668_9;