kubi/src/fly_controller.rs

@@ -3,31 +3,10 @@ use shipyard::{Component, View, ViewMut, IntoIter, UniqueView, Workload, IntoWor
 use std::f32::consts::PI;
 use crate::{transform::Transform, input::Inputs, settings::GameSettings, delta_time::DeltaTime};
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum PlayerControllerType {
-  FlyCam,
-  FpsCtl,
-}
-
 #[derive(Component)]
-pub struct PlayerController {
+pub struct FlyController;
-  pub control_type: PlayerControllerType,
-  pub speed: f32,
-}
 
-impl PlayerController {
+pub fn update_controllers() -> Workload {
-  pub const DEFAULT_FLY_CAM: Self = Self {
-    control_type: PlayerControllerType::FlyCam,
-    speed: 30.,
-  };
-
-  pub const DEFAULT_FPS_CTL: Self = Self {
-    control_type: PlayerControllerType::FpsCtl,
-    speed: 10.,
-  };
-}
-
-pub fn update_player_controllers() -> Workload {
   (
     update_look,
     update_movement
@@ -37,7 +16,7 @@ pub fn update_player_controllers() -> Workload {
 const MAX_PITCH: f32 = PI/2. - 0.05;
 
 fn update_look(
-  controllers: View<PlayerController>,
+  controllers: View<FlyController>,
   mut transforms: ViewMut<Transform, track::All>,
   inputs: UniqueView<Inputs>,
   settings: UniqueView<GameSettings>,
@@ -57,18 +36,18 @@ fn update_look(
 }
 
 fn update_movement(
-  controllers: View<PlayerController>,
+  controllers: View<FlyController>,
   mut transforms: ViewMut<Transform, track::All>,
   inputs: UniqueView<Inputs>,
   dt: UniqueView<DeltaTime>,
 ) {
   if inputs.movement == Vec2::ZERO { return }
-  let movement = inputs.movement * dt.0.as_secs_f32();
+  let movement = inputs.movement * 30. * dt.0.as_secs_f32();
-  for (ctl, mut transform) in (&controllers, &mut transforms).iter() {
+  for (_, mut transform) in (&controllers, &mut transforms).iter() {
     let (scale, rotation, mut translation) = transform.0.to_scale_rotation_translation();
     let rotation_norm = rotation.normalize();
-    translation += (rotation_norm * Vec3::NEG_Z).normalize() * movement.y * ctl.speed;
+    translation += (rotation_norm * Vec3::NEG_Z).normalize() * movement.y;
-    translation += (rotation_norm * Vec3::X).normalize() * movement.x * ctl.speed;
+    translation += (rotation_norm * Vec3::X).normalize() * movement.x;
     transform.0 = Mat4::from_scale_rotation_translation(scale, rotation_norm, translation);
   }
 }

kubi/src/input.rs

@@ -1,301 +1,297 @@
-use gilrs::{Gilrs, GamepadId, Button, Event, Axis};
+use gilrs::{Gilrs, GamepadId, Button, Event, Axis};
-use glam::{Vec2, DVec2, vec2, dvec2};
+use glam::{Vec2, DVec2, vec2, dvec2};
-use winit::{
+use winit::{
-  keyboard::{KeyCode, PhysicalKey},
+  keyboard::{KeyCode, PhysicalKey},
-  event::{DeviceEvent, DeviceId, ElementState, TouchPhase}
+  event::{DeviceEvent, DeviceId, ElementState, TouchPhase}
-};
+};
-use hashbrown::HashMap;
+use hashbrown::HashMap;
-use tinyset::{SetU32, SetU64};
+use tinyset::{SetU32, SetU64};
-use nohash_hasher::BuildNoHashHasher;
+use nohash_hasher::BuildNoHashHasher;
-use shipyard::{AllStoragesView, Unique, View, IntoIter, UniqueViewMut, Workload, IntoWorkload, UniqueView, NonSendSync};
+use shipyard::{AllStoragesView, Unique, View, IntoIter, UniqueViewMut, Workload, IntoWorkload, UniqueView, NonSendSync};
-use crate::{
+use crate::{
-  events::{InputDeviceEvent, TouchEvent},
+  events::{InputDeviceEvent, TouchEvent},
-  rendering::WindowSize
+  rendering::WindowSize
-};
+};
-
+
-#[derive(Unique, Clone, Copy, Default, Debug)]
+#[derive(Unique, Clone, Copy, Default, Debug)]
-pub struct Inputs {
+pub struct Inputs {
-  pub movement: Vec2,
+  pub movement: Vec2,
-  pub look: Vec2,
+  pub look: Vec2,
-  pub action_a: bool,
+  pub action_a: bool,
-  pub action_b: bool,
+  pub action_b: bool,
-  pub jump: bool,
+}
-}
+
-
+#[derive(Unique, Clone, Copy, Default, Debug)]
-#[derive(Unique, Clone, Copy, Default, Debug)]
+pub struct PrevInputs(pub Inputs);
-pub struct PrevInputs(pub Inputs);
+
-
+#[derive(Unique, Clone, Default, Debug)]
-#[derive(Unique, Clone, Default, Debug)]
+pub struct RawKbmInputState {
-pub struct RawKbmInputState {
+  pub keyboard_state: SetU32,
-  pub keyboard_state: SetU32,
+  pub button_state: [bool; 32],
-  pub button_state: [bool; 32],
+  pub mouse_delta: DVec2
-  pub mouse_delta: DVec2
+}
-}
+
-
+#[derive(Clone, Copy, Debug, Default)]
-#[derive(Clone, Copy, Debug, Default)]
+pub enum FingerCheck {
-pub enum FingerCheck {
+  #[default]
-  #[default]
+  Start,
-  Start,
+  Current,
-  Current,
+  StartOrCurrent,
-  StartOrCurrent,
+  StartAndCurrent,
-  StartAndCurrent,
+  NotMoved,
-  NotMoved,
+}
-}
+
-
+#[derive(Clone, Copy, Debug)]
-#[derive(Clone, Copy, Debug)]
+pub struct Finger {
-pub struct Finger {
+  pub id: u64,
-  pub id: u64,
+  pub device_id: DeviceId,
-  pub device_id: DeviceId,
+  pub prev_position: DVec2,
-  pub prev_position: DVec2,
+  pub start_position: DVec2,
-  pub start_position: DVec2,
+  pub current_position: DVec2,
-  pub current_position: DVec2,
+  pub has_moved: bool,
-  pub has_moved: bool,
+}
-}
+impl Finger {
-impl Finger {
+  pub fn within_area(&self, area_pos: DVec2, area_size: DVec2, check: FingerCheck) -> bool {
-  pub fn within_area(&self, area_pos: DVec2, area_size: DVec2, check: FingerCheck) -> bool {
+    let within_area = |pos: DVec2| -> bool {
-    let within_area = |pos: DVec2| -> bool {
+      ((pos - area_pos).min_element() >= 0.) &&
-      ((pos - area_pos).min_element() >= 0.) &&
+      ((pos - (area_pos + area_size)).max_element() <= 0.)
-      ((pos - (area_pos + area_size)).max_element() <= 0.)
+    };
-    };
+    let start = within_area(self.start_position);
-    let start = within_area(self.start_position);
+    let current = within_area(self.current_position);
-    let current = within_area(self.current_position);
+    match check {
-    match check {
+      FingerCheck::Start => start,
-      FingerCheck::Start => start,
+      FingerCheck::Current => current,
-      FingerCheck::Current => current,
+      FingerCheck::StartOrCurrent => start || current,
-      FingerCheck::StartOrCurrent => start || current,
+      FingerCheck::StartAndCurrent => start && current,
-      FingerCheck::StartAndCurrent => start && current,
+      FingerCheck::NotMoved => current && !self.has_moved,
-      FingerCheck::NotMoved => current && !self.has_moved,
+    }
-    }
+  }
-  }
+}
-}
+
-
+#[derive(Unique, Clone, Default, Debug)]
-#[derive(Unique, Clone, Default, Debug)]
+pub struct RawTouchState {
-pub struct RawTouchState {
+  //TODO: handle multiple touch devices somehow
-  //TODO: handle multiple touch devices somehow
+  pub fingers: HashMap<u64, Finger, BuildNoHashHasher<u64>>
-  pub fingers: HashMap<u64, Finger, BuildNoHashHasher<u64>>
+}
-}
+
-
+impl RawTouchState {
-impl RawTouchState {
+  pub fn query_area(&self, area_pos: DVec2, area_size: DVec2, check: FingerCheck) -> impl Iterator<Item = Finger> + '_ {
-  pub fn query_area(&self, area_pos: DVec2, area_size: DVec2, check: FingerCheck) -> impl Iterator<Item = Finger> + '_ {
+    self.fingers.iter().filter_map(move |(_, &finger)| {
-    self.fingers.iter().filter_map(move |(_, &finger)| {
+      finger.within_area(area_pos, area_size, check).then_some(finger)
-      finger.within_area(area_pos, area_size, check).then_some(finger)
+    })
-    })
+  }
-  }
+}
-}
+
-
+#[derive(Unique)]
-#[derive(Unique)]
+pub struct GilrsWrapper(Option<Gilrs>);
-pub struct GilrsWrapper(Option<Gilrs>);
+
-
+#[derive(Unique, Default, Clone, Copy)]
-#[derive(Unique, Default, Clone, Copy)]
+pub struct ActiveGamepad(Option<GamepadId>);
-pub struct ActiveGamepad(Option<GamepadId>);
+
-
+//maybe we should manage gamepad state ourselves just like keyboard?
-//maybe we should manage gamepad state ourselves just like keyboard?
+//at least for the sake of consitency
-//at least for the sake of consitency
+
-
+fn process_events(
-fn process_events(
+  device_events: View<InputDeviceEvent>,
-  device_events: View<InputDeviceEvent>,
+  mut input_state: UniqueViewMut<RawKbmInputState>,
-  mut input_state: UniqueViewMut<RawKbmInputState>,
+) {
-) {
+  input_state.mouse_delta = DVec2::ZERO;
-  input_state.mouse_delta = DVec2::ZERO;
+  for event in device_events.iter() {
-  for event in device_events.iter() {
+    match &event.event {
-    match &event.event {
+      DeviceEvent::MouseMotion { delta } => {
-      DeviceEvent::MouseMotion { delta } => {
+        input_state.mouse_delta = DVec2::from(*delta);
-        input_state.mouse_delta = DVec2::from(*delta);
+      },
-      },
+      DeviceEvent::Key(input) => {
-      DeviceEvent::Key(input) => {
+        if let PhysicalKey::Code(code) = input.physical_key {
-        if let PhysicalKey::Code(code) = input.physical_key {
+          match input.state {
-          match input.state {
+            ElementState::Pressed  => input_state.keyboard_state.insert(code as u32),
-            ElementState::Pressed  => input_state.keyboard_state.insert(code as u32),
+            ElementState::Released => input_state.keyboard_state.remove(code as u32),
-            ElementState::Released => input_state.keyboard_state.remove(code as u32),
+          };
-          };
+        }
-        }
+      },
-      },
+      DeviceEvent::Button { button, state } => {
-      DeviceEvent::Button { button, state } => {
+        if *button < 32 {
-        if *button < 32 {
+          input_state.button_state[*button as usize] = matches!(*state, ElementState::Pressed);
-          input_state.button_state[*button as usize] = matches!(*state, ElementState::Pressed);
+        }
-        }
+      },
-      },
+      _ => ()
-      _ => ()
+    }
-    }
+  }
-  }
+}
-}
+
-
+fn process_touch_events(
-fn process_touch_events(
+  touch_events: View<TouchEvent>,
-  touch_events: View<TouchEvent>,
+  mut touch_state: UniqueViewMut<RawTouchState>,
-  mut touch_state: UniqueViewMut<RawTouchState>,
+) {
-) {
+  for (_, finger) in &mut touch_state.fingers {
-  for (_, finger) in &mut touch_state.fingers {
+    finger.prev_position = finger.current_position;
-    finger.prev_position = finger.current_position;
+  }
-  }
+  for event in touch_events.iter() {
-  for event in touch_events.iter() {
+    let position = dvec2(event.0.location.x, event.0.location.y);
-    let position = dvec2(event.0.location.x, event.0.location.y);
+    match event.0.phase {
-    match event.0.phase {
+      TouchPhase::Started => {
-      TouchPhase::Started => {
+        //println!("touch started: finger {}", event.0.id);
-        //println!("touch started: finger {}", event.0.id);
+        touch_state.fingers.insert(event.0.id, Finger {
-        touch_state.fingers.insert(event.0.id, Finger {
+          id: event.0.id,
-          id: event.0.id,
+          device_id: event.0.device_id,
-          device_id: event.0.device_id,
+          start_position: position,
-          start_position: position,
+          current_position: position,
-          current_position: position,
+          prev_position: position,
-          prev_position: position,
+          has_moved: false
-          has_moved: false
+        });
-        });
+      },
-      },
+      TouchPhase::Moved => {
-      TouchPhase::Moved => {
+        if let Some(finger) = touch_state.fingers.get_mut(&event.0.id) {
-        if let Some(finger) = touch_state.fingers.get_mut(&event.0.id) {
+          finger.has_moved = true;
-          finger.has_moved = true;
+          finger.current_position = position;
-          finger.current_position = position;
+        }
-        }
+      },
-      },
+      TouchPhase::Ended | TouchPhase::Cancelled => {
-      TouchPhase::Ended | TouchPhase::Cancelled => {
+        //println!("touch ended: finger {}", event.0.id);
-        //println!("touch ended: finger {}", event.0.id);
+        touch_state.fingers.remove(&event.0.id);
-        touch_state.fingers.remove(&event.0.id);
+      },
-      },
+    }
-    }
+  }
-  }
+}
-}
+
-
+fn process_gilrs_events(
-fn process_gilrs_events(
+  mut gilrs: NonSendSync<UniqueViewMut<GilrsWrapper>>,
-  mut gilrs: NonSendSync<UniqueViewMut<GilrsWrapper>>,
+  mut active_gamepad: UniqueViewMut<ActiveGamepad>
-  mut active_gamepad: UniqueViewMut<ActiveGamepad>
+) {
-) {
+  if let Some(gilrs) = &mut gilrs.0 {
-  if let Some(gilrs) = &mut gilrs.0 {
+    while let Some(Event { id, event: _, time: _ }) = gilrs.next_event() {
-    while let Some(Event { id, event: _, time: _ }) = gilrs.next_event() {
+      active_gamepad.0 = Some(id);
-      active_gamepad.0 = Some(id);
+    }
-    }
+  }
-  }
+}
-}
+
-
+fn input_start(
-fn input_start(
+  mut inputs: UniqueViewMut<Inputs>,
-  mut inputs: UniqueViewMut<Inputs>,
+  mut prev_inputs: UniqueViewMut<PrevInputs>,
-  mut prev_inputs: UniqueViewMut<PrevInputs>,
+) {
-) {
+  prev_inputs.0 = *inputs;
-  prev_inputs.0 = *inputs;
+  *inputs = Inputs::default();
-  *inputs = Inputs::default();
+}
-}
+
-
+fn update_input_state (
-fn update_input_state (
+  raw_inputs: UniqueView<RawKbmInputState>,
-  raw_inputs: UniqueView<RawKbmInputState>,
+  mut inputs: UniqueViewMut<Inputs>,
-  mut inputs: UniqueViewMut<Inputs>,
+) {
-) {
+  inputs.movement += Vec2::new(
-  inputs.movement += Vec2::new(
+    raw_inputs.keyboard_state.contains(KeyCode::KeyD as u32) as u32 as f32 -
-    raw_inputs.keyboard_state.contains(KeyCode::KeyD as u32) as u32 as f32 -
+    raw_inputs.keyboard_state.contains(KeyCode::KeyA as u32) as u32 as f32,
-    raw_inputs.keyboard_state.contains(KeyCode::KeyA as u32) as u32 as f32,
+    raw_inputs.keyboard_state.contains(KeyCode::KeyW as u32) as u32 as f32 -
-    raw_inputs.keyboard_state.contains(KeyCode::KeyW as u32) as u32 as f32 -
+    raw_inputs.keyboard_state.contains(KeyCode::KeyS as u32) as u32 as f32
-    raw_inputs.keyboard_state.contains(KeyCode::KeyS as u32) as u32 as f32
+  );
-  );
+  inputs.look += raw_inputs.mouse_delta.as_vec2();
-  inputs.look += raw_inputs.mouse_delta.as_vec2();
+  inputs.action_a |= raw_inputs.button_state[0];
-  inputs.action_a |= raw_inputs.button_state[0];
+  inputs.action_b |= raw_inputs.button_state[1];
-  inputs.action_b |= raw_inputs.button_state[1];
+}
-  inputs.jump |= raw_inputs.button_state[2];
+
-}
+fn update_input_state_gamepad (
-
+  gilrs: NonSendSync<UniqueView<GilrsWrapper>>,
-fn update_input_state_gamepad (
+  active_gamepad: UniqueView<ActiveGamepad>,
-  gilrs: NonSendSync<UniqueView<GilrsWrapper>>,
+  mut inputs: UniqueViewMut<Inputs>,
-  active_gamepad: UniqueView<ActiveGamepad>,
+) {
-  mut inputs: UniqueViewMut<Inputs>,
+  if let Some(gilrs) = &gilrs.0 {
-) {
+    if let Some(gamepad) = active_gamepad.0.map(|id| gilrs.gamepad(id)) {
-  if let Some(gilrs) = &gilrs.0 {
+      let left_stick = vec2(gamepad.value(Axis::LeftStickX), gamepad.value(Axis::LeftStickY));
-    if let Some(gamepad) = active_gamepad.0.map(|id| gilrs.gamepad(id)) {
+      let right_stick = vec2(gamepad.value(Axis::RightStickX), -gamepad.value(Axis::RightStickY));
-      let left_stick = vec2(gamepad.value(Axis::LeftStickX), gamepad.value(Axis::LeftStickY));
+      inputs.movement += left_stick;
-      let right_stick = vec2(gamepad.value(Axis::RightStickX), -gamepad.value(Axis::RightStickY));
+      inputs.look += right_stick;
-      inputs.movement += left_stick;
+      inputs.action_a |= gamepad.is_pressed(Button::South);
-      //HACK: for now, we multiply look by 2 to make it feel more responsive
+      inputs.action_b |= gamepad.is_pressed(Button::East);
-      inputs.look += right_stick * 2.;
+    }
-      inputs.action_a |= gamepad.is_pressed(Button::West);
+  }
-      inputs.action_b |= gamepad.is_pressed(Button::East);
+}
-      inputs.jump |= gamepad.is_pressed(Button::South);
+
-    }
+fn update_input_state_touch (
-  }
+  touch_state: UniqueView<RawTouchState>,
-}
+  win_size: UniqueView<WindowSize>,
-
+  mut inputs: UniqueViewMut<Inputs>,
-fn update_input_state_touch (
+) {
-  touch_state: UniqueView<RawTouchState>,
+  let w = win_size.0.as_dvec2();
-  win_size: UniqueView<WindowSize>,
+
-  mut inputs: UniqueViewMut<Inputs>,
+  //Movement
-) {
+  if let Some(finger) = touch_state.query_area(
-  let w = win_size.0.as_dvec2();
+    dvec2(0., 0.),
-
+    dvec2(w.x / 2., w.y),
-  //Movement
+    FingerCheck::Start
-  if let Some(finger) = touch_state.query_area(
+  ).next() {
-    dvec2(0., 0.),
+    inputs.movement += (((finger.current_position - finger.start_position) / (w.x / 4.)) * dvec2(1., -1.)).as_vec2();
-    dvec2(w.x / 2., w.y),
+  }
-    FingerCheck::Start
+
-  ).next() {
+  //Action buttons
-    inputs.movement += (((finger.current_position - finger.start_position) / (w.x / 4.)) * dvec2(1., -1.)).as_vec2();
+  let action_button_fingers = {
-  }
+    let mut action_button_fingers = SetU64::new();
-
+
-  //Action buttons
+    //Creates iterator of fingers that started within action button area
-  let action_button_fingers = {
+    let action_finger_iter = || touch_state.query_area(
-    let mut action_button_fingers = SetU64::new();
+      dvec2(w.x * 0.75, w.y * 0.666),
-
+      dvec2(w.x * 0.25, w.y * 0.333),
-    //Creates iterator of fingers that started within action button area
+      FingerCheck::Start
-    let action_finger_iter = || touch_state.query_area(
+    );
-      dvec2(w.x * 0.75, w.y * 0.666),
+
-      dvec2(w.x * 0.25, w.y * 0.333),
+    //Action button A
-      FingerCheck::Start
+    inputs.action_a |= action_finger_iter().filter(|finger| finger.within_area(
-    );
+      dvec2(w.x * (0.75 + 0.125), w.y * 0.666),
-
+      dvec2(w.x * 0.125, w.y * 0.333),
-    //Action button A
+      FingerCheck::StartOrCurrent
-    inputs.action_a |= action_finger_iter().filter(|finger| finger.within_area(
+    )).map(|x| action_button_fingers.insert(x.id)).next().is_some();
-      dvec2(w.x * (0.75 + 0.125), w.y * 0.666),
+    
-      dvec2(w.x * 0.125, w.y * 0.333),
+    //Action button B
-      FingerCheck::StartOrCurrent
+    inputs.action_b |= action_finger_iter().filter(|finger| finger.within_area(
-    )).map(|x| action_button_fingers.insert(x.id)).next().is_some();
+      dvec2(w.x * 0.75, w.y * 0.666),
-    
+      dvec2(w.x * 0.125, w.y * 0.333),
-    //Action button B
+      FingerCheck::StartOrCurrent
-    inputs.action_b |= action_finger_iter().filter(|finger| finger.within_area(
+    )).map(|x| action_button_fingers.insert(x.id)).next().is_some();
-      dvec2(w.x * 0.75, w.y * 0.666),
+
-      dvec2(w.x * 0.125, w.y * 0.333),
+    action_button_fingers
-      FingerCheck::StartOrCurrent
+  };
-    )).map(|x| action_button_fingers.insert(x.id)).next().is_some();
+
-
+  //Camera controls
-    action_button_fingers
+  if let Some(finger) = touch_state.query_area(
-  };
+    dvec2(w.x / 2., 0.),
-
+    dvec2(w.x / 2., w.y),
-  //Camera controls
+    FingerCheck::Start
-  if let Some(finger) = touch_state.query_area(
+  ).find(|x| !action_button_fingers.contains(x.id)) {
-    dvec2(w.x / 2., 0.),
+    inputs.look += (((finger.current_position - finger.prev_position) / (w.x / 4.)) * 300.).as_vec2();
-    dvec2(w.x / 2., w.y),
+  }
-    FingerCheck::Start
+}
-  ).find(|x| !action_button_fingers.contains(x.id)) {
+
-    inputs.look += (((finger.current_position - finger.prev_position) / (w.x / 4.)) * 300.).as_vec2();
+fn input_end(
-  }
+  mut inputs: UniqueViewMut<Inputs>,
-}
+) {
-
+  if inputs.movement.length() >= 1. {
-fn input_end(
+    inputs.movement = inputs.movement.normalize();
-  mut inputs: UniqueViewMut<Inputs>,
+  }
-) {
+}
-  if inputs.movement.length() >= 1. {
+
-    inputs.movement = inputs.movement.normalize();
+pub fn init_input (
-  }
+  storages: AllStoragesView
-}
+) {
-
+  storages.add_unique_non_send_sync(GilrsWrapper(
-pub fn init_input (
+    Gilrs::new().map_err(|x| {
-  storages: AllStoragesView
+      log::error!("Failed to initialize Gilrs");
-) {
+      x
-  storages.add_unique_non_send_sync(GilrsWrapper(
+    }).ok()
-    Gilrs::new().map_err(|x| {
+  ));
-      log::error!("Failed to initialize Gilrs");
+  storages.add_unique(ActiveGamepad::default());
-      x
+  storages.add_unique(Inputs::default());
-    }).ok()
+  storages.add_unique(PrevInputs::default());
-  ));
+  storages.add_unique(RawKbmInputState::default());
-  storages.add_unique(ActiveGamepad::default());
+  storages.add_unique(RawTouchState::default());
-  storages.add_unique(Inputs::default());
+}
-  storages.add_unique(PrevInputs::default());
+
-  storages.add_unique(RawKbmInputState::default());
+pub fn process_inputs() -> Workload {
-  storages.add_unique(RawTouchState::default());
+  (
-}
+    process_events,
-
+    process_touch_events,
-pub fn process_inputs() -> Workload {
+    process_gilrs_events,
-  (
+    input_start,
-    process_events,
+    update_input_state,
-    process_touch_events,
+    update_input_state_touch,
-    process_gilrs_events,
+    update_input_state_gamepad,
-    input_start,
+    input_end,
-    update_input_state,
+  ).into_sequential_workload()
-    update_input_state_touch,
+}
-    update_input_state_gamepad,
-    input_end,
-  ).into_sequential_workload()
-}

kubi/src/lib.rs

@@ -23,7 +23,7 @@ pub(crate) mod settings;
 pub(crate) mod camera;
 pub(crate) mod events;
 pub(crate) mod input;
-pub(crate) mod player_controller;
+pub(crate) mod fly_controller;
 pub(crate) mod block_placement;
 pub(crate) mod delta_time;
 pub(crate) mod cursor_lock;
@@ -57,7 +57,7 @@ use events::{
   player_actions::generate_move_events, 
 };
 use input::{init_input, process_inputs};
-use player_controller::update_player_controllers;
+use fly_controller::update_controllers;
 use rendering::{
   Renderer, 
   RenderTarget, 
@@ -133,7 +133,7 @@ fn update() -> Workload {
       update_loaded_world_around_player,
     ).into_sequential_workload().run_if(is_ingame_or_loading),
     (
-      update_player_controllers,
+      update_controllers,
       update_client_physics_late,
       generate_move_events,
       update_raycasts,

kubi/src/player.rs

@@ -12,7 +12,7 @@ use kubi_shared::{
 use crate::{
   camera::Camera,
   client_physics::ClPhysicsActor,
-  player_controller::PlayerController,
+  fly_controller::FlyController,
   transform::Transform,
   world::raycast::LookingAtBlock
 };
@@ -31,7 +31,7 @@ pub fn spawn_player (
     Health::new(PLAYER_HEALTH),
     Transform::default(),
     Camera::default(),
-    PlayerController::DEFAULT_FPS_CTL,
+    FlyController,
     LookingAtBlock::default(),
     PlayerHolding(Some(Block::Cobblestone)),
     Username("LocalPlayer".into()),
@@ -53,7 +53,7 @@ pub fn spawn_local_player_multiplayer (
     init.health,
     Transform(Mat4::from_rotation_translation(init.direction, init.position)),
     Camera::default(),
-    PlayerController::DEFAULT_FPS_CTL,
+    FlyController,
     LookingAtBlock::default(),
     PlayerHolding::default(),
   ),(