use super::{KeyCode, MouseButton};
use crate::core::ObjectRef;
use crate::math::{Quaternion, Vector3};
const EPS: f64 = 0.000001;
#[derive(Clone, Copy, PartialEq, Debug, Default)]
pub struct MoveState {
pub up: f64,
pub down: f64,
pub left: f64,
pub right: f64,
pub forward: f64,
pub back: f64,
pub pitch_up: f64,
pub pitch_down: f64,
pub yaw_left: f64,
pub yaw_right: f64,
pub roll_left: f64,
pub roll_right: f64,
}
pub struct FlyControls {
pub enabled: bool,
pub movement_speed: f64,
pub roll_speed: f64,
pub drag_to_look: bool,
pub auto_forward: bool,
pub movement_speed_multiplier: f64,
pub move_state: MoveState,
move_vector: Vector3,
rotation_vector: Vector3,
last_quaternion: Quaternion,
last_position: Vector3,
status: i32,
element_width: f64,
element_height: f64,
}
impl Default for FlyControls {
fn default() -> Self {
Self::new()
}
}
impl FlyControls {
pub fn new() -> Self {
Self {
enabled: true,
movement_speed: 1.0,
roll_speed: 0.005,
drag_to_look: false,
auto_forward: false,
movement_speed_multiplier: 1.0,
move_state: MoveState::default(),
move_vector: Vector3::ZERO,
rotation_vector: Vector3::ZERO,
last_quaternion: Quaternion::default(),
last_position: Vector3::ZERO,
status: 0,
element_width: 800.0,
element_height: 500.0,
}
}
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 move_vector(&self) -> Vector3 {
self.move_vector
}
pub fn rotation_vector(&self) -> Vector3 {
self.rotation_vector
}
pub fn update(&mut self, object: &ObjectRef, delta: f64) -> bool {
if !self.enabled {
return false;
}
let mut object = object.borrow_mut();
let move_mult = delta * self.movement_speed;
let rot_mult = delta * self.roll_speed;
object.translate_x(self.move_vector.x * move_mult);
object.translate_y(self.move_vector.y * move_mult);
object.translate_z(self.move_vector.z * move_mult);
let mut tmp_quaternion = Quaternion::default();
tmp_quaternion
.set(
self.rotation_vector.x * rot_mult,
self.rotation_vector.y * rot_mult,
self.rotation_vector.z * rot_mult,
1.0,
)
.normalize();
object.quaternion.multiply(&tmp_quaternion);
object.sync_rotation_from_quaternion();
if self.last_position.distance_to_squared(&object.position) > EPS
|| 8.0 * (1.0 - self.last_quaternion.dot(&object.quaternion)) > EPS
{
self.last_quaternion = object.quaternion;
self.last_position = object.position;
true
} else {
false
}
}
pub fn update_movement_vector(&mut self) {
let state = &self.move_state;
let forward = if state.forward != 0.0 || (self.auto_forward && state.back == 0.0) {
1.0
} else {
0.0
};
self.move_vector.x = -state.left + state.right;
self.move_vector.y = -state.down + state.up;
self.move_vector.z = -forward + state.back;
}
pub fn update_rotation_vector(&mut self) {
let state = &self.move_state;
self.rotation_vector.x = -state.pitch_down + state.pitch_up;
self.rotation_vector.y = -state.yaw_right + state.yaw_left;
self.rotation_vector.z = -state.roll_right + state.roll_left;
}
pub fn key_down(&mut self, key: KeyCode, alt_key: bool) {
if alt_key || !self.enabled {
return;
}
self.set_key(key, 1.0);
}
pub fn key_up(&mut self, key: KeyCode) {
if !self.enabled {
return;
}
self.set_key(key, 0.0);
}
fn set_key(&mut self, key: KeyCode, value: f64) {
let state = &mut self.move_state;
match key {
KeyCode::ShiftLeft | KeyCode::ShiftRight => {
self.movement_speed_multiplier = if value == 1.0 { 0.1 } else { 1.0 };
}
KeyCode::KeyW => state.forward = value,
KeyCode::KeyS => state.back = value,
KeyCode::KeyA => state.left = value,
KeyCode::KeyD => state.right = value,
KeyCode::KeyR => state.up = value,
KeyCode::KeyF => state.down = value,
KeyCode::ArrowUp => state.pitch_up = value,
KeyCode::ArrowDown => state.pitch_down = value,
KeyCode::ArrowLeft => state.yaw_left = value,
KeyCode::ArrowRight => state.yaw_right = value,
KeyCode::KeyQ => state.roll_left = value,
KeyCode::KeyE => state.roll_right = value,
KeyCode::Other => {}
}
self.update_movement_vector();
self.update_rotation_vector();
}
pub fn pointer_down(&mut self, button: MouseButton) {
if !self.enabled {
return;
}
if self.drag_to_look {
self.status += 1;
} else {
match button {
MouseButton::Left => self.move_state.forward = 1.0,
MouseButton::Right => self.move_state.back = 1.0,
MouseButton::Middle | MouseButton::Other => {}
}
self.update_movement_vector();
}
}
pub fn pointer_move(&mut self, x: f64, y: f64) {
if !self.enabled {
return;
}
if !self.drag_to_look || self.status > 0 {
let half_width = self.element_width / 2.0;
let half_height = self.element_height / 2.0;
self.move_state.yaw_left = -(x - half_width) / half_width;
self.move_state.pitch_down = (y - half_height) / half_height;
self.update_rotation_vector();
}
}
pub fn pointer_up(&mut self, button: MouseButton) {
if !self.enabled {
return;
}
if self.drag_to_look {
self.status -= 1;
self.move_state.yaw_left = 0.0;
self.move_state.pitch_down = 0.0;
} else {
match button {
MouseButton::Left => self.move_state.forward = 0.0,
MouseButton::Right => self.move_state.back = 0.0,
MouseButton::Middle | MouseButton::Other => {}
}
self.update_movement_vector();
}
self.update_rotation_vector();
}
pub fn pointer_cancel(&mut self) {
if !self.enabled {
return;
}
if self.drag_to_look {
self.status = 0;
self.move_state.yaw_left = 0.0;
self.move_state.pitch_down = 0.0;
} else {
self.move_state.forward = 0.0;
self.move_state.back = 0.0;
self.update_movement_vector();
}
self.update_rotation_vector();
}
}