fix image_drm_format_modifier being a hard requirement

* updated dependencies

* updated vulkano and ash with fixes

Cargo.toml

@@ -4,32 +4,32 @@ debug = true
 
 [package]
 name = "wlx-overlay-s"
-version = "0.4.0"
+version = "0.4.1"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-anyhow = "1.0.79"
-ash = "^0.37.2"
-chrono = "0.4.29"
+anyhow = "1.0.86"
+ash = "^0.38.0"
+chrono = "0.4.38"
 chrono-tz = "0.9.0"
-clap = { version = "4.5.1", features = ["derive"] }
+clap = { version = "4.5.6", features = ["derive"] }
 config = "0.14.0"
 cstr = "0.2.12"
-ctrlc = { version = "3.4.2", features = ["termination"] }
+ctrlc = { version = "3.4.4", features = ["termination"] }
 dbus = { version = "0.9.7" }
-flexi_logger = "0.28.0"
+flexi_logger = "0.28.1"
 fontconfig-rs = "0.1.1"
 freetype-rs = "0.36.0"
-futures = "0.3.29"
+futures = "0.3.30"
 glam = { version = "0.27.0", features = ["approx", "serde"] }
 idmap = { version = "0.2.21", features = ["serde"] }
 idmap-derive = "0.1.2"
 input-linux = "0.6.0"
 json = { version = "0.12.4", optional = true }
 json5 = "0.4.1"
-libc = "0.2.153"
+libc = "0.2.155"
 libloading = "0.8.3"
 log = "0.4.21"
 once_cell = "1.19.0"
@@ -38,23 +38,23 @@ ovr_overlay = { features = [
   "ovr_input",
   "ovr_system",
 ], git = "https://github.com/galister/ovr_overlay_oyasumi", optional = true }
-regex = "1.9.5"
-rodio = { version = "0.17.1", default-features = false, features = [
+regex = "1.10.4"
+rodio = { version = "0.18.1", default-features = false, features = [
   "wav",
   "hound",
 ] }
 rosc = { version = "0.10.1", optional = true }
-serde = { version = "1.0.188", features = ["derive", "rc"] }
-serde_json = "1.0.113"
+serde = { version = "1.0.203", features = ["derive", "rc"] }
+serde_json = "1.0.117"
 serde_yaml = "0.9.34"
-smallvec = "1.11.0"
+smallvec = "1.13.2"
 strum = { version = "0.26.2", features = ["derive"] }
-sysinfo = { version = "0.30.0" }
-thiserror = "1.0.56"
-vulkano = { git = "https://github.com/vulkano-rs/vulkano", rev = "94f50f1" }
-vulkano-shaders = { git = "https://github.com/vulkano-rs/vulkano", rev = "94f50f1" }
+sysinfo = { version = "0.30.12" }
+thiserror = "1.0.61"
+vulkano = { git = "https://github.com/vulkano-rs/vulkano", rev = "b9f3e89" }
+vulkano-shaders = { git = "https://github.com/vulkano-rs/vulkano", rev = "b9f3e89" }
 wlx-capture = { git = "https://github.com/galister/wlx-capture", tag = "v0.3.11", default-features = false }
-winit = { version = "0.29.15", optional = true }
+winit = { version = "0.30.0", optional = true }
 xdg = "2.5.2"
 log-panics = { version = "2.1.0", features = ["with-backtrace"] }
 serde_json5 = "0.1.0"
@@ -72,6 +72,5 @@ x11 = ["dep:xcb", "wlx-capture/xshm", "xkbcommon/x11"]
 wayland = ["pipewire", "wlx-capture/wlr", "xkbcommon/wayland"]
 pipewire = ["wlx-capture/pipewire"]
 uidev = ["dep:winit"]
-no-dmabuf = []
 xcb = ["dep:xcb"]
 as-raw-xcb-connection = []

src/backend/common.rs

@@ -68,10 +68,14 @@ where
 
         app.screens.clear();
         let data = if let Some(wl) = wl.as_mut() {
-            keymap = get_keymap_wl().ok();
+            keymap = get_keymap_wl()
+                .map_err(|f| log::warn!("Could not load keyboard layout: {}", f))
+                .ok();
             crate::overlays::screen::create_screens_wayland(wl, app)?
         } else {
-            keymap = get_keymap_x11().ok();
+            keymap = get_keymap_x11()
+                .map_err(|f| log::warn!("Could not load keyboard layout: {}", f))
+                .ok();
             match crate::overlays::screen::create_screens_x11pw(app) {
                 Ok(data) => data,
                 Err(e) => {

src/backend/openvr/playspace.rs

@@ -114,7 +114,8 @@ impl PlayspaceMover {
             let new_hand = data
                 .pose
                 .transform_point3a(state.input_state.pointers[data.hand].raw_pose.translation);
-            let relative_pos = new_hand - data.hand_pose;
+            let relative_pos =
+                (new_hand - data.hand_pose) * state.session.config.space_drag_multiplier;
 
             if relative_pos.length_squared() > 1000.0 {
                 log::warn!("Space drag too fast, ignoring");
@@ -199,6 +200,15 @@ impl PlayspaceMover {
 
         set_working_copy(&self.universe, chaperone_mgr, &mat);
         chaperone_mgr.commit_working_copy(EChaperoneConfigFile::EChaperoneConfigFile_Live);
+
+        if self.drag.is_some() {
+            log::info!("Space drag interrupted by fix floor");
+            self.drag = None;
+        }
+        if self.rotate.is_some() {
+            log::info!("Space rotate interrupted by fix floor");
+            self.rotate = None;
+        }
     }
 
     pub fn playspace_changed(

src/backend/openxr/helpers.rs

@@ -185,7 +185,8 @@ pub(super) fn find_libmonado() -> anyhow::Result<libloading::Library> {
         }
     }
 
-    const PROC_NAMES: [&str; 1] = ["monado-service"];
+    const PROC_NAMES: [&str; 2] = ["monado-service", "wivrn-server"];
+
     let mut system = sysinfo::System::new();
     system.refresh_processes();
     for p in system.processes().values() {
@@ -201,16 +202,20 @@ pub(super) fn find_libmonado() -> anyhow::Result<libloading::Library> {
 }
 
 fn proc_load_libmonado(proc: &Process) -> Option<libloading::Library> {
-    let path = proc
-        .exe()?
-        .parent()?
-        .parent()?
-        .join("lib")
-        .join("libmonado.so");
+    // relative to folder containing binary
+    const SEARCH_PATHS: [&str; 3] = [
+        "../lib/libmonado.so",
+        "../libmonado/libmonado.so",
+        "../_deps/monado-build/src/xrt/targets/libmonado/libmonado.so",
+    ];
 
-    if path.exists() {
-        Some(unsafe { libloading::Library::new(path).ok()? })
-    } else {
-        None
+    for &p in SEARCH_PATHS.iter() {
+        let path = proc.exe()?.parent()?.join(p);
+
+        if path.exists() {
+            return Some(unsafe { libloading::Library::new(path).ok()? });
+        }
     }
+
+    None
 }

src/backend/openxr/input.rs

@@ -84,7 +84,9 @@ impl CustomClickAction {
         let res = self
             .action_bool_double
             .state(&state.session, xr::Path::NULL)?;
-        if res.is_active && self.check_double_click(res.current_state) {
+        if res.is_active
+            && ((before && res.current_state) || self.check_double_click(res.current_state))
+        {
             return Ok(true);
         }
 
@@ -100,7 +102,10 @@ impl CustomClickAction {
         }
 
         let res = self.action_f32.state(&state.session, xr::Path::NULL)?;
-        if res.is_active && self.check_double_click(res.current_state > threshold) {
+        if res.is_active
+            && ((before && res.current_state > threshold)
+                || self.check_double_click(res.current_state > threshold))
+        {
             return Ok(true);
         }
 
@@ -136,6 +141,7 @@ pub(super) struct OpenXrHandSource {
     action_alt_click: CustomClickAction,
     action_show_hide: CustomClickAction,
     action_space_drag: CustomClickAction,
+    action_space_rotate: CustomClickAction,
     action_modifier_right: CustomClickAction,
     action_modifier_middle: CustomClickAction,
     action_move_mouse: CustomClickAction,
@@ -266,6 +272,11 @@ impl OpenXrHand {
                 .action_space_drag
                 .state(pointer.before.space_drag, xr, session)?;
 
+        pointer.now.space_rotate =
+            self.source
+                .action_space_rotate
+                .state(pointer.before.space_rotate, xr, session)?;
+
         Ok(())
     }
 }
@@ -298,6 +309,7 @@ impl OpenXrHandSource {
             action_alt_click: CustomClickAction::new(action_set, "alt_click", side)?,
             action_show_hide: CustomClickAction::new(action_set, "show_hide", side)?,
             action_space_drag: CustomClickAction::new(action_set, "space_drag", side)?,
+            action_space_rotate: CustomClickAction::new(action_set, "space_rotate", side)?,
             action_modifier_right: CustomClickAction::new(
                 action_set,
                 "click_modifier_right",
@@ -451,6 +463,14 @@ fn suggest_bindings(instance: &xr::Instance, hands: &[&OpenXrHandSource; 2]) ->
             instance
         );
 
+        add_custom!(
+            profile.space_rotate,
+            &hands[0].action_space_rotate,
+            &hands[1].action_space_rotate,
+            bindings,
+            instance
+        );
+
         add_custom!(
             profile.click_modifier_right,
             &hands[0].action_modifier_right,
@@ -504,6 +524,7 @@ struct OpenXrActionConfProfile {
     alt_click: Option<OpenXrActionConfAction>,
     show_hide: Option<OpenXrActionConfAction>,
     space_drag: Option<OpenXrActionConfAction>,
+    space_rotate: Option<OpenXrActionConfAction>,
     click_modifier_right: Option<OpenXrActionConfAction>,
     click_modifier_middle: Option<OpenXrActionConfAction>,
     move_mouse: Option<OpenXrActionConfAction>,

src/backend/openxr/openxr_actions.json5

@@ -90,7 +90,7 @@
       left: "/user/hand/left/input/x/touch",
       right: "/user/hand/right/input/a/touch"
     },
-    mouse_move: {
+    move_mouse: {
       // used with focus_follows_mouse_mode
       left: "/user/hand/left/input/trigger/touch",
       right: "/user/hand/right/input/trigger/touch"
@@ -140,7 +140,7 @@
       left: "/user/hand/left/input/a/touch",
       right: "/user/hand/right/input/a/touch"
     },
-    mouse_move: {
+    move_mouse: {
       // used with focus_follows_mouse_mode
       left: "/user/hand/left/input/trigger/touch",
       right: "/user/hand/right/input/trigger/touch"

src/backend/openxr/playspace.rs

@@ -37,6 +37,7 @@ enum ApiImpl {
 pub(super) struct PlayspaceMover {
     last_transform: Affine3A,
     drag: Option<MoverData<Vec3A>>,
+    rotate: Option<MoverData<Quat>>,
 
     libmonado: Library,
     mnd_root: *mut c_void,
@@ -75,6 +76,7 @@ impl PlayspaceMover {
             Ok(Self {
                 last_transform: Affine3A::IDENTITY,
                 drag: None,
+                rotate: None,
 
                 libmonado,
                 mnd_root: root,
@@ -84,6 +86,61 @@ impl PlayspaceMover {
     }
 
     pub fn update(&mut self, overlays: &mut OverlayContainer<OpenXrOverlayData>, state: &AppState) {
+        if let Some(mut data) = self.rotate.take() {
+            let pointer = &state.input_state.pointers[data.hand];
+            if !pointer.now.space_rotate {
+                self.last_transform = data.pose;
+                log::info!("End space rotate");
+                return;
+            }
+
+            let new_hand =
+                Quat::from_affine3(&(data.pose * state.input_state.pointers[data.hand].raw_pose));
+
+            let dq = new_hand * data.hand_pose.conjugate();
+            let rel_y = f32::atan2(
+                2.0 * (dq.y * dq.w + dq.x * dq.z),
+                (2.0 * (dq.w * dq.w + dq.x * dq.x)) - 1.0,
+            );
+
+            let mut space_transform = Affine3A::from_rotation_y(rel_y);
+            let offset = (space_transform.transform_vector3a(state.input_state.hmd.translation)
+                - state.input_state.hmd.translation)
+                * -1.0;
+            let mut overlay_transform = Affine3A::from_rotation_y(-rel_y);
+
+            overlay_transform.translation = offset;
+            space_transform.translation = offset;
+
+            overlays.iter_mut().for_each(|overlay| {
+                if overlay.state.grabbable {
+                    overlay.state.dirty = true;
+                    overlay.state.transform.translation =
+                        overlay_transform.transform_point3a(overlay.state.transform.translation);
+                }
+            });
+
+            data.pose *= space_transform;
+            data.hand_pose = new_hand;
+
+            self.apply_offset(data.pose);
+            self.rotate = Some(data);
+        } else {
+            for (i, pointer) in state.input_state.pointers.iter().enumerate() {
+                if pointer.now.space_rotate {
+                    let hand_pose = Quat::from_affine3(&self.last_transform);
+                    self.rotate = Some(MoverData {
+                        pose: self.last_transform,
+                        hand: i,
+                        hand_pose,
+                    });
+                    self.drag = None;
+                    log::info!("Start space rotate");
+                    return;
+                }
+            }
+        }
+
         if let Some(mut data) = self.drag.take() {
             let pointer = &state.input_state.pointers[data.hand];
             if !pointer.now.space_drag {
@@ -95,7 +152,8 @@ impl PlayspaceMover {
             let new_hand = data
                 .pose
                 .transform_point3a(state.input_state.pointers[data.hand].pose.translation);
-            let relative_pos = new_hand - data.hand_pose;
+            let relative_pos =
+                (new_hand - data.hand_pose) * state.session.config.space_drag_multiplier;
 
             if relative_pos.length_squared() > 1000.0 {
                 log::warn!("Space drag too fast, ignoring");
@@ -136,8 +194,12 @@ impl PlayspaceMover {
 
     pub fn reset_offset(&mut self) {
         if self.drag.is_some() {
-            log::info!("Cannot reset offset while dragging.");
-            return;
+            log::info!("Space drag interrupted by manual reset");
+            self.drag = None;
+        }
+        if self.rotate.is_some() {
+            log::info!("Space rotate interrupted by manual reset");
+            self.rotate = None;
         }
 
         self.last_transform = Affine3A::IDENTITY;
@@ -146,8 +208,12 @@ impl PlayspaceMover {
 
     pub fn fix_floor(&mut self, input: &InputState) {
         if self.drag.is_some() {
-            log::info!("Cannot fix floor while dragging.");
-            return;
+            log::info!("Space drag interrupted by fix floor");
+            self.drag = None;
+        }
+        if self.rotate.is_some() {
+            log::info!("Space rotate interrupted by fix floor");
+            self.rotate = None;
         }
 
         let y1 = input.pointers[0].pose.translation.y;

src/config.rs

@@ -240,6 +240,9 @@ pub struct GeneralConfig {
 
     #[serde(default = "def_font")]
     pub primary_font: Arc<str>,
+
+    #[serde(default = "def_one")]
+    pub space_drag_multiplier: f32,
 }
 
 impl GeneralConfig {
@@ -374,6 +377,7 @@ pub struct AutoSettings {
     pub notifications_sound_enabled: bool,
     pub realign_on_showhide: bool,
     pub allow_sliding: bool,
+    pub space_drag_multiplier: f32,
 }
 
 fn get_settings_path() -> PathBuf {
@@ -392,6 +396,7 @@ pub fn save_settings(config: &GeneralConfig) -> anyhow::Result<()> {
         notifications_sound_enabled: config.notifications_sound_enabled,
         realign_on_showhide: config.realign_on_showhide,
         allow_sliding: config.allow_sliding,
+        space_drag_multiplier: config.space_drag_multiplier,
     };
 
     let json = serde_json::to_string_pretty(&conf).unwrap(); // want panic

src/graphics.rs

@@ -42,8 +42,8 @@ use vulkano::{
         allocator::StandardDescriptorSetAllocator, DescriptorSet, WriteDescriptorSet,
     },
     device::{
-        physical::PhysicalDevice, Device, DeviceCreateInfo, DeviceExtensions, Features, Queue,
-        QueueCreateInfo, QueueFlags,
+        physical::PhysicalDevice, Device, DeviceCreateInfo, DeviceExtensions, DeviceFeatures,
+        Queue, QueueCreateInfo, QueueFlags,
     },
     format::Format,
     image::{
@@ -135,17 +135,13 @@ pub struct WlxGraphics {
     pub shared_shaders: RwLock<HashMap<&'static str, Arc<ShaderModule>>>,
 }
 
-fn get_device_extensions() -> DeviceExtensions {
-    #[cfg(not(feature = "no-dmabuf"))]
-    return DeviceExtensions {
+fn get_dmabuf_extensions() -> DeviceExtensions {
+    DeviceExtensions {
         khr_external_memory: true,
         khr_external_memory_fd: true,
         ext_external_memory_dma_buf: true,
-        ext_image_drm_format_modifier: true,
         ..DeviceExtensions::empty()
-    };
-    #[cfg(feature = "no-dmabuf")]
-    return DeviceExtensions::empty();
+    }
 }
 
 static VULKAN_LIBRARY: OnceLock<Arc<vulkano::VulkanLibrary>> = OnceLock::new();
@@ -196,7 +192,7 @@ impl WlxGraphics {
         let target_version = vulkano::Version::V1_3;
         let library = get_vulkan_library();
 
-        let vk_app_info_raw = vk::ApplicationInfo::builder()
+        let vk_app_info_raw = vk::ApplicationInfo::default()
             .application_version(0)
             .engine_version(0)
             .api_version(vk_target_version);
@@ -206,7 +202,7 @@ impl WlxGraphics {
                 .create_vulkan_instance(
                     system,
                     get_instance_proc_addr,
-                    &vk::InstanceCreateInfo::builder()
+                    &vk::InstanceCreateInfo::default()
                         .application_info(&vk_app_info_raw)
                         .enabled_extension_names(&instance_extensions_raw)
                         as *const _ as *const _,
@@ -258,12 +254,17 @@ impl WlxGraphics {
             .position(|(_, q)| q.queue_flags.intersects(QueueFlags::GRAPHICS))
             .expect("Vulkan device has no graphics queue") as u32;
 
-        let mut device_extensions = get_device_extensions();
-        if !physical_device
+        let mut device_extensions = DeviceExtensions::empty();
+        let dmabuf_extensions = get_dmabuf_extensions();
+
+        if physical_device
             .supported_extensions()
-            .ext_image_drm_format_modifier
+            .contains(&dmabuf_extensions)
         {
-            device_extensions.ext_image_drm_format_modifier = false;
+            device_extensions = device_extensions.union(&dmabuf_extensions);
+            device_extensions.ext_image_drm_format_modifier = physical_device
+                .supported_extensions()
+                .ext_image_drm_format_modifier;
         }
 
         let device_extensions_raw = device_extensions
@@ -278,26 +279,23 @@ impl WlxGraphics {
             })
             .collect::<Vec<_>>();
 
-        let features = Features {
+        let features = DeviceFeatures {
             dynamic_rendering: true,
             ..Default::default()
         };
 
         let queue_priorities = [1.0];
 
-        let queue_create_infos = [vk::DeviceQueueCreateInfo::builder()
+        let queue_create_infos = [vk::DeviceQueueCreateInfo::default()
             .queue_family_index(queue_family_index)
-            .queue_priorities(&queue_priorities)
-            .build()];
+            .queue_priorities(&queue_priorities)];
 
-        let mut device_create_info = vk::DeviceCreateInfo::builder()
+        let mut device_create_info = vk::DeviceCreateInfo::default()
             .queue_create_infos(&queue_create_infos)
-            .enabled_extension_names(&device_extensions_raw)
-            .build();
+            .enabled_extension_names(&device_extensions_raw);
 
-        let mut dynamic_rendering = PhysicalDeviceDynamicRenderingFeatures::builder()
-            .dynamic_rendering(true)
-            .build();
+        let mut dynamic_rendering =
+            PhysicalDeviceDynamicRenderingFeatures::default().dynamic_rendering(true);
 
         dynamic_rendering.p_next = device_create_info.p_next as _;
         device_create_info.p_next = (&mut dynamic_rendering) as *const _ as *const c_void;
@@ -330,6 +328,15 @@ impl WlxGraphics {
             )
         };
 
+        log::debug!(
+            "  DMA-buf supported: {}",
+            device.enabled_extensions().ext_external_memory_dma_buf
+        );
+        log::debug!(
+            "  DRM format modifiers supported: {}",
+            device.enabled_extensions().ext_image_drm_format_modifier
+        );
+
         // Drop the CStrings
         device_extensions_raw
             .into_iter()
@@ -380,6 +387,7 @@ impl WlxGraphics {
         //#[cfg(debug_assertions)]
         //let layers = vec!["VK_LAYER_KHRONOS_validation".to_owned()];
         //#[cfg(not(debug_assertions))]
+
         let layers = vec![];
 
         log::debug!("Instance exts for runtime: {:?}", &vk_instance_extensions);
@@ -396,30 +404,16 @@ impl WlxGraphics {
             },
         )?;
 
-        let device_extensions = get_device_extensions();
-        log::debug!("Device exts for app: {:?}", &device_extensions);
+        let dmabuf_extensions = get_dmabuf_extensions();
 
         let (physical_device, my_extensions, queue_family_index) = instance
             .enumerate_physical_devices()?
             .filter_map(|p| {
-                let runtime_extensions = vk_device_extensions_fn(&p);
-                log::debug!(
-                    "Device exts for {}: {:?}",
-                    p.properties().device_name,
-                    &runtime_extensions
-                );
-                let mut my_extensions = runtime_extensions.union(&device_extensions);
-                if p.supported_extensions().contains(&my_extensions) {
-                    Some((p, my_extensions))
-                } else {
-                    // try without DRM format modifiers
-                    my_extensions.ext_image_drm_format_modifier = false;
-                    if p.supported_extensions().contains(&my_extensions) {
-                        return Some((p, my_extensions));
-                    }
+                let mut my_extensions = vk_device_extensions_fn(&p);
 
+                if !p.supported_extensions().contains(&my_extensions) {
                     log::debug!(
-                        "Not using {} because it does not implement the following device extensions:",
+                        "Not using {} due to missing extensions:",
                         p.properties().device_name,
                     );
                     for (ext, missing) in p.supported_extensions().difference(&my_extensions) {
@@ -427,8 +421,21 @@ impl WlxGraphics {
                             log::debug!("  {}", ext);
                         }
                     }
-                    None
+                    return None;
                 }
+
+                if p.supported_extensions().contains(&dmabuf_extensions) {
+                    my_extensions = my_extensions.union(&dmabuf_extensions);
+                    my_extensions.ext_image_drm_format_modifier =
+                        p.supported_extensions().ext_image_drm_format_modifier;
+                }
+
+                log::debug!(
+                    "Device exts for {}: {:?}",
+                    p.properties().device_name,
+                    &my_extensions
+                );
+                Some((p, my_extensions))
             })
             .filter_map(|(p, my_extensions)| {
                 p.queue_family_properties()
@@ -456,9 +463,9 @@ impl WlxGraphics {
             physical_device,
             DeviceCreateInfo {
                 enabled_extensions: my_extensions,
-                enabled_features: Features {
+                enabled_features: DeviceFeatures {
                     dynamic_rendering: true,
-                    ..Features::empty()
+                    ..DeviceFeatures::empty()
                 },
                 queue_create_infos: vec![QueueCreateInfo {
                     queue_family_index,
@@ -468,6 +475,15 @@ impl WlxGraphics {
             },
         )?;
 
+        log::debug!(
+            "  DMA-buf supported: {}",
+            device.enabled_extensions().ext_external_memory_dma_buf
+        );
+        log::debug!(
+            "  DRM format modifiers supported: {}",
+            device.enabled_extensions().ext_image_drm_format_modifier
+        );
+
         let queue = queues
             .next()
             .ok_or_else(|| anyhow::anyhow!("no GPU queues available"))?;
@@ -511,7 +527,7 @@ impl WlxGraphics {
         Arc<vulkano::swapchain::Surface>,
     )> {
         use vulkano::swapchain::Surface;
-        use winit::{event_loop::EventLoop, window::WindowBuilder};
+        use winit::{event_loop::EventLoop, window::Window};
 
         let event_loop = EventLoop::new().unwrap();
         let mut vk_instance_extensions = Surface::required_extensions(&event_loop).unwrap();
@@ -527,10 +543,14 @@ impl WlxGraphics {
             },
         )?;
 
-        let window = Arc::new(WindowBuilder::new().build(&event_loop).unwrap());
+        let window = Arc::new(
+            event_loop
+                .create_window(Window::default_attributes())
+                .unwrap(),
+        );
         let surface = Surface::from_window(instance.clone(), window.clone())?;
 
-        let mut device_extensions = get_device_extensions();
+        let mut device_extensions = DeviceExtensions::empty();
         device_extensions.khr_swapchain = true;
 
         log::debug!("Device exts for app: {:?}", &device_extensions);
@@ -580,9 +600,9 @@ impl WlxGraphics {
             physical_device,
             DeviceCreateInfo {
                 enabled_extensions: my_extensions,
-                enabled_features: Features {
+                enabled_features: DeviceFeatures {
                     dynamic_rendering: true,
-                    ..Features::empty()
+                    ..DeviceFeatures::empty()
                 },
                 queue_create_infos: vec![QueueCreateInfo {
                     queue_family_index,
@@ -988,10 +1008,7 @@ impl WlxGraphics {
             (fns.v1_0.queue_submit)(
                 self.queue.handle(),
                 1,
-                [SubmitInfo::builder()
-                    .command_buffers(&[command_buffer.handle()])
-                    .build()]
-                .as_ptr(),
+                [SubmitInfo::default().command_buffers(&[command_buffer.handle()])].as_ptr(),
                 fence.handle(),
             )
         }
@@ -1144,7 +1161,7 @@ impl WlxPipeline<WlxPipelineDynamic> {
         let vep = vert.entry_point("main").unwrap(); // want panic
         let fep = frag.entry_point("main").unwrap(); // want panic
 
-        let vertex_input_state = Vert2Uv::per_vertex().definition(&vep.info().input_interface)?;
+        let vertex_input_state = Vert2Uv::per_vertex().definition(&vep)?;
 
         let stages = smallvec![
             vulkano::pipeline::PipelineShaderStageCreateInfo::new(vep),
@@ -1301,7 +1318,7 @@ impl WlxPipeline<WlxPipelineLegacy> {
         let vep = vert.entry_point("main").unwrap(); // want panic
         let fep = frag.entry_point("main").unwrap(); // want panic
 
-        let vertex_input_state = Vert2Uv::per_vertex().definition(&vep.info().input_interface)?;
+        let vertex_input_state = Vert2Uv::per_vertex().definition(&vep)?;
 
         let stages = smallvec![
             vulkano::pipeline::PipelineShaderStageCreateInfo::new(vep),

src/gui/modular/button.rs

@@ -134,6 +134,9 @@ pub enum ButtonAction {
         channel: ColorChannel,
         delta: f32,
     },
+    DragMultiplier {
+        delta: f32,
+    },
     System {
         action: SystemAction,
     },
@@ -330,6 +333,9 @@ fn handle_action(action: &ButtonAction, press: &mut PressData, app: &mut AppStat
                 .enqueue(TaskType::System(SystemTask::ColorGain(channel, delta)));
         }
         ButtonAction::System { action } => run_system(action, app),
+        ButtonAction::DragMultiplier { delta } => {
+            app.session.config.space_drag_multiplier += delta;
+        }
     }
 }
 

src/gui/modular/label.rs

@@ -38,6 +38,7 @@ pub enum LabelContent {
         low_color: Arc<str>,
         charging_color: Arc<str>,
     },
+    DragMultiplier,
     Ipd,
 }
 
@@ -66,6 +67,7 @@ pub enum LabelData {
     Ipd {
         last_ipd: f32,
     },
+    DragMultiplier,
 }
 
 pub fn modular_label_init(label: &mut ModularControl, content: &LabelContent) {
@@ -111,6 +113,7 @@ pub fn modular_label_init(label: &mut ModularControl, content: &LabelContent) {
             None
         }
         LabelContent::Ipd => Some(LabelData::Ipd { last_ipd: 0. }),
+        LabelContent::DragMultiplier => Some(LabelData::DragMultiplier),
     };
 
     if let Some(state) = state {
@@ -249,5 +252,8 @@ pub(super) fn label_update(control: &mut ModularControl, _: &mut (), app: &mut A
                 control.set_text(&format!("{:.1}", app.input_state.ipd));
             }
         }
+        LabelData::DragMultiplier => {
+            control.set_text(&format!("{:.1}", app.session.config.space_drag_multiplier));
+        }
     }
 }

src/hid/x11.rs

@@ -1,6 +1,9 @@
 use xkbcommon::xkb::{
     self,
-    x11::{get_core_keyboard_device_id, keymap_new_from_device},
+    x11::{
+        get_core_keyboard_device_id, keymap_new_from_device, setup_xkb_extension,
+        SetupXkbExtensionFlags, MIN_MAJOR_XKB_VERSION, MIN_MINOR_XKB_VERSION,
+    },
 };
 
 use super::XkbKeymap;
@@ -9,7 +12,23 @@ pub fn get_keymap_x11() -> anyhow::Result<XkbKeymap> {
     let context = xkb::Context::new(xkb::CONTEXT_NO_FLAGS);
 
     let (conn, _) = xcb::Connection::connect(None)?;
+    setup_xkb_extension(
+        &conn,
+        MIN_MAJOR_XKB_VERSION,
+        MIN_MINOR_XKB_VERSION,
+        SetupXkbExtensionFlags::NoFlags,
+        &mut 0,
+        &mut 0,
+        &mut 0,
+        &mut 0,
+    );
+
     let device_id = get_core_keyboard_device_id(&conn);
+    if device_id == -1 {
+        return Err(anyhow::anyhow!(
+            "get_core_keyboard_device_id returned -1. Check your XKB installation."
+        ));
+    }
     let keymap = keymap_new_from_device(&context, &conn, device_id, xkb::KEYMAP_COMPILE_NO_FLAGS);
 
     Ok(XkbKeymap { context, keymap })

src/main.rs

@@ -21,7 +21,7 @@ use clap::Parser;
 use flexi_logger::{Duplicate, FileSpec, LogSpecification};
 
 /// The lightweight desktop overlay for OpenVR and OpenXR
-#[derive(Parser, Debug)]
+#[derive(Default, Parser, Debug)]
 #[command(version, about, long_about = None)]
 struct Args {
     #[cfg(feature = "openvr")]
@@ -57,7 +57,11 @@ struct Args {
 }
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let mut args = Args::parse();
+    let mut args = if std::env::args().skip(1).any(|a| !a.is_empty()) {
+        Args::parse()
+    } else {
+        Args::default()
+    };
 
     if !args.multi && !ensure_single_instance(args.replace) {
         println!("Looks like WlxOverlay-S is already running.");

src/res/keyboard.yaml

@@ -62,29 +62,51 @@ macros:
 # Value: Array of strings. 0th element is the upper row, 1st element is lower row.
 # For empty labels, use [] (do not use ~)
 labels:
-    "Escape":       ["Esc"]
-    "Prior":        ["PgUp"]
-    "Next":         ["PgDn"]
-    "NumLock":      ["Num"]
-    "Space":        []
-    "LAlt":         ["Alt"]
-    "LCtrl":        ["Ctrl"]
-    "RCtrl":        ["Ctrl"]
-    "LSuper":       ["Super"]
-    "RSuper":       ["Super"]
-    "LShift":       ["Shift"]
-    "RShift":       ["Shift"]
-    "Insert":       ["Ins"]
-    "Delete":       ["Del"]
-    "BackSpace":    ["<<"]
-    "KP_Divide":    [" /"]
-    "KP_Add":       [" +"]
-    "KP_Multiply":  [" *"]
-    "KP_Decimal":   [" ."]
-    "KP_Subtract":  [" -"]
-    "KP_Enter":     ["Ent"]
-    "Print":        ["Prn"]
-    "Scroll":       ["Scr"]
-    "Pause":        ["Brk"]
-    "XF86Favorites": ["Rofi"]
+    "Escape":         ["Esc"]
+    "Prior":          ["PgUp"]
+    "Next":           ["PgDn"]
+    "NumLock":        ["Num"]
+    "Space":          []
+    "LAlt":           ["Alt"]
+    "LCtrl":          ["Ctrl"]
+    "RCtrl":          ["Ctrl"]
+    "LSuper":         ["Super"]
+    "RSuper":         ["Super"]
+    "LShift":         ["Shift"]
+    "RShift":         ["Shift"]
+    "Insert":         ["Ins"]
+    "Delete":         ["Del"]
+    "BackSpace":      ["<<"]
+    "KP_Divide":      [" /"]
+    "KP_Add":         [" +"]
+    "KP_Multiply":    [" *"]
+    "KP_Decimal":     [" ."]
+    "KP_Subtract":    [" -"]
+    "KP_Enter":       ["Ent"]
+    "Print":          ["Prn"]
+    "Scroll":         ["Scr"]
+    "Pause":          ["Brk"]
+    "XF86Favorites":  ["Menu"] # fallback labels below
+    "N1":             ["1", "!"]
+    "N2":             ["2", "@"]
+    "N3":             ["3", "#"]
+    "N4":             ["4", "$"]
+    "N5":             ["5", "%"]
+    "N6":             ["6", "^"]
+    "N7":             ["7", "&"]
+    "N8":             ["8", "*"]
+    "N9":             ["9", "("]
+    "N0":             ["0", ")"]
+    "Minus":          ["-", "_"]
+    "Plus":           ["=", "+"]
+    "Comma":          [" ,",  "<"]
+    "Period":         [" .",  ">"]
+    "Oem1":           [" ;",  ":"]
+    "Oem2":           [" /",  "?"]
+    "Oem3":           ["`", "~"]
+    "Oem4":           [" [",  "{"]
+    "Oem5":           [" \\", "|"]
+    "Oem6":           [" ]",  "}"]
+    "Oem7":           [" '",  "\""]
+    "Oem102":         [" \\", "|"]