Update Rust crate openvr to 0.7.0

context/src/core/context.rs

@@ -60,7 +60,7 @@ impl Context {
     pub fn next_frame<C, F>(&mut self, world: &mut World, mut f: F) -> Result<bool>
     where
         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 consumer = world.resources.get_mut_unchecked::<C>();
@@ -116,9 +116,19 @@ impl Context {
         self.core.queue()
     }
 
-    pub fn controllers(&self) -> impl Iterator<Item = &Controller> {
+    pub fn controllers(&self) -> &[Arc<RwLock<Controller>>] {
         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 {

ecs/src/type_map.rs

@@ -229,7 +229,7 @@ pub enum ComponentRequestType {
 
 #[derive(Debug)]
 pub struct ComponentNotFoundError {
-    pub request_type: ComponentRequestType,
+    request_type: ComponentRequestType,
 }
 
 impl ComponentNotFoundError {

ecs/src/updates.rs

@@ -341,7 +341,7 @@ pub struct ArchetypeInfo {
 }
 
 impl ArchetypeInfo {
-    pub fn new(entities: Vec<(Entity, Option<String>)>) -> Self {
+    pub(crate) fn new(entities: Vec<(Entity, Option<String>)>) -> Self {
         Self { entities }
     }
 
@@ -388,7 +388,7 @@ impl Archetype {
         Ok(())
     }
 
-    pub fn entities(
+    pub(crate) fn entities(
         &self,
     ) -> &IndexMap<Entity, Box<dyn Fn(Entity, &mut World) -> Result<()> + Send + Sync>> {
         &self.entities
@@ -572,12 +572,12 @@ impl Updates {
         }
     }
 
-    // pub(crate) fn clear(&mut self) {
+    pub(crate) fn clear(&mut self) {
-    //     self.updates.clear();
+        self.updates.clear();
 
-    //     #[cfg(feature = "timings")]
+        #[cfg(feature = "timings")]
-    //     self.timings.clear();
+        self.timings.clear();
-    // }
+    }
 
     pub(crate) fn add(&mut self, name: &str, priority: u32, update: Update) -> Result<()> {
         #[cfg(feature = "timings")]

engine/src/engine/engine.rs

@@ -13,7 +13,9 @@ use crate::prelude::*;
 use std::collections::HashMap;
 use std::sync::Arc;
 
-pub struct GuiHandlerRenderer;
+pub struct GuiHandlerRenderer {
+    pub gui_handler: Arc<GuiHandler>,
+}
 
 impl TScene for GuiHandlerRenderer {
     fn process(
@@ -21,12 +23,9 @@ impl TScene for GuiHandlerRenderer {
         buffer_recorder: &mut CommandBufferRecorder<'_>,
         _images: &TargetMode<Vec<Arc<Image>>>,
         indices: &TargetMode<usize>,
-        world: &World,
+        _world: &World,
     ) -> Result<()> {
-        world
+        self.gui_handler.process(buffer_recorder, indices)
-            .resources
-            .get::<Arc<GuiHandler>>()
-            .process(buffer_recorder, indices)
     }
 
     fn resize(
@@ -34,17 +33,16 @@ impl TScene for GuiHandlerRenderer {
         window_width: f32,
         window_height: f32,
         images: &TargetMode<Vec<Arc<Image>>>,
-        world: &World,
     ) -> Result<()> {
-        world.resources.get::<Arc<GuiHandler>>().resize(
+        self.gui_handler
-            window_width as u32,
+            .resize(window_width as u32, window_height as u32, images)
-            window_height as u32,
-            images,
-        )
     }
 }
 
 pub struct Engine {
+    // loads and keeps track of raw data
+    asset_manager: AssetManager,
+
     pub(crate) resource_base_path: String,
 }
 
@@ -173,9 +171,14 @@ impl Engine {
         )?;
 
         let asset_manager = AssetManager::new(&engine_settings)?;
-        let gui_handler = GuiHandler::new(create_info.gui_info, &context)?;
+
+        let gui_handler = GuiHandlerRenderer {
+            gui_handler: GuiHandler::new(create_info.gui_info, &context)?,
+        };
 
         let engine = Engine {
+            asset_manager,
+
             resource_base_path: create_info.resource_base_path,
         };
 
@@ -201,9 +204,8 @@ impl Engine {
         direction_mapping.insert(Keycode::Down, GuiDirection::Down);
 
         world.resources.insert(gui_handler);
-        world.resources.insert(GuiHandlerRenderer);
         world.resources.insert(InputMap { direction_mapping });
-        world.resources.insert(asset_manager);
+
         world.resources.insert(engine);
         world.resources.insert(engine_settings);
         world.resources.insert(scene);
@@ -252,18 +254,25 @@ impl Engine {
 
 impl Engine {
     fn main_system<T: EventConsumer>(world: &mut World) -> Result<bool> {
-        let gui_handler = world.resources.get_unchecked::<Arc<GuiHandler>>();
+        let gui_handler = world.resources.get_unchecked::<GuiHandlerRenderer>();
         let input_map = world.resources.get_unchecked::<InputMap>();
         let context = world.resources.get_unchecked::<Context>();
 
         let res = world.resources.get_mut_unchecked::<Context>().next_frame(
             world,
             |world, consumer: &mut T, event| {
-                Self::event(world, context, gui_handler, input_map, consumer, event)
+                Self::event(
+                    world,
+                    context,
+                    &gui_handler.gui_handler,
+                    input_map,
+                    consumer,
+                    event,
+                )
             },
         )?;
 
-        gui_handler.process_callbacks()?;
+        gui_handler.gui_handler.process_callbacks()?;
 
         Ok(res)
     }

engine/src/engine/engine_event_handling.rs

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

engine/src/engine/engine_settings.rs

@@ -205,7 +205,7 @@ impl EngineSettings {
         button: ControllerButton,
     ) -> Result<Option<Arc<Image>>> {
         // 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() {
             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(())
-    // }
+    }
 }

engine/src/scene/general/light.rs

@@ -5,7 +5,7 @@ use crate::prelude::*;
 use anyhow::Result;
 use utilities::{
     impl_reprc,
-    prelude::cgmath::{InnerSpace, Rad, Vector3, Zero, vec3},
+    prelude::cgmath::{vec3, InnerSpace, Rad, Vector3, Zero},
 };
 
 use utilities::prelude::cgmath::{Matrix4, SquareMatrix};
@@ -127,15 +127,15 @@ pub struct Light {
 }
 
 impl Light {
-    pub fn point_light(device: &Arc<Device>) -> Result<Light> {
+    pub(crate) fn point_light(device: &Arc<Device>) -> Result<Light> {
         Self::new(LightType::Point, device)
     }
 
-    pub fn directional_light(device: &Arc<Device>) -> Result<Light> {
+    pub(crate) fn directional_light(device: &Arc<Device>) -> Result<Light> {
         Self::new(LightType::Direction, device)
     }
 
-    pub fn spot_light(device: &Arc<Device>) -> Result<Light> {
+    pub(crate) fn spot_light(device: &Arc<Device>) -> Result<Light> {
         Self::new(LightType::Spot, device)
     }
 

engine/src/scene/scene/scene_base.rs

@@ -14,6 +14,7 @@ use super::super::timings::Timings;
 
 use anyhow::Result;
 use ecs::*;
+use rayon::prelude::*;
 use utilities::prelude::cgmath::{Matrix4, Vector3, vec3};
 
 use std::sync::Mutex;
@@ -27,6 +28,9 @@ pub struct Scene {
     screen_width: f32,
     screen_height: f32,
 
+    device: Arc<Device>,
+    queue: Arc<Mutex<Queue>>,
+
     render_type: SceneType,
 
     last_frame: Duration,
@@ -88,6 +92,9 @@ impl Scene {
 
             render_type,
 
+            device: device.clone(),
+            queue: queue.clone(),
+
             frustum_check: None,
 
             renderer,
@@ -479,7 +486,6 @@ impl TScene for Scene {
         window_width: f32,
         window_height: f32,
         images: &TargetMode<Vec<Arc<Image>>>,
-        _world: &World,
     ) -> anyhow::Result<()> {
         self.screen_width = window_width;
         self.screen_height = window_height;

examples/simple_window/src/main.rs

@@ -14,8 +14,7 @@ fn main() -> Result<()> {
     world_builder.add_system(GameState::update);
     world_builder.resources.insert(GameState::Startup);
 
-    let dir = Path::new("C:/Users/M.Huebner/Downloads/Space Skybox Generator/Export");
+    let dir = Path::new("/home/michaelh/Sync/skybox");
-    // let dir = Path::new("/home/michaelh/Sync/skybox");
     SkyBox::new(
         &mut world_builder,
         [
@@ -53,7 +52,7 @@ impl 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 {
             GameState::Startup => (),
             GameState::Loading => (),
@@ -72,7 +71,7 @@ impl Game {
         Ok(())
     }
 
-    fn event(&mut self, world: &mut World, event: EngineEvent<'_>) -> Result<()> {
+    fn event(&mut self, world: &mut World, event: EngineEvent) -> Result<()> {
         Ok(())
     }
 }

loading-screen/src/loadingscreen.rs

@@ -1,60 +1,40 @@
 use context::prelude::*;
 
-use std::{
+use std::{sync::Arc, thread};
-    sync::{
-        Arc,
-        mpsc::{Receiver, channel},
-    },
-    thread,
-};
 
 use anyhow::Result;
 
-pub struct LoadingScreen<T: Send + Sync + 'static> {
+pub struct LoadingScreen;
-    result: Option<T>,
-    receiver: Receiver<T>,
-}
 
-impl<T: Send + Sync + 'static> LoadingScreen<T> {
+impl LoadingScreen {
-    pub fn load<R, L, G>(gui: Arc<G>, loader: L) -> Result<Self>
+    pub fn load<T, R, L, G>(
+        context: &Arc<Context>,
+        gui: Option<Arc<G>>,
+        loader: L,
+        on_ready: R,
+    ) -> Result<()>
     where
         R: Fn(T) -> Result<()> + Send + Sync + 'static,
         T: Send + Sync + 'static,
         L: FnOnce() -> T + Send + Sync + 'static,
         G: TopLevelGui + TopGui + Send + Sync + 'static,
     {
+        if let Some(gui) = &gui {
             gui.enable()?;
+        }
 
-        let (sender, receiver) = channel();
+        let context = context.clone();
 
         thread::spawn(move || {
-            let _ = sender.send(loader());
+            let result = loader();
-            let _ = gui.disable();
+            if let Some(gui) = &gui {
+                gui.disable().unwrap();
+            }
+
+            todo!();
+            // context.push_event(move || (on_ready)(result));
         });
 
-        Ok(Self {
+        Ok(())
-            result: None,
-            receiver,
-        })
-    }
-
-    pub fn check_ready(&mut self) -> bool {
-        if self.result.is_some() {
-            return true;
-        }
-
-        match self.receiver.try_recv() {
-            Ok(result) => {
-                self.result = Some(result);
-                true
-            }
-            Err(_) => false,
-        }
-    }
-
-    /// Will panic if there is no result.
-    /// Use `check_ready` before calling this.
-    pub fn take_result(mut self) -> T {
-        self.result.take().unwrap()
     }
 }

presentation/src/input/controller.rs

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

presentation/src/input/eventsystem.rs

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

presentation/src/input/joystick.rs

@@ -1,40 +0,0 @@
-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 {}

presentation/src/input/mod.rs

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

presentation/src/presentationcore.rs

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

presentation/src/renderbackend.rs

@@ -89,7 +89,7 @@ impl SceneHandle {
                 world
                     .resources
                     .get_mut_unchecked::<T>()
-                    .resize(width, height, images, world)
+                    .resize(width, height, images)
             }),
         }
     }

presentation/src/traits.rs

@@ -25,7 +25,6 @@ pub trait TScene: Send + Sync + 'static {
         window_width: f32,
         window_height: f32,
         images: &TargetMode<Vec<Arc<Image>>>,
-        world: &World,
     ) -> Result<()>;
 }
 

skybox/src/lib.rs

@@ -37,8 +37,6 @@ impl<T: ExactSizeIterator<Item = PathBuf>> From<T> for SkyBoxImages {
 }
 
 pub struct SkyBox {
-    enabled: bool,
-
     _cube_map: Arc<Image>,
     cube_buffer: Arc<Buffer<VertexPoint>>,
 
@@ -162,8 +160,6 @@ impl SkyBox {
         .submit()?;
 
         let me = Self {
-            enabled: true,
-
             _cube_map: cube_map,
             cube_buffer,
 
@@ -179,14 +175,6 @@ impl SkyBox {
         Ok(())
     }
 
-    pub fn enable(&mut self) {
-        self.enabled = true;
-    }
-
-    pub fn disable(&mut self) {
-        self.enabled = false;
-    }
-
     fn create_render_target(
         context: &Context,
         sample_count: VkSampleCountFlags,
@@ -268,10 +256,6 @@ impl TScene for SkyBox {
         indices: &TargetMode<usize>,
         _world: &World,
     ) -> Result<()> {
-        if !self.enabled {
-            return Ok(());
-        }
-
         self.render_target
             .chain(indices)
             .chain(&self.pipeline)
@@ -295,34 +279,10 @@ impl TScene for SkyBox {
 
     fn resize(
         &mut self,
-        _window_width: f32,
+        window_width: f32,
-        _window_height: f32,
+        window_height: f32,
-        _images: &TargetMode<Vec<Arc<Image>>>,
+        images: &TargetMode<Vec<Arc<Image>>>,
-        world: &World,
     ) -> Result<()> {
-        let sample_count = world
-            .resources
-            .get::<EngineSettings>()
-            .graphics_info()?
-            .sample_count;
-
-        let context = world.resources.get::<Context>();
-
-        let pipeline_layout = match &self.pipeline {
-            TargetMode::Mono(p) => p.pipeline_layout().clone(),
-            TargetMode::Stereo(p, _) => p.pipeline_layout().clone(),
-        };
-
-        self.render_target = Self::create_render_target(context, sample_count)?;
-        self.pipeline = Self::create_pipeline(
-            context,
-            sample_count,
-            &self.render_target,
-            &pipeline_layout,
-            &self.vertex_shader,
-            &self.fragment_shader,
-        )?;
-
         Ok(())
     }
 }