hodasemi/engine
1
1
Fork 0
Code Issues 3 Pull requests 1 Projects Releases Wiki Activity Actions

Start reworking event system

Browse source
This commit is contained in:
Michael Hübner 2025-03-03 09:47:37 +01:00
parent 52dcbc6353
commit ae1e06d52e
9 changed files with 201 additions and 313 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
context/src/core/context.rs
View file

@ -60,7 +60,7 @@ impl Context {
pub fn next_frame<C, F>(&mut self, world: &mut World, mut f: F) -> Result<bool> pub fn next_frame<C, F>(&mut self, world: &mut World, mut f: F) -> Result<bool>
where where
C: Send + Sync + 'static, C: Send + Sync + 'static,
F: FnMut(&mut World, &mut C, Event) -> Result<()> + Send + Sync + 'static, F: FnMut(&mut World, &mut C, Event<'_>) -> Result<()> + Send + Sync + 'static,
{ {
let render_core = self.render_core.clone(); let render_core = self.render_core.clone();
let consumer = world.resources.get_mut_unchecked::<C>(); let consumer = world.resources.get_mut_unchecked::<C>();
@ -116,19 +116,9 @@ impl Context {
self.core.queue() self.core.queue()
} }
pub fn controllers(&self) -> &[Arc<RwLock<Controller>>] { pub fn controllers(&self) -> impl Iterator<Item = &Controller> {
self.presentation.event_system().controllers() self.presentation.event_system().controllers()
} }
pub fn active_controller(&self) -> &Option<Arc<RwLock<Controller>>> {
self.presentation.event_system().active_controller()
}
pub fn set_active_controller(&mut self, controller: &Arc<RwLock<Controller>>) {
self.presentation
.event_system_mut()
.set_active_controller(controller)
}
} }
impl std::fmt::Debug for Context { impl std::fmt::Debug for Context {

32
engine/src/engine/engine_event_handling.rs
View file

@ -1,14 +1,9 @@
use crate::prelude::*; use crate::prelude::*;
use anyhow::Result; use anyhow::Result;
use std::collections::HashMap; use std::collections::HashMap;
use std::sync::{Arc, RwLock};
// use super::engine_object_data::{EngineObjectAccess, EngineObjectDataHandle};
#[derive(Debug)] #[derive(Debug)]
pub enum EngineEvent { pub enum EngineEvent<'a> {
MouseMotion(u32, u32), MouseMotion(u32, u32),
MouseButtonDown(MouseButton), MouseButtonDown(MouseButton),
MouseButtonUp(MouseButton), MouseButtonUp(MouseButton),
@ -21,14 +16,14 @@ pub enum EngineEvent {
ButtonUp(ControllerButton), ButtonUp(ControllerButton),
ControllerAxis(ControllerAxis), ControllerAxis(ControllerAxis),
ControllerAdded(Arc<RwLock<Controller>>), ControllerAdded(&'a Controller),
ControllerRemoved(Arc<RwLock<Controller>>), ControllerRemoved(&'a Controller),
FileDrop(String), FileDrop(String),
} }
pub trait EventConsumer: Send + Sync + 'static { pub trait EventConsumer: Send + Sync + 'static {
fn event(&mut self, world: &mut World, event: EngineEvent) -> Result<()>; fn event(&mut self, world: &mut World, event: EngineEvent<'_>) -> Result<()>;
} }
pub struct InputMap { pub struct InputMap {
@ -42,7 +37,7 @@ impl Engine {
gui_handler: &GuiHandler, gui_handler: &GuiHandler,
input: &InputMap, input: &InputMap,
consumer: &mut T, consumer: &mut T,
event: Event, event: Event<'_>,
) -> anyhow::Result<()> { ) -> anyhow::Result<()> {
match event { match event {
Event::MouseMotion(x, y) => { Event::MouseMotion(x, y) => {
@ -71,15 +66,13 @@ impl Engine {
Event::TextInput(text) => { Event::TextInput(text) => {
Self::text_input(gui_handler, text)?; Self::text_input(gui_handler, text)?;
} }
Event::ControllerButtonDown(button) => { Event::ControllerButtonDown(_controller, button) => {
Self::button_down_event(world, gui_handler, consumer, button)?; Self::button_down_event(world, gui_handler, consumer, button)?;
} }
Event::ControllerButtonUp(button) => { Event::ControllerButtonUp(_controller, button) => {
Self::button_up_event(world, consumer, button)?; Self::button_up_event(world, consumer, button)?;
} }
Event::ControllerAxis(controller) => { Event::ControllerAxis(controller) => {
let controller = controller.read().unwrap();
if !gui_handler.check_navigatable()? { if !gui_handler.check_navigatable()? {
Self::axis_event(world, consumer, &controller)? Self::axis_event(world, consumer, &controller)?
} else { } else {
@ -92,6 +85,13 @@ impl Engine {
Event::ControllerRemoved(controller) => { Event::ControllerRemoved(controller) => {
Self::controller_removed(world, consumer, controller)? Self::controller_removed(world, consumer, controller)?
} }
Event::JoystickAxis(_joystick) => todo!(),
Event::JoystickButtonDown(_joystick) => todo!(),
Event::JoystickButtonUp(_joystick) => todo!(),
Event::JoystickAdded(_joystick) => todo!(),
Event::JoystickRemoved(_joystick) => todo!(),
Event::FileDrop(filename) => consumer.event(world, EngineEvent::FileDrop(filename))?, Event::FileDrop(filename) => consumer.event(world, EngineEvent::FileDrop(filename))?,
} }
@ -104,7 +104,7 @@ impl Engine {
fn controller_added<T: EventConsumer>( fn controller_added<T: EventConsumer>(
world: &mut World, world: &mut World,
consumer: &mut T, consumer: &mut T,
controller: Arc<RwLock<Controller>>, controller: &Controller,
) -> Result<()> { ) -> Result<()> {
consumer.event(world, EngineEvent::ControllerAdded(controller))?; consumer.event(world, EngineEvent::ControllerAdded(controller))?;
@ -115,7 +115,7 @@ impl Engine {
fn controller_removed<T: EventConsumer>( fn controller_removed<T: EventConsumer>(
world: &mut World, world: &mut World,
consumer: &mut T, consumer: &mut T,
controller: Arc<RwLock<Controller>>, controller: &Controller,
) -> Result<()> { ) -> Result<()> {
consumer.event(world, EngineEvent::ControllerRemoved(controller))?; consumer.event(world, EngineEvent::ControllerRemoved(controller))?;

96
engine/src/engine/engine_settings.rs
View file

@ -205,7 +205,7 @@ impl EngineSettings {
button: ControllerButton, button: ControllerButton,
) -> Result<Option<Arc<Image>>> { ) -> Result<Option<Arc<Image>>> {
// TODO: don't check it every time we request a button // TODO: don't check it every time we request a button
self.check_controller(context)?; // self.check_controller(context)?;
match self.current_controller_type.read().unwrap().as_ref() { match self.current_controller_type.read().unwrap().as_ref() {
Some(controller_type) => Ok(Some(self.controller_button_for( Some(controller_type) => Ok(Some(self.controller_button_for(
@ -347,61 +347,61 @@ impl EngineSettings {
} }
} }
fn check_controller(&self, context: &Context) -> Result<()> { // fn check_controller(&self, context: &Context) -> Result<()> {
let active_controller = context.active_controller(); // let active_controller = context.active_controller();
match &active_controller { // match &active_controller {
// there is an controller connected // // there is an controller connected
Some(controller) => { // Some(controller) => {
let controller_name = controller.read().unwrap().name().clone(); // let controller_name = controller.read().unwrap().name().clone();
// predict controller type from name // // predict controller type from name
let controller_type = if controller_name.contains("PS4") { // let controller_type = if controller_name.contains("PS4") {
ControllerType::PS4 // ControllerType::PS4
} else if controller_name.contains("Steam") { // } else if controller_name.contains("Steam") {
ControllerType::Steam // ControllerType::Steam
} else { // } else {
ControllerType::XBox // ControllerType::XBox
}; // };
let mut current_controller_type = self.current_controller_type.write().unwrap(); // let mut current_controller_type = self.current_controller_type.write().unwrap();
// check if current controller type is set // // check if current controller type is set
if current_controller_type.is_some() { // if current_controller_type.is_some() {
// if controller type is set, check if it is different // // if controller type is set, check if it is different
if *current_controller_type.as_ref().unwrap() != controller_type { // if *current_controller_type.as_ref().unwrap() != controller_type {
*current_controller_type = Some(controller_type); // *current_controller_type = Some(controller_type);
let mut map = self.controller_buttons.write().unwrap(); // let mut map = self.controller_buttons.write().unwrap();
// clear map if filled // // clear map if filled
if !map.is_empty() { // if !map.is_empty() {
map.clear(); // map.clear();
} // }
} // }
} else { // } else {
// set the controller type // // set the controller type
*current_controller_type = Some(controller_type); // *current_controller_type = Some(controller_type);
} // }
} // }
// there is no controller connected // // there is no controller connected
None => { // None => {
let mut current_controller_type = self.current_controller_type.write().unwrap(); // let mut current_controller_type = self.current_controller_type.write().unwrap();
let mut map = self.controller_buttons.write().unwrap(); // let mut map = self.controller_buttons.write().unwrap();
// clear current type if set // // clear current type if set
if current_controller_type.is_some() { // if current_controller_type.is_some() {
*current_controller_type = None; // *current_controller_type = None;
} // }
// clear map if filled // // clear map if filled
if !map.is_empty() { // if !map.is_empty() {
map.clear(); // map.clear();
} // }
} // }
} // }
Ok(()) // Ok(())
} // }
} }

4
examples/simple_window/src/main.rs
View file

@ -53,7 +53,7 @@ impl GameState {
} }
impl EventConsumer for GameState { impl EventConsumer for GameState {
fn event(&mut self, world: &mut World, event: EngineEvent) -> Result<()> { fn event(&mut self, world: &mut World, event: EngineEvent<'_>) -> Result<()> {
match self { match self {
GameState::Startup => (), GameState::Startup => (),
GameState::Loading => (), GameState::Loading => (),
@ -72,7 +72,7 @@ impl Game {
Ok(()) Ok(())
} }
fn event(&mut self, world: &mut World, event: EngineEvent) -> Result<()> { fn event(&mut self, world: &mut World, event: EngineEvent<'_>) -> Result<()> {
Ok(()) Ok(())
} }
} }

16
presentation/src/input/controller.rs
View file

@ -3,7 +3,7 @@ use ui::prelude::*;
use super::controlleraxis::ControllerAxis; use super::controlleraxis::ControllerAxis;
use sdl2; use sdl2::{self, GameControllerSubsystem};
#[derive(PartialEq)] #[derive(PartialEq)]
enum State { enum State {
@ -51,7 +51,7 @@ pub struct Controller {
impl Controller { impl Controller {
pub fn new( pub fn new(
controller_subsystem: &sdl2::GameControllerSubsystem, controller_subsystem: &GameControllerSubsystem,
id: u32, id: u32,
deadzones: ControllerDeadzones, deadzones: ControllerDeadzones,
) -> Result<Controller> { ) -> Result<Controller> {
@ -199,7 +199,7 @@ impl Controller {
} }
} }
pub fn set_left_x(&mut self, x: f32) { pub(crate) fn set_left_x(&mut self, x: f32) {
self.controller_axis.left_stick.x = x; self.controller_axis.left_stick.x = x;
let direction = self.check_direction( let direction = self.check_direction(
@ -212,7 +212,7 @@ impl Controller {
} }
} }
pub fn set_left_y(&mut self, y: f32) { pub(crate) fn set_left_y(&mut self, y: f32) {
self.controller_axis.left_stick.y = y; self.controller_axis.left_stick.y = y;
let direction = self.check_direction( let direction = self.check_direction(
@ -225,15 +225,15 @@ impl Controller {
} }
} }
pub fn set_right_x(&mut self, x: f32) { pub(crate) fn set_right_x(&mut self, x: f32) {
self.controller_axis.right_stick.x = x; self.controller_axis.right_stick.x = x;
} }
pub fn set_right_y(&mut self, y: f32) { pub(crate) fn set_right_y(&mut self, y: f32) {
self.controller_axis.right_stick.y = y; self.controller_axis.right_stick.y = y;
} }
pub fn set_left_trigger(&mut self, trigger: f32) { pub(crate) fn set_left_trigger(&mut self, trigger: f32) {
self.controller_axis.left_trigger = trigger; self.controller_axis.left_trigger = trigger;
let left_trigger = self.check_trigger(trigger, self.last_left_trigger); let left_trigger = self.check_trigger(trigger, self.last_left_trigger);
@ -244,7 +244,7 @@ impl Controller {
} }
} }
pub fn set_right_trigger(&mut self, trigger: f32) { pub(crate) fn set_right_trigger(&mut self, trigger: f32) {
self.controller_axis.right_trigger = trigger; self.controller_axis.right_trigger = trigger;
let right_trigger = self.check_trigger(trigger, self.last_right_trigger); let right_trigger = self.check_trigger(trigger, self.last_right_trigger);

257
presentation/src/input/eventsystem.rs
View file

@ -2,7 +2,9 @@ use sdl2;
use sdl2::EventPump; use sdl2::EventPump;
use sdl2::EventSubsystem; use sdl2::EventSubsystem;
use sdl2::GameControllerSubsystem; use sdl2::GameControllerSubsystem;
use sdl2::JoystickSubsystem;
use sdl2::Sdl; use sdl2::Sdl;
use sdl2::controller::Axis;
use sdl2::controller::Button; use sdl2::controller::Button;
use sdl2::event::{Event as SdlEvent, EventType as SdlEventType, WindowEvent}; use sdl2::event::{Event as SdlEvent, EventType as SdlEventType, WindowEvent};
use sdl2::keyboard::Keycode; use sdl2::keyboard::Keycode;
@ -10,11 +12,12 @@ use sdl2::mouse::{MouseButton as SdlMouseButton, MouseUtil, MouseWheelDirection}
use ui::prelude::*; use ui::prelude::*;
use std::sync::{Arc, RwLock}; use std::collections::HashMap;
use crate::Result; use crate::Result;
use super::controller::{Controller, ControllerDeadzones}; use super::controller::{Controller, ControllerDeadzones};
use super::joystick::Joystick;
fn convert_button(button: Button) -> ControllerButton { fn convert_button(button: Button) -> ControllerButton {
match button { match button {
@ -51,7 +54,7 @@ fn convert_button(button: Button) -> ControllerButton {
} }
#[derive(Debug)] #[derive(Debug)]
pub enum Event { pub enum Event<'a> {
// mouse events // mouse events
MouseMotion(u32, u32), MouseMotion(u32, u32),
MouseButtonDown(MouseButton), MouseButtonDown(MouseButton),
@ -64,11 +67,18 @@ pub enum Event {
TextInput(String), TextInput(String),
// controller events // controller events
ControllerAxis(Arc<RwLock<Controller>>), ControllerAxis(&'a Controller),
ControllerButtonDown(ControllerButton), ControllerButtonDown(&'a Controller, ControllerButton),
ControllerButtonUp(ControllerButton), ControllerButtonUp(&'a Controller, ControllerButton),
ControllerAdded(Arc<RwLock<Controller>>), ControllerAdded(&'a Controller),
ControllerRemoved(Arc<RwLock<Controller>>), ControllerRemoved(&'a Controller),
// joystick events
JoystickAxis(&'a Joystick),
JoystickButtonDown(&'a Joystick),
JoystickButtonUp(&'a Joystick),
JoystickAdded(&'a Joystick),
JoystickRemoved(&'a Joystick),
// drag'n'drop // drag'n'drop
FileDrop(String), FileDrop(String),
@ -78,12 +88,13 @@ pub struct EventSystem {
event_pump: EventPump, event_pump: EventPump,
mouse: MouseUtil, mouse: MouseUtil,
controller_subsystem: GameControllerSubsystem, controller_subsystem: GameControllerSubsystem,
joystick_subsystem: JoystickSubsystem,
event_subsystem: EventSubsystem, event_subsystem: EventSubsystem,
controller_deadzones: ControllerDeadzones, controller_deadzones: ControllerDeadzones,
selected_controller: Option<Arc<RwLock<Controller>>>, connected_controllers: HashMap<u32, Controller>,
connected_controllers: Vec<Arc<RwLock<Controller>>>, connected_joysticks: HashMap<u32, Joystick>,
} }
impl EventSystem { impl EventSystem {
@ -96,12 +107,13 @@ impl EventSystem {
controller_subsystem: sdl2_context controller_subsystem: sdl2_context
.game_controller() .game_controller()
.map_err(|s| anyhow::Error::msg(s))?, .map_err(|s| anyhow::Error::msg(s))?,
joystick_subsystem: sdl2_context.joystick().map_err(|s| anyhow::Error::msg(s))?,
event_subsystem: sdl2_context.event().map_err(|s| anyhow::Error::msg(s))?, event_subsystem: sdl2_context.event().map_err(|s| anyhow::Error::msg(s))?,
controller_deadzones: ControllerDeadzones::default(), controller_deadzones: ControllerDeadzones::default(),
selected_controller: None, connected_controllers: HashMap::new(),
connected_controllers: Vec::new(), connected_joysticks: HashMap::new(),
}; };
event_system.disable_mouse(); event_system.disable_mouse();
@ -180,11 +192,9 @@ impl EventSystem {
pub fn poll_events<F, R>(&mut self, mut event_callback: F, mut resize: R) -> Result<bool> pub fn poll_events<F, R>(&mut self, mut event_callback: F, mut resize: R) -> Result<bool>
where where
F: FnMut(Event) -> Result<()>, F: FnMut(Event<'_>) -> Result<()>,
R: FnMut(u32, u32) -> Result<()>, R: FnMut(u32, u32) -> Result<()>,
{ {
let mut controller_axis_changed = false;
for event in self.event_pump.poll_iter() { for event in self.event_pump.poll_iter() {
match event { match event {
SdlEvent::Window { win_event, .. } => match win_event { SdlEvent::Window { win_event, .. } => match win_event {
@ -266,7 +276,6 @@ impl EventSystem {
which as u32, which as u32,
self.controller_deadzones.clone(), self.controller_deadzones.clone(),
) { ) {
let controller = {
if cfg!(debug_assertions) { if cfg!(debug_assertions) {
println!( println!(
"Controller added: {}({})", "Controller added: {}({})",
@ -275,175 +284,70 @@ impl EventSystem {
); );
} }
let arc_controller = Arc::new(RwLock::new(controller)); event_callback(Event::ControllerAdded(&controller))?;
self.connected_controllers.push(arc_controller.clone()); self.connected_controllers
.insert(controller.id(), controller);
if self.selected_controller.is_none() {
if cfg!(debug_assertions) {
let contr = arc_controller.read().unwrap();
println!(
"New active controller: {}({})",
contr.name(),
contr.id()
);
}
self.selected_controller = Some(arc_controller.clone());
}
arc_controller
};
event_callback(Event::ControllerAdded(controller))?;
} }
} }
SdlEvent::ControllerDeviceRemoved { which, .. } => { SdlEvent::ControllerDeviceRemoved { which, .. } => {
let removed_controller = { if let Some(controller) = self.connected_controllers.remove(&which) {
if self.selected_controller.is_some() {
if cfg!(debug_assertions) { if cfg!(debug_assertions) {
let contr =
self.selected_controller.as_ref().unwrap().read().unwrap();
println!(
"Remove active controller: {}({})",
contr.name(),
contr.id()
);
}
// unwrap is save since we just tested for `is_some()`
if self
.selected_controller
.as_ref()
.unwrap()
.read()
.unwrap()
.id()
== which
{
self.selected_controller = None;
}
}
self.connected_controllers
.iter()
.position(|controller_cell| {
let controller = controller_cell.read().unwrap();
controller.id() == which
})
.map(|remove_index| {
let removed_controller =
self.connected_controllers.swap_remove(remove_index);
if cfg!(debug_assertions) {
let contr = removed_controller.read().unwrap();
println!( println!(
"Controller removed: {}({})", "Controller removed: {}({})",
contr.name(), controller.name(),
contr.id() controller.id()
); );
} }
// if we removed the selected controller, take the controller at the first position if possible event_callback(Event::ControllerRemoved(&controller))?;
if self.selected_controller.is_none()
&& !self.connected_controllers.is_empty()
{
if cfg!(debug_assertions) {
println!(
"Set active controller: {}",
self.connected_controllers[0].read().unwrap().name()
);
}
self.selected_controller =
Some(self.connected_controllers[0].clone());
}
removed_controller
})
};
if let Some(removed_controller) = removed_controller {
event_callback(Event::ControllerRemoved(removed_controller))?;
} }
} }
// maybe make use of `which`, for support of multiple controllers SdlEvent::ControllerButtonDown { button, which, .. } => {
SdlEvent::ControllerButtonDown { event_callback(Event::ControllerButtonDown(
button, self.connected_controllers.get(&which).unwrap(),
// which, convert_button(button),
.. ))?;
} => {
// // only call back if the selected controller pressed a button
// match self.selected_controller.read().unwrap().as_ref() {
// Some(selected_controller) => {
// if selected_controller.read().unwrap().id() != which {
// continue;
// }
// }
// None => continue,
// }
event_callback(Event::ControllerButtonDown(convert_button(button)))?;
} }
// maybe make use of `which`, for support of multiple controllers SdlEvent::ControllerButtonUp { button, which, .. } => {
SdlEvent::ControllerButtonUp { event_callback(Event::ControllerButtonUp(
button, self.connected_controllers.get(&which).unwrap(),
// which, convert_button(button),
.. ))?;
} => {
// // only call back if the selected controller released a button
// match self.selected_controller.read().unwrap().as_ref() {
// Some(selected_controller) => {
// if selected_controller.read().unwrap().id() != which {
// continue;
// }
// }
// None => continue,
// }
event_callback(Event::ControllerButtonUp(convert_button(button)))?;
} }
SdlEvent::ControllerAxisMotion { SdlEvent::ControllerAxisMotion {
axis, axis, value, which, ..
value,
// which,
..
} => { } => {
if let Some(controller) = self.selected_controller.as_mut() { let controller = self.connected_controllers.get_mut(&which).unwrap();
let mut controller = controller.write().unwrap();
// // only update axis, when selected controller made the change
// if controller.id() != which {
// continue;
// }
// 1 / 32768 = 0,000030518
let normalized = value as f32 * 0.000_030_518; let normalized = value as f32 * 0.000_030_518;
match axis { match axis {
sdl2::controller::Axis::LeftX => { Axis::LeftX => {
controller.set_left_x(normalized); controller.set_left_x(normalized);
} }
sdl2::controller::Axis::RightX => { Axis::RightX => {
controller.set_right_x(normalized); controller.set_right_x(normalized);
} }
sdl2::controller::Axis::LeftY => { Axis::LeftY => {
controller.set_left_y(-normalized); controller.set_left_y(-normalized);
} }
sdl2::controller::Axis::RightY => { Axis::RightY => {
controller.set_right_y(normalized); controller.set_right_y(normalized);
} }
sdl2::controller::Axis::TriggerLeft => { Axis::TriggerLeft => {
controller.set_left_trigger(normalized); controller.set_left_trigger(normalized);
} }
sdl2::controller::Axis::TriggerRight => { Axis::TriggerRight => {
controller.set_right_trigger(normalized); controller.set_right_trigger(normalized);
} }
} }
controller_axis_changed = true; event_callback(Event::ControllerAxis(&*controller))?;
} }
SdlEvent::JoyDeviceAdded { which, .. } => {
let joystick = Joystick::new(&self.joystick_subsystem, which)?;
event_callback(Event::JoystickAdded(&joystick))?;
self.connected_joysticks.insert(joystick.id(), joystick);
} }
SdlEvent::DropFile { filename, .. } => { SdlEvent::DropFile { filename, .. } => {
event_callback(Event::FileDrop(filename))?; event_callback(Event::FileDrop(filename))?;
@ -452,58 +356,11 @@ impl EventSystem {
} }
} }
if controller_axis_changed {
if let Some(controller) = &self.selected_controller {
let (left_trigger, right_trigger) = {
let mut controller_lock = controller.write().unwrap();
(
controller_lock.left_trigger(),
controller_lock.right_trigger(),
)
};
if let Some(right_trigger) = right_trigger {
if right_trigger {
event_callback(Event::ControllerButtonDown(
ControllerButton::RightTrigger,
))?;
} else {
event_callback(Event::ControllerButtonUp(ControllerButton::RightTrigger))?;
}
}
if let Some(left_trigger) = left_trigger {
if left_trigger {
event_callback(Event::ControllerButtonDown(ControllerButton::LeftTrigger))?;
} else {
event_callback(Event::ControllerButtonUp(ControllerButton::LeftTrigger))?;
}
}
event_callback(Event::ControllerAxis(controller.clone()))?;
}
}
Ok(true) Ok(true)
} }
pub fn controllers(&self) -> &[Arc<RwLock<Controller>>] { pub fn controllers(&self) -> impl Iterator<Item = &Controller> {
&self.connected_controllers self.connected_controllers.values()
}
pub fn active_controller(&self) -> &Option<Arc<RwLock<Controller>>> {
&self.selected_controller
}
pub fn set_active_controller(&mut self, controller: &Arc<RwLock<Controller>>) {
if let Some(res) = self
.connected_controllers
.iter()
.find(|c| Arc::ptr_eq(c, controller))
{
self.selected_controller = Some(res.clone());
}
} }
} }

40
presentation/src/input/joystick.rs Normal file
View file

@ -0,0 +1,40 @@
use anyhow::Result;
use sdl2::JoystickSubsystem;
pub struct Joystick {
_sdl2_joystick: sdl2::joystick::Joystick,
id: u32,
name: String,
}
impl Joystick {
pub fn new(joystick_subsystem: &JoystickSubsystem, id: u32) -> Result<Self> {
let sdl2_joystick = joystick_subsystem.open(id)?;
Ok(Self {
name: sdl2_joystick.name(),
id,
_sdl2_joystick: sdl2_joystick,
})
}
pub fn id(&self) -> u32 {
self.id
}
pub fn name(&self) -> &str {
&self.name
}
}
impl std::fmt::Debug for Joystick {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Joystick")
.field("id", &self.id)
.field("name", &self.name)
.finish()
}
}
unsafe impl Send for Joystick {}
unsafe impl Sync for Joystick {}

1
presentation/src/input/mod.rs
View file

@ -3,3 +3,4 @@
pub mod controller; pub mod controller;
pub mod controlleraxis; pub mod controlleraxis;
pub mod eventsystem; pub mod eventsystem;
pub mod joystick;

2
presentation/src/presentationcore.rs
View file

@ -113,7 +113,7 @@ impl PresentationCore {
pub fn poll_events<F, R>(&mut self, event_callback: F, resize_event: R) -> Result<bool> pub fn poll_events<F, R>(&mut self, event_callback: F, resize_event: R) -> Result<bool>
where where
F: FnMut(Event) -> Result<()>, F: FnMut(Event<'_>) -> Result<()>,
R: FnMut(u32, u32) -> Result<()>, R: FnMut(u32, u32) -> Result<()>,
{ {
self.event_system.poll_events(event_callback, resize_event) self.event_system.poll_events(event_callback, resize_event)