cyborg
/
cyborg
2
2
Fork 0
Code Issues 19 Pull Requests 1 Projects Releases Wiki Activity

Merge pull request 'Flycam rewrite' (#7) from turtle1331/cyborg:flycam-rewrite into main 

Reviewed-on: #7
This commit is contained in:
mars 2022-03-18 05:26:23 +00:00
parent f88e3e7158 15bca6a6ca
commit 607730fb83
2 changed files with 116 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

164
src/camera.rs
View File

@ -1,6 +1,7 @@
use glam::{Mat4, Quat, Vec2, Vec3};
use std::time::Instant;
use winit::event::{ElementState, VirtualKeyCode};
use std::f32::consts::LN_2;
pub trait Camera {
fn get_eye(&self) -> [f32; 4];
@ -9,22 +10,35 @@ pub trait Camera {
pub struct Flycam {
// input
is_up_pressed: bool,
is_down_pressed: bool,
// currently held keys
is_world_up_pressed: bool,
is_world_down_pressed: bool,
is_cam_up_pressed: bool,
is_cam_down_pressed: bool,
is_forward_pressed: bool,
is_backward_pressed: bool,
is_left_pressed: bool,
is_right_pressed: bool,
// accumulated mouse movement yet to be processed
mouse_dx: f32,
mouse_dy: f32,
// state
// timestamp
last_update: Instant,
pan: f32,
tilt: f32,
// camera orientation
euler_x: f32,
euler_y: f32,
// camera movement state
velocity: Vec3,
position: Vec3,
// constants
speed: f32,
turn_speed: f32,
// camera movement
turn_sensitivity: f32, // coefficient for mouse_dx/dy -> euler_x/y
thrust_mag: f32, // coefficient for thrust acceleration vector
damping_coeff: f32, // coefficient for damping acceleration vector
// camera frustum
aspect: f32,
fovy: f32,
znear: f32,
@ -32,10 +46,14 @@ pub struct Flycam {
}
impl Flycam {
pub fn new(speed: f32, turn_speed: f32) -> Self {
/// thrust_speed: top speed when using a single thruster, in units/second
/// duration to halve difference between current and target velocity, in seconds
pub fn new(turn_sensitivity: f32, thrust_speed: f32, damper_half_life: f32) -> Self {
Self {
is_up_pressed: false,
is_down_pressed: false,
is_world_up_pressed: false,
is_world_down_pressed: false,
is_cam_up_pressed: false,
is_cam_down_pressed: false,
is_forward_pressed: false,
is_backward_pressed: false,
is_left_pressed: false,
@ -43,11 +61,13 @@ impl Flycam {
mouse_dx: 0.0,
mouse_dy: 0.0,
last_update: Instant::now(),
pan: 0.0,
tilt: 0.0,
euler_x: 0.0,
euler_y: 0.0,
velocity: Vec3::new(0.0, 0.0, 0.0),
position: Vec3::new(0.0, 0.5, 1.0),
speed,
turn_speed,
turn_sensitivity,
thrust_mag: thrust_speed / damper_half_life * LN_2,
damping_coeff: LN_2 / damper_half_life,
aspect: 1.0, // TODO compute from size
fovy: std::f32::consts::FRAC_PI_2,
znear: 0.01,
@ -57,14 +77,21 @@ impl Flycam {
}
impl Flycam {
/// update stored keyboard state for use in update()
pub fn process_keyboard(&mut self, key: VirtualKeyCode, state: ElementState) {
let is_pressed = state == ElementState::Pressed;
match key {
VirtualKeyCode::Space => {
self.is_up_pressed = is_pressed;
self.is_world_up_pressed = is_pressed;
}
VirtualKeyCode::LShift => {
self.is_down_pressed = is_pressed;
self.is_world_down_pressed = is_pressed;
}
VirtualKeyCode::Q => {
self.is_cam_down_pressed = is_pressed;
}
VirtualKeyCode::E => {
self.is_cam_up_pressed = is_pressed;
}
VirtualKeyCode::W | VirtualKeyCode::Up => {
self.is_forward_pressed = is_pressed;
@ -82,6 +109,7 @@ impl Flycam {
}
}
/// update accumulated mouse movement for use in update()
pub fn process_mouse(&mut self, mouse_dx: f64, mouse_dy: f64) {
self.mouse_dx += mouse_dx as f32;
self.mouse_dy += mouse_dy as f32;
@ -91,60 +119,94 @@ impl Flycam {
self.aspect = (width as f32) / (height as f32);
}
/// apply input and update camera movement
pub fn update(&mut self) {
let dt = self.last_update.elapsed();
self.last_update = Instant::now();
let dt = dt.as_micros() as f32 / 1_000_000.0;
let t = self.turn_speed;
self.pan += t * self.mouse_dx;
self.tilt += t * self.mouse_dy;
self.update_orientation(dt);
self.update_kinematic(dt);
}
fn update_orientation(&mut self, dt: f32) {
let t = self.turn_sensitivity;
self.euler_x -= t * self.mouse_dy; // mouse +y = 2D plane down = look down = 3d space -x
self.euler_y -= t * self.mouse_dx; // mouse +x = 2D plane right = look to the right = 3d space -y
self.mouse_dx = 0.0;
self.mouse_dy = 0.0;
let tilt_limit = std::f32::consts::FRAC_PI_2;
if self.tilt < -tilt_limit {
self.tilt = -tilt_limit;
} else if self.tilt > tilt_limit {
self.tilt = tilt_limit;
// Clamp euler_x to [-pi/2, pi/2]
let euler_x_limit = std::f32::consts::FRAC_PI_2;
if self.euler_x < -euler_x_limit {
self.euler_x = -euler_x_limit;
} else if self.euler_x > euler_x_limit {
self.euler_x = euler_x_limit;
}
let s = dt * self.speed;
let axis = Self::key_axis;
let truck = s * axis(self.is_backward_pressed, self.is_forward_pressed);
let dolly = s * axis(self.is_right_pressed, self.is_left_pressed);
let boom = s * axis(self.is_down_pressed, self.is_up_pressed);
self.move_position(truck, dolly, boom);
}
/// update velocity and position from acceleration using forward differences
fn update_kinematic(&mut self, dt: f32) {
let net_acc = self.get_thrust_acc() + self.get_damping_acc();
let delta_vel = net_acc * dt;
self.velocity += delta_vel;
let delta_pos = self.velocity * dt;
self.position += delta_pos;
}
/// use keyboard key pairs to trigger directional thrusters in camera and world coordinates
/// thrust_speed is the max speed (under drag) with a single thruster, but combinations can
/// produce higher speeds (e.g. forward and right, camera down and world down)
fn get_thrust_acc(&self) -> glam::Vec3 {
let axis = Self::key_axis;
let thruster_cam_x = axis(self.is_left_pressed, self.is_right_pressed);
let thruster_cam_y = axis(self.is_cam_down_pressed, self.is_cam_up_pressed);
let thruster_cam_z = -axis(self.is_backward_pressed, self.is_forward_pressed); // forward is -z
let thruster_world_y = axis(self.is_world_down_pressed, self.is_world_up_pressed);
let thrusters_cam = Vec3::new(thruster_cam_x, thruster_cam_y, thruster_cam_z);
let thrusters_world = Vec3::new(0.0, thruster_world_y, 0.0);
let cam_to_world = self.get_orientation();
let thrusters_total = thrusters_world + cam_to_world * thrusters_cam;
self.thrust_mag * thrusters_total
}
/// calculate a damping force (proportional to velocity)
/// the damping coefficient is calculated in the constructor, which is parameterized in terms
/// of more physically meaningful values
fn get_damping_acc(&self) -> glam::Vec3 {
self.damping_coeff * -self.velocity
}
/// a helper function to turn a pair of key states into a sign for thruster direction
fn key_axis(negative: bool, positive: bool) -> f32 {
if negative {
if positive {
0.0
0.0 // positive + negative cancel out
} else {
-1.0
-1.0 // negative only
}
} else {
if positive {
1.0
1.0 // positive only
} else {
0.0
0.0 // neutral
}
}
}
fn move_position(&mut self, truck: f32, dolly: f32, boom: f32) {
// truck direction from straight down
let h = Vec2::new(self.pan.sin(), -self.pan.cos());
// truck direction from the side
let v = Vec2::new(self.tilt.cos(), -self.tilt.sin());
// composite to get forward direction
let truck_to = Vec3::new(h.x * v.x, v.y, h.y * v.x);
let dolly_to = Vec3::new(-self.pan.cos(), 0.0, -self.pan.sin());
self.position += (truck_to * truck) + (dolly_to * dolly);
self.position.y += boom;
/// the current camera orientation, which can be seen as a rotation (in quaternion form) from
/// camera axes to world axes
/// glam's YXZ ordering matches the standard roll-pitch-yaw Euler angles
fn get_orientation(&self) -> glam::Quat {
Quat::from_euler(glam::EulerRot::YXZ, self.euler_y, self.euler_x, 0.0)
}
}
@ -154,10 +216,14 @@ impl Camera for Flycam {
}
fn get_vp(&self) -> [[f32; 4]; 4] {
let orientation = Quat::from_euler(glam::EulerRot::XYZ, self.tilt, self.pan, 0.0);
let rotation = Mat4::from_quat(orientation);
let view = rotation * Mat4::from_translation(-self.position);
// view matrix is inverted camera pose (world space to camera space)
let rotation = Mat4::from_quat(self.get_orientation().inverse());
let translation = Mat4::from_translation(-self.position);
let view = rotation * translation;
// perspective projection
let proj = Mat4::perspective_rh_gl(self.fovy, self.aspect, self.znear, self.zfar);
let vp = proj * view;
vp.to_cols_array_2d()
}

2
src/main.rs
View File

@ -149,7 +149,7 @@ async fn make_window_renderer(window: &winit::window::Window) -> Renderer {
fn main() {
let event_loop = EventLoop::new();
let window = WindowBuilder::new().build(&event_loop).unwrap();
let mut camera = Flycam::new(10.0, 0.002);
let mut camera = Flycam::new(0.002, 10.0, 0.25);
let mut is_grabbed = false;
let mut ren = pollster::block_on(make_window_renderer(&window));
// let mut state: Box<dyn WorldState> = Box::new(Planets::new(&mut ren));