405 lines
12 KiB
Rust
405 lines
12 KiB
Rust
//! This models contains structs that help move the camera in a user-friendly way.
|
|
|
|
const EPSILON: f64 = 0.001;
|
|
|
|
use glium::glutin::dpi::{PhysicalPosition, PhysicalSize};
|
|
use glium::glutin::event::{
|
|
ElementState, Event, KeyboardInput, MouseButton, MouseScrollDelta, VirtualKeyCode, WindowEvent,
|
|
};
|
|
|
|
use camera::Camera;
|
|
use math::vector::{Vector2, Vector3};
|
|
use model::Model;
|
|
use renderer::Renderer;
|
|
|
|
/// The trait that all controls should implement.
|
|
pub trait Controls {
|
|
/// Modifies the camera depending on the event.
|
|
fn manage_event(&mut self, event: &Event<()>, camera: &mut Camera, renderer: &Renderer);
|
|
|
|
/// Updates the camera depending on time.
|
|
fn update(&mut self, camera: &mut Camera, renderer: &Renderer);
|
|
}
|
|
|
|
/// An orbit controls allowing to orbit around an object.
|
|
///
|
|
/// Only object centered are supported.
|
|
pub struct OrbitControls {
|
|
/// The last position of the mouse.
|
|
mouse_position: Vector2<f64>,
|
|
|
|
/// Wether the left click of the mouse is pressed or not.
|
|
pressed: bool,
|
|
|
|
/// The theta angle of the position of the camera in spheric coordinates.
|
|
theta: f64,
|
|
|
|
/// The phi angle of the position of the camera in spheric coordinates.
|
|
phi: f64,
|
|
|
|
/// The distance between the camera and the origin.
|
|
distance: f64,
|
|
|
|
/// The sensitiviy of the rotation of the mouse.
|
|
sensitivity: f64,
|
|
|
|
/// The center of the object.
|
|
center: Vector3<f64>,
|
|
}
|
|
|
|
impl OrbitControls {
|
|
/// Creates a new orbit controls, and initializes the camera.
|
|
pub fn new(center: Vector3<f64>, distance: f64, camera: &mut Camera) -> OrbitControls {
|
|
let controls = OrbitControls {
|
|
mouse_position: Vector2::new(0.0, 0.0),
|
|
pressed: false,
|
|
theta: 0.0,
|
|
phi: 0.0,
|
|
distance: distance,
|
|
sensitivity: 200.0,
|
|
center: center,
|
|
};
|
|
|
|
*camera.position.x_mut() = controls.distance * controls.theta.cos();
|
|
*camera.position.y_mut() = 0.0;
|
|
*camera.position.z_mut() = controls.distance * controls.phi.sin();
|
|
camera.position += controls.center;
|
|
camera.target = controls.center;
|
|
|
|
controls
|
|
}
|
|
|
|
/// Creates orbit controls that are mode to rotate around a model.
|
|
pub fn around(model: &Model, camera: &mut Camera) -> OrbitControls {
|
|
// Compute bounding box
|
|
let bounding_box = model.bounding_box();
|
|
let center = (bounding_box.min() + bounding_box.max()) / 2.0;
|
|
let distance = (bounding_box.max() - bounding_box.min()).norm();
|
|
|
|
OrbitControls::new(
|
|
Vector3::new(center.x() as f64, center.y() as f64, center.z() as f64),
|
|
distance as f64,
|
|
camera,
|
|
)
|
|
}
|
|
}
|
|
|
|
impl Controls for OrbitControls {
|
|
fn manage_event(&mut self, event: &Event<()>, camera: &mut Camera, _: &Renderer) {
|
|
match *event {
|
|
Event::WindowEvent {
|
|
event:
|
|
WindowEvent::MouseInput {
|
|
button: MouseButton::Left,
|
|
state,
|
|
..
|
|
},
|
|
..
|
|
} => {
|
|
self.pressed = state == ElementState::Pressed;
|
|
}
|
|
|
|
Event::WindowEvent {
|
|
event: WindowEvent::Resized(PhysicalSize { width, height }),
|
|
..
|
|
} => {
|
|
camera.aspect_ratio = width as f64 / height as f64;
|
|
}
|
|
|
|
Event::WindowEvent {
|
|
event:
|
|
WindowEvent::MouseWheel {
|
|
delta: MouseScrollDelta::LineDelta(_, y),
|
|
..
|
|
},
|
|
..
|
|
} => {
|
|
self.distance -= y as f64 / self.sensitivity;
|
|
|
|
*camera.position.x_mut() = self.distance * self.phi.cos() * self.theta.cos();
|
|
*camera.position.y_mut() = self.distance * self.phi.sin();
|
|
*camera.position.z_mut() = self.distance * self.phi.cos() * self.theta.sin();
|
|
|
|
camera.position += self.center;
|
|
camera.target = self.center;
|
|
}
|
|
|
|
Event::WindowEvent {
|
|
event:
|
|
WindowEvent::CursorMoved {
|
|
position: PhysicalPosition { x, y },
|
|
..
|
|
},
|
|
..
|
|
} => {
|
|
let current_position = Vector2::new(x as f64, y as f64);
|
|
|
|
if self.pressed {
|
|
let difference = (current_position - self.mouse_position) / self.sensitivity;
|
|
|
|
self.theta += difference.x();
|
|
self.phi += difference.y();
|
|
|
|
use std::f64::consts::PI;
|
|
self.phi = self.phi.max(-PI / 2.0 + EPSILON);
|
|
self.phi = self.phi.min(PI / 2.0 - EPSILON);
|
|
|
|
*camera.position.x_mut() = self.distance * self.phi.cos() * self.theta.cos();
|
|
*camera.position.y_mut() = self.distance * self.phi.sin();
|
|
*camera.position.z_mut() = self.distance * self.phi.cos() * self.theta.sin();
|
|
|
|
camera.position += self.center;
|
|
camera.target = self.center;
|
|
}
|
|
|
|
// Record new position
|
|
self.mouse_position = current_position;
|
|
}
|
|
|
|
_ => (),
|
|
}
|
|
}
|
|
|
|
fn update(&mut self, _: &mut Camera, _: &Renderer) {}
|
|
}
|
|
|
|
/// First person controls, just like in video games.
|
|
pub struct FirstPersonControls {
|
|
/// Theta angle of the spheric coordinates of the direction of the camera.
|
|
theta: f64,
|
|
|
|
/// Phi angle of the spheric coordinates of the direction of the camera.
|
|
phi: f64,
|
|
|
|
/// Current position of the camera.
|
|
position: Vector3<f64>,
|
|
|
|
/// Vector indicating the direction of the camera.
|
|
forward: Vector3<f64>,
|
|
|
|
/// Vector indicating the left of the camera.
|
|
left: Vector3<f64>,
|
|
|
|
/// Speed of the camera.
|
|
speed: f64,
|
|
|
|
/// Sensitivity of the mouse.
|
|
sensitivity: f64,
|
|
|
|
/// Wether the forward button is pressed or not.
|
|
forward_pressed: bool,
|
|
|
|
/// Wether the backward button is pressed or not.
|
|
backward_pressed: bool,
|
|
|
|
/// Wether the left button is pressed or not.
|
|
left_pressed: bool,
|
|
|
|
/// Wether the right button is pressed or not.
|
|
right_pressed: bool,
|
|
|
|
/// Wether the boost is active or not.
|
|
boost: bool,
|
|
}
|
|
|
|
impl FirstPersonControls {
|
|
/// Creates a new default first person controls.
|
|
pub fn new() -> FirstPersonControls {
|
|
FirstPersonControls {
|
|
theta: 0.0,
|
|
phi: 0.0,
|
|
position: Vector3::new(0.0, 0.0, 0.0),
|
|
forward: Vector3::new(0.0, 0.0, 1.0),
|
|
left: Vector3::new(1.0, 0.0, 0.0),
|
|
speed: 0.001,
|
|
forward_pressed: false,
|
|
backward_pressed: false,
|
|
left_pressed: false,
|
|
right_pressed: false,
|
|
boost: false,
|
|
sensitivity: 500.0,
|
|
}
|
|
}
|
|
|
|
/// Updates the camera according to the state of the controls.
|
|
pub fn update_camera(&self, camera: &mut Camera) {
|
|
camera.position = self.position;
|
|
camera.target = self.position + self.forward;
|
|
}
|
|
}
|
|
|
|
impl Controls for FirstPersonControls {
|
|
fn manage_event(&mut self, event: &Event<()>, camera: &mut Camera, renderer: &Renderer) {
|
|
match *event {
|
|
// On resize window
|
|
Event::WindowEvent {
|
|
event: WindowEvent::Resized(PhysicalSize { width, height }),
|
|
..
|
|
} => {
|
|
camera.aspect_ratio = width as f64 / height as f64;
|
|
}
|
|
|
|
// On Z pressed
|
|
Event::WindowEvent {
|
|
event:
|
|
WindowEvent::KeyboardInput {
|
|
input:
|
|
KeyboardInput {
|
|
virtual_keycode: Some(VirtualKeyCode::Z),
|
|
state,
|
|
..
|
|
},
|
|
..
|
|
},
|
|
..
|
|
} => {
|
|
self.forward_pressed = state == ElementState::Pressed;
|
|
}
|
|
|
|
// On S pressed
|
|
Event::WindowEvent {
|
|
event:
|
|
WindowEvent::KeyboardInput {
|
|
input:
|
|
KeyboardInput {
|
|
virtual_keycode: Some(VirtualKeyCode::S),
|
|
state,
|
|
..
|
|
},
|
|
..
|
|
},
|
|
..
|
|
} => {
|
|
self.backward_pressed = state == ElementState::Pressed;
|
|
}
|
|
|
|
// On Q pressed
|
|
Event::WindowEvent {
|
|
event:
|
|
WindowEvent::KeyboardInput {
|
|
input:
|
|
KeyboardInput {
|
|
virtual_keycode: Some(VirtualKeyCode::Q),
|
|
state,
|
|
..
|
|
},
|
|
..
|
|
},
|
|
..
|
|
} => {
|
|
self.left_pressed = state == ElementState::Pressed;
|
|
}
|
|
|
|
// On D pressed
|
|
Event::WindowEvent {
|
|
event:
|
|
WindowEvent::KeyboardInput {
|
|
input:
|
|
KeyboardInput {
|
|
virtual_keycode: Some(VirtualKeyCode::D),
|
|
state,
|
|
..
|
|
},
|
|
..
|
|
},
|
|
..
|
|
} => {
|
|
self.right_pressed = state == ElementState::Pressed;
|
|
}
|
|
|
|
// On Space pressed
|
|
Event::WindowEvent {
|
|
event:
|
|
WindowEvent::KeyboardInput {
|
|
input:
|
|
KeyboardInput {
|
|
virtual_keycode: Some(VirtualKeyCode::Space),
|
|
state,
|
|
..
|
|
},
|
|
..
|
|
},
|
|
..
|
|
} => {
|
|
self.boost = state == ElementState::Pressed;
|
|
}
|
|
|
|
// On mouse move
|
|
Event::WindowEvent {
|
|
event:
|
|
WindowEvent::CursorMoved {
|
|
position: PhysicalPosition { x, y },
|
|
..
|
|
},
|
|
..
|
|
} => {
|
|
let size = renderer.gl_window().window().inner_size();
|
|
let center = Vector2::new(size.width as f64 / 2.0, size.height as f64 / 2.0);
|
|
let current_position = Vector2::new(x as f64, y as f64);
|
|
let difference = (current_position - center) / self.sensitivity;
|
|
|
|
self.theta += difference.x();
|
|
self.phi -= difference.y();
|
|
|
|
use std::f64::consts::PI;
|
|
self.phi = self.phi.max(-PI / 2.0 + EPSILON);
|
|
self.phi = self.phi.min(PI / 2.0 - EPSILON);
|
|
|
|
self.forward = Vector3::new(
|
|
self.phi.cos() * self.theta.cos(),
|
|
self.phi.sin(),
|
|
self.phi.cos() * self.theta.sin(),
|
|
);
|
|
|
|
self.left = Vector3::new(0.0, 1.0, 0.0)
|
|
.cross_product(self.forward)
|
|
.normalized();
|
|
|
|
// Move the cursor back to the center
|
|
renderer
|
|
.gl_window()
|
|
.window()
|
|
.set_cursor_position(PhysicalPosition::new(
|
|
size.width as f64 / 2.0,
|
|
size.height as f64 / 2.0,
|
|
))
|
|
.unwrap();
|
|
}
|
|
|
|
_ => (),
|
|
}
|
|
|
|
self.update_camera(camera);
|
|
}
|
|
|
|
fn update(&mut self, camera: &mut Camera, renderer: &Renderer) {
|
|
renderer.gl_window().window().set_cursor_visible(false);
|
|
|
|
let mut speed = Vector3::new(0.0, 0.0, 0.0);
|
|
|
|
if self.forward_pressed {
|
|
speed += self.forward * self.speed;
|
|
}
|
|
|
|
if self.backward_pressed {
|
|
speed -= self.forward * self.speed;
|
|
}
|
|
|
|
if self.left_pressed {
|
|
speed += self.left * self.speed;
|
|
}
|
|
|
|
if self.right_pressed {
|
|
speed -= self.left * self.speed;
|
|
}
|
|
|
|
if self.boost {
|
|
speed *= 10.0;
|
|
}
|
|
|
|
self.position += speed;
|
|
|
|
self.update_camera(camera);
|
|
}
|
|
}
|