140 lines
4.8 KiB
Rust
140 lines
4.8 KiB
Rust
use raidillon_engine::system::{System, SystemContext};
|
|
use glam::{Quat, Vec3};
|
|
use winit::event::DeviceEvent::MouseMotion;
|
|
use winit::event::{ElementState, Event, MouseButton, WindowEvent};
|
|
use winit::keyboard::{KeyCode, PhysicalKey};
|
|
use winit::window::CursorGrabMode;
|
|
use raidillon_assets::model_path;
|
|
use raidillon_platform::{Camera, PlatformContext};
|
|
use raidillon_engine::InputState;
|
|
use raidillon_engine::EngineResources;
|
|
use raidillon_core::scene::Scene;
|
|
use raidillon_ecs::components::CameraMode;
|
|
|
|
pub struct FPSDebugCameraSystem {
|
|
mouse_delta: (f64, f64),
|
|
mouse_enabled: bool,
|
|
position: Vec3,
|
|
yaw: f32,
|
|
pitch: f32,
|
|
speed: f32,
|
|
sensitivity: f32,
|
|
}
|
|
|
|
impl Default for FPSDebugCameraSystem {
|
|
fn default() -> Self {
|
|
Self {
|
|
mouse_delta: Default::default(),
|
|
mouse_enabled: Default::default(),
|
|
position: Vec3::new(0.0, 0.0, 2.0),
|
|
yaw: -90.0,
|
|
pitch: 0.0,
|
|
speed: 8.0,
|
|
sensitivity: 0.1,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl System for FPSDebugCameraSystem {
|
|
fn handle_event(&mut self, res: &mut EngineResources, scene: &mut Scene) {
|
|
if !self.is_camera_mode_valid(scene) {
|
|
return
|
|
}
|
|
let pctx = res.get::<PlatformContext>().unwrap();
|
|
let event2 = pctx.current_event.clone();
|
|
match event2 {
|
|
Event::DeviceEvent { device_id, event} => {
|
|
match event {
|
|
MouseMotion { delta } => {
|
|
self.mouse_delta.0 += delta.0;
|
|
self.mouse_delta.1 += delta.1;
|
|
},
|
|
_ => {}
|
|
}
|
|
},
|
|
Event::WindowEvent { event, .. } => match event {
|
|
WindowEvent::MouseInput { state, button, .. } => {
|
|
if button == MouseButton::Right {
|
|
// blood and tear
|
|
let window = pctx.window.lock().unwrap();
|
|
match state {
|
|
ElementState::Pressed => {
|
|
if window
|
|
.set_cursor_grab(CursorGrabMode::Confined)
|
|
.or_else(|_| window.set_cursor_grab(CursorGrabMode::Locked))
|
|
.is_ok()
|
|
{
|
|
window.set_cursor_visible(false);
|
|
self.mouse_enabled = true;
|
|
}
|
|
}
|
|
ElementState::Released => {
|
|
let _ = window.set_cursor_grab(CursorGrabMode::None);
|
|
window.set_cursor_visible(true);
|
|
self.mouse_enabled = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
_ => {},
|
|
},
|
|
_ => {},
|
|
}
|
|
}
|
|
|
|
fn frame_update(&mut self, res: &mut EngineResources, scene: &mut Scene) {
|
|
if !self.is_camera_mode_valid(scene) {
|
|
return
|
|
}
|
|
let (pctx, input) = res.get_many::<(PlatformContext, InputState)>().unwrap();
|
|
|
|
if self.mouse_enabled {
|
|
self.yaw += self.mouse_delta.0 as f32 * self.sensitivity;
|
|
self.pitch -= self.mouse_delta.1 as f32 * self.sensitivity;
|
|
self.pitch = self.pitch.clamp(-89.0, 89.0);
|
|
}
|
|
|
|
let front = self.front();
|
|
let right_vec = front.cross(Vec3::Y).normalize();
|
|
|
|
if input.key_held(KeyCode::KeyW) {
|
|
self.position += front * pctx.time_ctx.frame_dt * self.speed;
|
|
}
|
|
if input.key_held(KeyCode::KeyS) {
|
|
self.position -= front * pctx.time_ctx.frame_dt * self.speed;
|
|
}
|
|
if input.key_held(KeyCode::KeyA) {
|
|
self.position -= right_vec * pctx.time_ctx.frame_dt * self.speed;
|
|
}
|
|
if input.key_held(KeyCode::KeyD) {
|
|
self.position += right_vec * pctx.time_ctx.frame_dt * self.speed;
|
|
}
|
|
|
|
scene.world.query_mut::<&mut Camera>().into_iter().for_each(|(_, camera)| {
|
|
camera.eye = self.position;
|
|
camera.center = self.position + front;
|
|
});
|
|
self.mouse_delta = (0.0, 0.0);
|
|
}
|
|
}
|
|
|
|
impl FPSDebugCameraSystem {
|
|
pub fn front(&self) -> Vec3 {
|
|
let yaw_rad = self.yaw.to_radians();
|
|
let pitch_rad = self.pitch.to_radians();
|
|
Vec3::new(
|
|
yaw_rad.cos() * pitch_rad.cos(),
|
|
pitch_rad.sin(),
|
|
yaw_rad.sin() * pitch_rad.cos(),
|
|
).normalize()
|
|
}
|
|
|
|
fn is_camera_mode_valid(&self, scene: &mut Scene) -> bool {
|
|
let mut q = scene.world.query::<(&Camera, &CameraMode)>();
|
|
let (cam_ent, (cam, cam_mode)) = q
|
|
.iter()
|
|
.next()
|
|
.unwrap();
|
|
*cam_mode == CameraMode::Debug
|
|
}
|
|
}
|