120 lines
3.5 KiB
Rust
120 lines
3.5 KiB
Rust
const EPSILON: f32 = 0.001;
|
|
|
|
use glium::glutin::{
|
|
Event,
|
|
WindowEvent,
|
|
ElementState,
|
|
MouseButton,
|
|
MouseScrollDelta,
|
|
};
|
|
|
|
use math::vector::Vector2;
|
|
use renderer::camera::Camera;
|
|
|
|
/// 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);
|
|
}
|
|
|
|
/// 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<f32>,
|
|
|
|
/// 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: f32,
|
|
|
|
/// The phi angle of the position of the camera in spheric coordinates.
|
|
phi: f32,
|
|
|
|
/// The distance between the camera and the origin.
|
|
distance: f32,
|
|
|
|
/// The sensitiviy of the rotation of the mouse.
|
|
sensitivity: f32,
|
|
}
|
|
|
|
impl OrbitControls {
|
|
|
|
/// Creates a new orbit controls, and initializes the camera.
|
|
pub fn new(camera: &mut Camera) -> OrbitControls {
|
|
let controls = OrbitControls {
|
|
mouse_position: Vector2::new(0.0, 0.0),
|
|
pressed: false,
|
|
theta: 0.0,
|
|
phi: 0.0,
|
|
distance: 5.0,
|
|
sensitivity: 200.0,
|
|
};
|
|
|
|
*camera.position.x_mut() = controls.distance * controls.theta.cos();
|
|
*camera.position.y_mut() = 0.0;
|
|
*camera.position.z_mut() = controls.distance * controls.phi.sin();
|
|
controls
|
|
}
|
|
}
|
|
|
|
impl Controls for OrbitControls {
|
|
fn manage_event(&mut self, event: &Event, camera: &mut Camera) {
|
|
match *event {
|
|
|
|
Event::WindowEvent {
|
|
event: WindowEvent::MouseInput {
|
|
button: MouseButton::Left,
|
|
state, ..
|
|
}, ..
|
|
} => {
|
|
self.pressed = state == ElementState::Pressed;
|
|
},
|
|
|
|
Event::WindowEvent {
|
|
event: WindowEvent::MouseWheel {
|
|
delta: MouseScrollDelta::LineDelta(_, y), ..
|
|
}, ..
|
|
} => {
|
|
self.distance -= y;
|
|
|
|
*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();
|
|
},
|
|
|
|
Event::WindowEvent{
|
|
event: WindowEvent::CursorMoved {
|
|
position: (x, y), ..
|
|
}, ..
|
|
} => {
|
|
let current_position = Vector2::new(x as f32, y as f32);
|
|
|
|
if self.pressed {
|
|
let difference = (current_position - self.mouse_position) / self.sensitivity;
|
|
|
|
self.theta += difference.x();
|
|
self.phi += difference.y();
|
|
|
|
use std::f32::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();
|
|
|
|
}
|
|
|
|
// Record new position
|
|
self.mouse_position = current_position;
|
|
},
|
|
|
|
_ => (),
|
|
}
|
|
}
|
|
}
|