Better camera control

src/bin/wireframe/main.rs

@@ -1,3 +1,8 @@
+use std::{
+	collections::HashSet,
+	time::{Instant, SystemTime},
+};
+
 use glam::{mat4, vec2, vec3, vec4, Mat4, Quat, Vec2, Vec3};
 use glium::{
 	backend::glutin::SimpleWindowBuilder,
@@ -5,7 +10,11 @@ use glium::{
 	winit::event::{Event, WindowEvent},
 	Program, Surface, VertexBuffer,
 };
-use winit::{event::ElementState, event_loop::EventLoop};
+use winit::{
+	event::ElementState,
+	event_loop::EventLoop,
+	keyboard::{KeyCode, PhysicalKey},
+};
 
 #[derive(Copy, Clone)]
 struct Vertex {
@@ -53,6 +62,8 @@ fn main() {
 		.with_title("Refraction: Wireframe")
 		.build(&event_loop);
 
+	let mut keys_pressed = HashSet::<PhysicalKey>::new();
+
 	let vs_src = include_str!("ray.v.glsl");
 	let fs_src = include_str!("ray.f.glsl");
 	let program = Program::from_source(&display, vs_src, fs_src, None).unwrap();
@@ -87,21 +98,50 @@ fn main() {
 		0.,
 	);
 	let mut cur_pos = vec2(0., 0.);
-	let mut cam_pos = DragCtl::new(rot * vec3(0., 0., 4.));
+	let mut cam_pos = DragCtl::new(rot * vec3(0., 0., -4.));
-	let mut cam_rot = DragCtl::new(rot.inverse());
+	let mut cam_pos_2 = Vec3::ZERO;
+	let mut cam_rot = DragCtl::new(rot);
+
+	let mut t1 = Instant::now();
 
 	#[allow(deprecated)]
 	event_loop
 		.run(move |ev, window_target| match ev {
 			Event::WindowEvent { event, .. } => match event {
 				WindowEvent::RedrawRequested => {
+					let dt = {
+						let t2 = Instant::now();
+						let dt = t2 - t1;
+						t1 = t2;
+						dt.as_secs_f32()
+					};
+					let v: Vec3 = {
+						let ctl_left =
+							keys_pressed.contains(&PhysicalKey::Code(KeyCode::KeyA)) as i32 as f32;
+						let ctl_right =
+							keys_pressed.contains(&PhysicalKey::Code(KeyCode::KeyD)) as i32 as f32;
+						let ctl_fwd =
+							keys_pressed.contains(&PhysicalKey::Code(KeyCode::KeyW)) as i32 as f32;
+						let ctl_bwd =
+							keys_pressed.contains(&PhysicalKey::Code(KeyCode::KeyS)) as i32 as f32;
+						[
+							ctl_left * vec3(-1., 0., 0.),
+							ctl_right * vec3(1., 0., 0.),
+							ctl_fwd * vec3(0., 0., 1.),
+							ctl_bwd * vec3(0., 0., -1.),
+						]
+						.into_iter()
+						.sum()
+					};
+					cam_pos_2 += 5. * dt * (cam_rot.state() * v);
+
 					let size = window.inner_size();
 					let size = vec2(size.width as f32, size.height as f32).normalize()
 						* std::f32::consts::SQRT_2;
 					let proj = make_proj_matrix(vec3(size.x, size.y, 2.), (0.125, 1024.125));
 
-					let view =
+					let view = Mat4::from_quat(cam_rot.state().inverse())
-						Mat4::from_quat(cam_rot.state()) * Mat4::from_translation(cam_pos.state());
+						* Mat4::from_translation(-(cam_pos.state() + cam_pos_2));
 
 					let mut target = display.draw();
 					target.clear_color(0.0, 0.0, 0.2, 1.0);
@@ -142,14 +182,25 @@ fn main() {
 					cur_pos = vec2(position.x as f32, position.y as f32) / size.length();
 					cam_pos.on_move(cur_pos, |init, off| {
 						window.request_redraw();
-						init + 4. * (cam_rot.state().inverse() * vec3(off.x, -off.y, 0.))
+						init - 4. * (cam_rot.state() * vec3(off.x, -off.y, 0.))
 					});
 					cam_rot.on_move(cur_pos, |init, off| {
 						window.request_redraw();
-						Quat::from_euler(glam::EulerRot::YXZ, 5. * off.x, 5. * off.y, 0.) * init
+						init * Quat::from_euler(glam::EulerRot::YXZ, -2. * off.x, -2. * off.y, 0.)
 					});
 				}
 
+				WindowEvent::KeyboardInput {
+					device_id: _,
+					event,
+					is_synthetic: _,
+				} => {
+					match event.state {
+						ElementState::Pressed => keys_pressed.insert(event.physical_key),
+						ElementState::Released => keys_pressed.remove(&event.physical_key),
+					};
+				}
+
 				WindowEvent::Resized(window_size) => {
 					display.resize(window_size.into());
 				}