use super::{KeyCode, MouseButton};
use crate::core::ObjectRef;
use crate::math::math_utils::{clamp, deg_to_rad, lerp, map_linear, rad_to_deg};
use crate::math::{Spherical, Vector3};
pub struct FirstPersonControls {
pub enabled: bool,
pub movement_speed: f64,
pub look_speed: f64,
pub damping_factor: f64,
pub look_vertical: bool,
pub auto_forward: bool,
pub height_speed: bool,
pub height_coef: f64,
pub height_min: f64,
pub height_max: f64,
pub constrain_vertical: bool,
pub vertical_min: f64,
pub vertical_max: f64,
mouse_drag_on: bool,
velocity: Vector3,
pointer_x: f64,
pointer_y: f64,
pointer_down_x: f64,
pointer_down_y: f64,
pointer_count: i32,
key_forward: bool,
key_backward: bool,
pointer_forward: bool,
pointer_backward: bool,
move_left: bool,
move_right: bool,
move_up: bool,
move_down: bool,
lat: f64,
lon: f64,
lon_velocity: f64,
lat_velocity: f64,
}
impl FirstPersonControls {
pub fn new(object: &ObjectRef) -> Self {
let mut controls = Self {
enabled: true,
movement_speed: 1.0,
look_speed: 0.005,
damping_factor: 0.1,
look_vertical: true,
auto_forward: false,
height_speed: false,
height_coef: 1.0,
height_min: 0.0,
height_max: 1.0,
constrain_vertical: false,
vertical_min: 0.0,
vertical_max: std::f64::consts::PI,
mouse_drag_on: false,
velocity: Vector3::ZERO,
pointer_x: 0.0,
pointer_y: 0.0,
pointer_down_x: 0.0,
pointer_down_y: 0.0,
pointer_count: 0,
key_forward: false,
key_backward: false,
pointer_forward: false,
pointer_backward: false,
move_left: false,
move_right: false,
move_up: false,
move_down: false,
lat: 0.0,
lon: 0.0,
lon_velocity: 0.0,
lat_velocity: 0.0,
};
controls.set_orientation(object);
controls
}
pub fn mouse_drag_on(&self) -> bool {
self.mouse_drag_on
}
pub fn look_at(&mut self, object: &ObjectRef, target: &Vector3) -> &mut Self {
object.look_at(target);
self.set_orientation(object);
self
}
pub fn update(&mut self, object: &ObjectRef, delta: f64) {
if !self.enabled {
return;
}
let one = |held: bool| -> f64 {
if held {
1.0
} else {
0.0
}
};
let mut drive = one(self.key_forward) - one(self.key_backward);
let mut look_move = one(self.pointer_forward) - one(self.pointer_backward);
if self.auto_forward && drive == 0.0 && look_move == 0.0 {
look_move = 1.0;
}
let (position, quaternion) = {
let object = object.borrow();
(object.position, object.quaternion)
};
let mut forward_speed = self.movement_speed;
if self.height_speed {
let y = clamp(position.y, self.height_min, self.height_max);
forward_speed += (y - self.height_min) * self.height_coef;
}
let yaw = deg_to_rad(self.lon);
let sin_yaw = yaw.sin();
let cos_yaw = yaw.cos();
let mut strafe = one(self.move_right) - one(self.move_left);
let mut climb = one(self.move_up) - one(self.move_down);
let key_scale = 1.0 / 1.0_f64.max((strafe * strafe + climb * climb + drive * drive).sqrt());
strafe *= self.movement_speed * key_scale;
climb *= self.movement_speed * key_scale;
drive *= (if drive > 0.0 {
forward_speed
} else {
self.movement_speed
}) * key_scale;
let mut target_velocity = Vector3::new(
sin_yaw * drive - cos_yaw * strafe,
climb,
cos_yaw * drive + sin_yaw * strafe,
);
if look_move != 0.0 {
let mut look_direction = Vector3::new(0.0, 0.0, -1.0);
look_direction.apply_quaternion(&quaternion);
let speed = if look_move > 0.0 {
forward_speed
} else {
self.movement_speed
};
target_velocity.add_scaled_vector(&look_direction, look_move * speed);
}
self.velocity.lerp(&target_velocity, self.damping_factor);
let position = {
let mut object = object.borrow_mut();
object.position.add_scaled_vector(&self.velocity, delta);
object.position
};
let vertical_look_ratio = if self.constrain_vertical {
std::f64::consts::PI / (self.vertical_max - self.vertical_min)
} else {
1.0
};
let target_lon = if self.mouse_drag_on {
-self.pointer_x * self.look_speed
} else {
0.0
};
let target_lat = if self.mouse_drag_on && self.look_vertical {
-self.pointer_y * self.look_speed * vertical_look_ratio
} else {
0.0
};
self.lon_velocity = lerp(self.lon_velocity, target_lon, self.damping_factor);
self.lat_velocity = lerp(self.lat_velocity, target_lat, self.damping_factor);
self.lon += self.lon_velocity * delta;
self.lat += self.lat_velocity * delta;
self.lat = clamp(self.lat, -85.0, 85.0);
let mut phi = deg_to_rad(90.0 - self.lat);
let theta = deg_to_rad(self.lon);
if self.constrain_vertical {
phi = map_linear(
phi,
0.0,
std::f64::consts::PI,
self.vertical_min,
self.vertical_max,
);
}
let mut target_position = Vector3::ZERO;
target_position
.set_from_spherical_coords(1.0, phi, theta)
.add(&position);
object.look_at(&target_position);
}
pub fn pointer_down(&mut self, button: MouseButton, x: f64, y: f64) {
self.pointer_count += 1;
if !self.key_forward && !self.key_backward {
match button {
MouseButton::Left => self.pointer_forward = true,
MouseButton::Right => self.pointer_backward = true,
MouseButton::Middle | MouseButton::Other => {}
}
}
self.start_drag(x, y);
}
pub fn touch_start(&mut self, x: f64, y: f64) {
self.pointer_count += 1;
self.pointer_forward = self.pointer_count == 1;
self.pointer_backward = self.pointer_count >= 2;
self.start_drag(x, y);
}
fn start_drag(&mut self, x: f64, y: f64) {
self.pointer_down_x = x;
self.pointer_down_y = y;
self.pointer_x = 0.0;
self.pointer_y = 0.0;
self.mouse_drag_on = true;
}
pub fn pointer_up(&mut self, button: MouseButton) {
if !self.mouse_drag_on {
return;
}
self.pointer_count -= 1;
match button {
MouseButton::Left => self.pointer_forward = false,
MouseButton::Right => self.pointer_backward = false,
MouseButton::Middle | MouseButton::Other => {}
}
self.end_drag();
}
pub fn touch_end(&mut self) {
if !self.mouse_drag_on {
return;
}
self.pointer_count -= 1;
self.pointer_forward = self.pointer_count == 1;
self.pointer_backward = false;
self.end_drag();
}
fn end_drag(&mut self) {
self.pointer_x = 0.0;
self.pointer_y = 0.0;
if self.pointer_count == 0 {
self.mouse_drag_on = false;
}
}
pub fn pointer_move(&mut self, x: f64, y: f64) {
if !self.mouse_drag_on {
return;
}
self.pointer_x = x - self.pointer_down_x;
self.pointer_y = y - self.pointer_down_y;
}
pub fn key_down(&mut self, key: KeyCode) {
self.set_key(key, true);
}
pub fn key_up(&mut self, key: KeyCode) {
self.set_key(key, false);
}
fn set_key(&mut self, key: KeyCode, held: bool) {
match key {
KeyCode::ArrowUp | KeyCode::KeyW => self.key_forward = held,
KeyCode::ArrowLeft | KeyCode::KeyA => self.move_left = held,
KeyCode::ArrowDown | KeyCode::KeyS => self.key_backward = held,
KeyCode::ArrowRight | KeyCode::KeyD => self.move_right = held,
KeyCode::KeyR => self.move_up = held,
KeyCode::KeyF => self.move_down = held,
_ => {}
}
}
fn set_orientation(&mut self, object: &ObjectRef) {
let quaternion = object.borrow().quaternion;
let mut look_direction = Vector3::new(0.0, 0.0, -1.0);
look_direction.apply_quaternion(&quaternion);
let mut spherical = Spherical::default();
spherical.set_from_vector3(&look_direction);
self.lat = 90.0 - rad_to_deg(spherical.phi);
self.lon = rad_to_deg(spherical.theta);
}
}