release 0.6

release modifiers on keyboard hide
add virtualkey action for modular button
2026-10-28 17:26:14 +01:00 · 2024-09-28 01:54:53 +09:00 · 2024-09-28 01:53:20 +09:00 · 2024-09-27 02:23:13 +09:00 · 2024-09-26 23:51:46 +09:00 · 2024-09-26 23:51:44 +09:00
31 changed files with 987 additions and 249 deletions
@@ -0,0 +1,51 @@
+name: Build AppImage
+
+on:
+  push:
+    branches:
+      - 'main'
+
+env:
+  APPDIR: WlxOverlay-S.AppDir
+  CARGO_TERM_COLOR: always
+  SCCACHE_GHA_ENABLED: "true"
+  RUSTC_WRAPPER: "sccache"
+  
+jobs:
+  build_appimage:
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup sccache
+        uses: mozilla-actions/sccache-action@v0.0.3
+      - name: Prepare Environment
+        run: |
+          sudo add-apt-repository -syn universe
+          sudo add-apt-repository -syn ppa:pipewire-debian/pipewire-upstream || sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 25088A0359807596
+          sudo apt-get update
+          sudo apt-get install -y fuse cmake pkg-config fontconfig libasound2-dev libxkbcommon-dev libxkbcommon-x11-0 libxkbcommon-x11-dev libopenxr-dev libfontconfig-dev libdbus-1-dev libpipewire-0.3-0 libpipewire-0.3-dev libspa-0.2-dev libx11-6 libxext6 libxrandr2 libx11-dev libxext-dev libxrandr-dev libopenvr-dev libopenvr-api1
+          rustup update
+          
+          test -f linuxdeploy-x86_64.AppImage || wget -q "https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-x86_64.AppImage"
+          chmod +x linuxdeploy-x86_64.AppImage
+          
+          test -d ${APPDIR} && rm -rf ${APPDIR}
+          mkdir -p ${APPDIR}/usr/bin 
+          
+      - name: Cargo Build
+        run: |
+          cargo build --release
+          mv target/release/wlx-overlay-s ${APPDIR}/usr/bin
+          chmod +x ${APPDIR}/usr/bin/wlx-overlay-s
+
+      - name: Package AppImage
+        run: |
+          export VERSION=$GITHUB_REF_NAME
+          ./linuxdeploy-x86_64.AppImage -dwlx-overlay-s.desktop -iwlx-overlay-s.png --appdir=${APPDIR} --output appimage --exclude-library '*libpipewire*'
+          mv WlxOverlay-S-$VERSION-x86_64.AppImage WlxOverlay-S-x86_64.AppImage
+
+      - name: Upload AppImage
+        uses: actions/upload-artifact@v4
+        with:
+          name: WlxOverlay-S-${{ github.ref_name }}-x86_64.AppImage
+          path: ./WlxOverlay-S-x86_64.AppImage
@@ -2,7 +2,7 @@ name: Check Full

 on:
  pull_request:
-    #branches: [ "main" ]
+    branches: [ "!main" ]

 env:
  CARGO_TERM_COLOR: always
@@ -225,11 +225,11 @@ checksum = "175571dd1d178ced59193a6fc02dde1b972eb0bc56c892cde9beeceac5bf0f6b"

 [[package]]
 name = "ash"
-version = "0.38.0+1.3.281"
+version = "0.37.3+1.3.251"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0bb44936d800fea8f016d7f2311c6a4f97aebd5dc86f09906139ec848cf3a46f"
+checksum = "39e9c3835d686b0a6084ab4234fcd1b07dbf6e4767dce60874b12356a25ecd4a"
 dependencies = [
- "libloading",
+ "libloading 0.7.4",
 ]

 [[package]]
@@ -789,7 +789,7 @@ checksum = "0b023947811758c97c59bf9d1c188fd619ad4718dcaa767947df1cadb14f39f4"
 dependencies = [
 "glob",
 "libc",
- "libloading",
+ "libloading 0.8.5",
 ]

 [[package]]
@@ -1264,7 +1264,7 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "330c60081dcc4c72131f8eb70510f1ac07223e5d4163db481a04a0befcffa412"
 dependencies = [
- "libloading",
+ "libloading 0.8.5",
 ]

 [[package]]
@@ -2031,6 +2031,16 @@ dependencies = [
 "pkg-config",
 ]

+[[package]]
+name = "libloading"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b67380fd3b2fbe7527a606e18729d21c6f3951633d0500574c4dc22d2d638b9f"
+dependencies = [
+ "cfg-if",
+ "winapi",
+]
+
 [[package]]
 name = "libloading"
 version = "0.8.5"
@@ -2671,7 +2681,7 @@ version = "0.18.0"
 source = "git+https://github.com/galister/openxrs?rev=af4a55d#af4a55df60125491c80c61464c824219c6019b76"
 dependencies = [
 "libc",
- "libloading",
+ "libloading 0.8.5",
 "ndk-context",
 "openxr-sys",
 ]
@@ -2682,6 +2692,7 @@ version = "0.10.0"
 source = "git+https://github.com/galister/openxrs?rev=af4a55d#af4a55df60125491c80c61464c824219c6019b76"
 dependencies = [
 "libc",
+ "mint",
 ]

 [[package]]
@@ -3471,12 +3482,6 @@ dependencies = [
 "autocfg",
 ]

-[[package]]
-name = "slabbin"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd8305086044614627ed85432d27b87cf9fc047204eaa036a11de6cf0120f273"
-
 [[package]]
 name = "slice-of-array"
 version = "0.3.2"
@@ -3907,7 +3912,7 @@ dependencies = [
 [[package]]
 name = "vulkano"
 version = "0.34.0"
-source = "git+https://github.com/vulkano-rs/vulkano?rev=b9f3e89#b9f3e893005078b5680cd1672037465a2b5f3133"
+source = "git+https://github.com/vulkano-rs/vulkano?rev=94f50f1#94f50f18bd25971ea123adb8b5782ad65a8f085c"
 dependencies = [
 "ahash",
 "ash",
@@ -3917,17 +3922,16 @@ dependencies = [
 "half",
 "heck 0.4.1",
 "indexmap 2.3.0",
- "libloading",
- "nom",
+ "libloading 0.8.5",
 "objc",
 "once_cell",
 "parking_lot",
 "proc-macro2",
 "quote",
 "raw-window-handle",
+ "regex",
 "serde",
 "serde_json",
- "slabbin",
 "smallvec",
 "thread_local",
 "vk-parse",
@@ -3937,7 +3941,7 @@ dependencies = [
 [[package]]
 name = "vulkano-macros"
 version = "0.34.0"
-source = "git+https://github.com/vulkano-rs/vulkano?rev=b9f3e89#b9f3e893005078b5680cd1672037465a2b5f3133"
+source = "git+https://github.com/vulkano-rs/vulkano?rev=94f50f1#94f50f18bd25971ea123adb8b5782ad65a8f085c"
 dependencies = [
 "proc-macro-crate 2.0.2",
 "proc-macro2",
@@ -3948,7 +3952,7 @@ dependencies = [
 [[package]]
 name = "vulkano-shaders"
 version = "0.34.0"
-source = "git+https://github.com/vulkano-rs/vulkano?rev=b9f3e89#b9f3e893005078b5680cd1672037465a2b5f3133"
+source = "git+https://github.com/vulkano-rs/vulkano?rev=94f50f1#94f50f18bd25971ea123adb8b5782ad65a8f085c"
 dependencies = [
 "ahash",
 "heck 0.4.1",
@@ -4555,7 +4559,7 @@ dependencies = [
 [[package]]
 name = "wlx-capture"
 version = "0.3.12"
-source = "git+https://github.com/galister/wlx-capture?tag=v0.3.12#14d2b8a13dad62849973fe90bed7be262aa07143"
+source = "git+https://github.com/galister/wlx-capture?tag=v0.3.13#c375a7c1d4b57741655a052ebe8af9fb4774f92d"
 dependencies = [
 "ashpd",
 "drm-fourcc",
@@ -4573,7 +4577,7 @@ dependencies = [

 [[package]]
 name = "wlx-overlay-s"
-version = "0.4.3"
+version = "0.6.0"
 dependencies = [
 "anyhow",
 "ash",
@@ -4599,6 +4603,7 @@ dependencies = [
 "libmonado-rs",
 "log",
 "log-panics",
+ "mint",
 "once_cell",
 "openxr",
 "ovr_overlay",
@@ -4642,7 +4647,7 @@ dependencies = [
 "as-raw-xcb-connection",
 "gethostname",
 "libc",
- "libloading",
+ "libloading 0.8.5",
 "once_cell",
 "rustix",
 "x11rb-protocol",
@@ -4,14 +4,14 @@ debug = true

 [package]
 name = "wlx-overlay-s"
-version = "0.4.3"
+version = "0.6.0"
 edition = "2021"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
 anyhow = "1.0.86"
-ash = "^0.38.0"
+ash = "^0.37.2"
 chrono = "0.4.38"
 chrono-tz = "0.9.0"
 clap = { version = "4.5.6", features = ["derive"] }
@@ -34,6 +34,7 @@ log = "0.4.21"
 once_cell = "1.19.0"
 openxr = { git = "https://github.com/galister/openxrs", rev = "af4a55d", features = [
  "linked",
+  "mint",
 ], optional = true }
 ovr_overlay = { features = [
  "ovr_input",
@@ -52,9 +53,9 @@ smallvec = "1.13.2"
 strum = { version = "0.26.2", features = ["derive"] }
 sysinfo = { version = "0.31.2" }
 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.12", default-features = false }
+vulkano = { git = "https://github.com/vulkano-rs/vulkano", rev = "94f50f1" }
+vulkano-shaders = { git = "https://github.com/vulkano-rs/vulkano", rev = "94f50f1" }
+wlx-capture = { git = "https://github.com/galister/wlx-capture", tag = "v0.3.13", default-features = false }
 libmonado-rs = { git = "https://github.com/technobaboo/libmonado-rs", rev = "a495f6d", optional = true }
 winit = { version = "0.30.0", optional = true }
 xdg = "2.5.2"
@@ -67,6 +68,10 @@ xcb = { version = "1.4.0", optional = true, features = [
 image_dds = { version = "0.6.0", default-features = false, features = [
  "ddsfile",
 ] }
+mint = "0.5.9"
+
+[build-dependencies]
+regex = { version = "*" }

 [features]
 default = ["openvr", "openxr", "osc", "x11", "wayland"]
@@ -6,21 +6,18 @@ WlxOverlay-S allows you to access your desktop screens while in VR.

 In comparison to similar overlays, WlxOverlay-S aims to run alongside VR games and experiences while having as little performance impact as possible. The UI appearance and rendering techniques are kept as simple and efficient as possible, while still allowing a high degree of customizability.

-This is the coming-together of two of my previous projects:
- [WlxOverlay](https://github.com/galister/WlxOverlay) (SteamVR overlay written in C#)
- [WlxOverlay-X](https://github.com/galister/wlx-overlay-x) (OpenXR overlay using StereoKit, written in Rust)
+![Screenshot of WlxOverlay-S being used as an OpenXR home environment](https://github.com/galister/wlx-overlay-s/blob/guide/wlx-s.png?raw=true)

-![Screenshot of WlxOverlay-S in Action](https://github.com/galister/wlx-overlay-s/blob/guide/wlx-s.png?raw=true)
-
-# Join the Linux VR Community
+## Join the Linux VR Community

 We are available on either:
- Discord: https://discord.gg/gHwJ2vwSWV
+
+- Discord: <https://discord.gg/gHwJ2vwSWV>
 - Matrix Space: `#linux-vr-adventures:matrix.org`

 Questions/issues specific to WlxOverlay-S will be handled in the `wlxoverlay` chat room.

-# Setup
+## Setup

 1. Grab the latest AppImage from [Releases](https://github.com/galister/wlx-overlay-s/releases).
 1. `chmod +x WlxOverlay-S-*.AppImage`
@@ -31,18 +28,21 @@ AUR package is [wlx-overlay-s-git](https://aur.archlinux.org/packages/wlx-overla

 You may also want to [build from source](https://github.com/galister/wlx-overlay-s/wiki/Building-from-Source).

-# First Start
+## First Start

-**If you get a screen share pop-up, check the terminal and select the screens in the order it tells you to.**
+**When the screen share pop-up appears, check the terminal and select the screens in the order it requests.**

 If you selected the screens in the wrong order:
-  - `rm ~/.config/wlxoverlay/conf.d/pw_tokens.yaml` then restart

-SteamVR users: WlxOverlay-S will register itself for auto-start, so you will not need to start it every time.
+- `rm ~/.config/wlxoverlay/conf.d/pw_tokens.yaml` then restart
+
+**SteamVR users**: WlxOverlay-S will register itself for auto-start, so you will not need to start it every time.
+
+**Envision users**: Set `wlx-overlay-s --openxr --show` as the _Autostart Command_ on your Envision profile! This will give you a home environment with a [customizable background](https://github.com/galister/wlx-overlay-s/wiki/OpenXR-Skybox)!

 **Please continue reading the guide below.**

-# Getting Started
+## Getting Started

 ### Working Set

@@ -51,6 +51,7 @@ Your working set consists of your currently selected overlays; screens, mirrors,
 The working set appears in front of you when shown, and can be re-centered by hiding and showing again.

 Show and hide your working set using:
+
 - Non-vive controller: double-tap B or Y on your left controller.
 - Vive controller: double-tap the menu button on your left controller (OpenXR, for SteamVR, you might need to bind `showhide` yourself.)

@@ -58,6 +59,7 @@ Show and hide your working set using:

 Much of the functionality in WlxOverlay-S depends on what color of laser you are using to interact with a UI element. \
 Using the default settings, there are 3 modes:
+
 - Regular Mode: Blue laser
 - Right-click Mode: Orange laser
 - Middle-click Mode: Purple laser
@@ -77,6 +79,7 @@ Check your left wrist for the watch. The watch is your primary tool for controll
 Hovering a pointer over a screen will move the mouse. If there are more than one pointers hovering a screen, the pointer that was last used to click will take precedence.

 The click depends on the laser color:
+
 - Blue laser: Left click
 - Orange laser: Right click
 - Purple laser: Middle click
@@ -92,6 +95,7 @@ The keyboard is fully customizable via the [keyboard.yaml](https://raw.githubuse
 Download it into your `~/.config/wlxoverlay/` folder and edit it to your liking.

 Typing
+
 - Use the BLUE laser when typing regularly.
 - While using ORANGE laser, all keystrokes will have SHIFT applied.
 - Purple laser has no effect as of now.
@@ -104,36 +108,36 @@ Typing

 ![Touch Controller Bindings](https://github.com/galister/wlx-overlay-s/blob/guide/wlx-oculus.png)

+To customize bindings on OpenXR, refer to the [OpenXR Bindings wiki page](https://github.com/galister/wlx-overlay-s/wiki/OpenXR-Bindings).
+
 If your bindings are not supported, please reach out. \
 We would like to work with you and include additional bindings.

-# Troubleshooting
+## Troubleshooting

 Check [here](https://github.com/galister/wlx-overlay-s/wiki/Troubleshooting) for tips.

-# Known Issues
+## Known Issues
+
+### Mouse is not where it should be

-## Mouse is not where it should be
 Hyprland users: Hyprland v0.41.0 changed their absolute input implementation to one that does not respect existing absolute input standards. Make your voice heard: [Hyprland#6023](https://github.com/hyprwm/Hyprland/issues/6023)・[Hyprland#6889](https://github.com/hyprwm/Hyprland/issues/6889)

 Niri users: use on Niri 0.1.7 or later.

 Other desktops: You may have selected the screens in the wrong order, see [First Start](#first-start).

-## Space-drag crashes SteamVR
+### Space-drag crashes SteamVR

 This has been idenfitied as an issue with SteamVR versions 2.5.5 and above (latest tested 2.7.2). One way to avoid the crash is by switching to the `temp-v1.27.5` branch of SteamVR (via beta selection) and selecting [Steam-Play-None](https://github.com/Scrumplex/Steam-Play-None) under the compatibility tab.

-## Modifiers get stuck in weird ways
+### Modifiers get stuck in weird ways

 This is a rare issue that can make your desktop not react to click or keys due to a modifier being stuck somewhere. Restarting the overlay fixes this.

-## Scroll wheel doesn't work
-
-This seems to be an issue specific to Electron apps (Discord, Element, Slack, Spotify) on Wayland. Scrolling will work when using these in your web browser.
-
-## X11 limitations
+### X11 limitations

+- X11 capture can generally seem slow. This is because zero-copy GPU capture is not supported on the general X11 desktop. Consider trying Wayland or Picom.
 - DPI scaling is not supported and may cause the mouse to not follow the laser properly.
 - Upright screens are not supported and can cause the mouse to act weirdly.
 - Screen changes (connecting / disconnecting a display, resolution changes, etc) are not handled at runtime. Restart the overlay for these to take effect.
@@ -0,0 +1,40 @@
+use regex::Regex;
+use std::process::Command;
+
+fn main() {
+    let mut wlx_build = get_version().unwrap_or(format!("{}-unknown", env!("CARGO_PKG_VERSION")));
+
+    match std::env::var("GITHUB_JOB").as_deref() {
+        Ok("make_release") => {
+            wlx_build = format!("{} (Release)", &wlx_build);
+        }
+        Ok("build_appimage") => {
+            wlx_build = format!("{} (AppImage)", &wlx_build);
+        }
+        _ => {}
+    }
+    println!("cargo:rustc-env=WLX_BUILD={}", &wlx_build);
+}
+
+fn get_version() -> Result<String, Box<dyn std::error::Error>> {
+    let re = Regex::new(r"v([0-9.]+)-([0-9]+)-g([a-f0-9]+)").unwrap(); // safe
+    let output = Command::new("git")
+        .args(["describe", "--tags", "--abbrev=7", "--dirty"])
+        .output()?;
+
+    let mut output_str = String::from_utf8(output.stdout)?;
+
+    if output_str.is_empty() {
+        let output = Command::new("git")
+            .args(["describe", "--tags", "--abbrev=7", "--dirty", "--always"])
+            .output()?;
+
+        output_str = format!(
+            "{}-{}",
+            env!("CARGO_PKG_VERSION"),
+            String::from_utf8(output.stdout)?
+        );
+    }
+
+    Ok(re.replace_all(&output_str, "${1}.r${2}.${3}").into_owned())
+}
@@ -73,6 +73,9 @@ impl InputState {
                if hand.now.space_rotate != hand.before.space_rotate {
                    log::debug!("Hand {}: space_rotate {}", hand.idx, hand.now.space_rotate);
                }
+                if hand.now.space_reset != hand.before.space_reset {
+                    log::debug!("Hand {}: space_reset {}", hand.idx, hand.now.space_reset);
+                }
                if hand.now.click_modifier_right != hand.before.click_modifier_right {
                    log::debug!(
                        "Hand {}: click_modifier_right {}",
@@ -192,6 +195,7 @@ pub struct PointerState {
    pub show_hide: bool,
    pub space_drag: bool,
    pub space_rotate: bool,
+    pub space_reset: bool,
    pub click_modifier_right: bool,
    pub click_modifier_middle: bool,
    pub move_mouse: bool,
@@ -309,15 +313,17 @@ where
            pointer = &mut app.input_state.pointers[idx];
            pointer.interaction.hovered_id = None;
        }
-        if let Some(clicked_id) = pointer.interaction.clicked_id.take() {
-            if let Some(clicked) = overlays.mut_by_id(clicked_id) {
-                let hit = PointerHit {
-                    pointer: pointer.idx,
-                    overlay: clicked_id,
-                    mode: pointer.interaction.mode,
-                    ..Default::default()
-                };
-                clicked.backend.on_pointer(app, &hit, false);
+        if !pointer.now.click && pointer.before.click {
+            if let Some(clicked_id) = pointer.interaction.clicked_id.take() {
+                if let Some(clicked) = overlays.mut_by_id(clicked_id) {
+                    let hit = PointerHit {
+                        pointer: pointer.idx,
+                        overlay: clicked_id,
+                        mode: pointer.interaction.mode,
+                        ..Default::default()
+                    };
+                    clicked.backend.on_pointer(app, &hit, false);
+                }
            }
        }
        return (0.0, None); // no hit
@@ -366,7 +372,10 @@ where
        );
    }

+    // Pass mouse motion events only if not scrolling
+    // (allows scrolling on all Chromium-based applications)
    let haptics = hovered.backend.on_hover(app, &hit);
+
    pointer = &mut app.input_state.pointers[idx];

    if pointer.now.scroll.abs() > 0.1 {
@@ -376,12 +385,9 @@ where
            .grabbed
            .is_some_and(|x| x.grabbed_id == hit.overlay)
        {
-            let is_portrait = hovered.view().is_some_and(|v| {
-                let extent = v.image().extent();
-                extent[0] >= extent[1]
-            });
+            let can_curve = hovered.extent().is_some_and(|e| e[0] >= e[1]);

-            if is_portrait {
+            if can_curve {
                let cur = hovered.state.curvature.unwrap_or(0.0);
                let new = (cur - scroll * 0.01).min(0.35);
                if new <= f32::EPSILON {
@@ -389,6 +395,8 @@ where
                } else {
                    hovered.state.curvature = Some(new);
                }
+            } else {
+                hovered.state.curvature = None;
            }
        } else {
            hovered.backend.on_scroll(app, &hit, scroll);
@@ -2,6 +2,9 @@ pub mod common;
 pub mod input;
 pub mod notifications;

+#[allow(clippy::all)]
+mod notifications_dbus;
+
 #[cfg(feature = "openvr")]
 pub mod openvr;

@@ -1,4 +1,9 @@
-use dbus::{blocking::Connection, channel::MatchingReceiver, message::MatchRule};
+use dbus::{
+    arg::{PropMap, Variant},
+    blocking::Connection,
+    channel::MatchingReceiver,
+    message::MatchRule,
+};
 use serde::Deserialize;
 use std::{
    sync::{
@@ -9,6 +14,7 @@ use std::{
 };

 use crate::{
+    backend::notifications_dbus::OrgFreedesktopNotifications,
    overlays::toast::{Toast, ToastTopic},
    state::AppState,
 };
@@ -196,6 +202,60 @@ impl Drop for NotificationManager {
    }
 }

+pub struct DbusNotificationSender {
+    connection: Connection,
+}
+
+impl DbusNotificationSender {
+    pub fn new() -> anyhow::Result<Self> {
+        Ok(Self {
+            connection: Connection::new_session()?,
+        })
+    }
+
+    pub fn notify_send(
+        &self,
+        summary: &str,
+        body: &str,
+        urgency: u8,
+        timeout: i32,
+        replaces_id: u32,
+        transient: bool,
+    ) -> anyhow::Result<u32> {
+        let proxy = self.connection.with_proxy(
+            "org.freedesktop.Notifications",
+            "/org/freedesktop/Notifications",
+            Duration::from_millis(1000),
+        );
+
+        let mut hints = PropMap::new();
+        hints.insert("urgency".to_string(), Variant(Box::new(urgency)));
+        hints.insert("transient".to_string(), Variant(Box::new(transient)));
+
+        Ok(proxy.notify(
+            "WlxOverlay-S",
+            replaces_id,
+            "",
+            summary,
+            body,
+            vec![],
+            hints,
+            timeout,
+        )?)
+    }
+
+    pub fn notify_close(&self, id: u32) -> anyhow::Result<()> {
+        let proxy = self.connection.with_proxy(
+            "org.freedesktop.Notifications",
+            "/org/freedesktop/Notifications",
+            Duration::from_millis(1000),
+        );
+
+        proxy.close_notification(id)?;
+        Ok(())
+    }
+}
+
 fn parse_dbus(msg: &dbus::Message) -> anyhow::Result<Toast> {
    let mut args = msg.iter_init();
    let app_name: String = args.read()?;
@@ -0,0 +1,267 @@
+// This code was autogenerated with `dbus-codegen-rust -g -m None -d org.freedesktop.Notifications -p /org/freedesktop/Notifications`, see https://github.com/diwic/dbus-rs
+use dbus as dbus;
+#[allow(unused_imports)]
+use dbus::arg;
+use dbus::blocking;
+
+pub trait OrgFreedesktopDBusProperties {
+    fn get<R0: for<'b> arg::Get<'b> + 'static>(&self, interface_name: &str, property_name: &str) -> Result<R0, dbus::Error>;
+    fn get_all(&self, interface_name: &str) -> Result<arg::PropMap, dbus::Error>;
+    fn set<I2: arg::Arg + arg::Append>(&self, interface_name: &str, property_name: &str, value: I2) -> Result<(), dbus::Error>;
+}
+
+#[derive(Debug)]
+pub struct OrgFreedesktopDBusPropertiesPropertiesChanged {
+    pub interface_name: String,
+    pub changed_properties: arg::PropMap,
+    pub invalidated_properties: Vec<String>,
+}
+
+impl arg::AppendAll for OrgFreedesktopDBusPropertiesPropertiesChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.interface_name, i);
+        arg::RefArg::append(&self.changed_properties, i);
+        arg::RefArg::append(&self.invalidated_properties, i);
+    }
+}
+
+impl arg::ReadAll for OrgFreedesktopDBusPropertiesPropertiesChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(OrgFreedesktopDBusPropertiesPropertiesChanged {
+            interface_name: i.read()?,
+            changed_properties: i.read()?,
+            invalidated_properties: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for OrgFreedesktopDBusPropertiesPropertiesChanged {
+    const NAME: &'static str = "PropertiesChanged";
+    const INTERFACE: &'static str = "org.freedesktop.DBus.Properties";
+}
+
+impl<'a, T: blocking::BlockingSender, C: ::std::ops::Deref<Target=T>> OrgFreedesktopDBusProperties for blocking::Proxy<'a, C> {
+
+    fn get<R0: for<'b> arg::Get<'b> + 'static>(&self, interface_name: &str, property_name: &str) -> Result<R0, dbus::Error> {
+        self.method_call("org.freedesktop.DBus.Properties", "Get", (interface_name, property_name, ))
+            .and_then(|r: (arg::Variant<R0>, )| Ok((r.0).0, ))
+    }
+
+    fn get_all(&self, interface_name: &str) -> Result<arg::PropMap, dbus::Error> {
+        self.method_call("org.freedesktop.DBus.Properties", "GetAll", (interface_name, ))
+            .and_then(|r: (arg::PropMap, )| Ok(r.0, ))
+    }
+
+    fn set<I2: arg::Arg + arg::Append>(&self, interface_name: &str, property_name: &str, value: I2) -> Result<(), dbus::Error> {
+        self.method_call("org.freedesktop.DBus.Properties", "Set", (interface_name, property_name, arg::Variant(value), ))
+    }
+}
+
+pub trait OrgFreedesktopDBusIntrospectable {
+    fn introspect(&self) -> Result<String, dbus::Error>;
+}
+
+impl<'a, T: blocking::BlockingSender, C: ::std::ops::Deref<Target=T>> OrgFreedesktopDBusIntrospectable for blocking::Proxy<'a, C> {
+
+    fn introspect(&self) -> Result<String, dbus::Error> {
+        self.method_call("org.freedesktop.DBus.Introspectable", "Introspect", ())
+            .and_then(|r: (String, )| Ok(r.0, ))
+    }
+}
+
+pub trait OrgFreedesktopDBusPeer {
+    fn ping(&self) -> Result<(), dbus::Error>;
+    fn get_machine_id(&self) -> Result<String, dbus::Error>;
+}
+
+impl<'a, T: blocking::BlockingSender, C: ::std::ops::Deref<Target=T>> OrgFreedesktopDBusPeer for blocking::Proxy<'a, C> {
+
+    fn ping(&self) -> Result<(), dbus::Error> {
+        self.method_call("org.freedesktop.DBus.Peer", "Ping", ())
+    }
+
+    fn get_machine_id(&self) -> Result<String, dbus::Error> {
+        self.method_call("org.freedesktop.DBus.Peer", "GetMachineId", ())
+            .and_then(|r: (String, )| Ok(r.0, ))
+    }
+}
+
+pub trait OrgFreedesktopNotifications {
+    fn set_noti_window_visibility(&self, value: bool) -> Result<(), dbus::Error>;
+    fn toggle_dnd(&self) -> Result<bool, dbus::Error>;
+    fn set_dnd(&self, state: bool) -> Result<(), dbus::Error>;
+    fn get_dnd(&self) -> Result<bool, dbus::Error>;
+    fn manually_close_notification(&self, id: u32, timeout: bool) -> Result<(), dbus::Error>;
+    fn close_all_notifications(&self) -> Result<(), dbus::Error>;
+    fn hide_latest_notification(&self, close: bool) -> Result<(), dbus::Error>;
+    fn get_capabilities(&self) -> Result<Vec<String>, dbus::Error>;
+    fn notify(&self, app_name: &str, replaces_id: u32, app_icon: &str, summary: &str, body: &str, actions: Vec<&str>, hints: arg::PropMap, expire_timeout: i32) -> Result<u32, dbus::Error>;
+    fn close_notification(&self, id: u32) -> Result<(), dbus::Error>;
+    fn get_server_information(&self) -> Result<(String, String, String, String), dbus::Error>;
+    fn dnd(&self) -> Result<bool, dbus::Error>;
+    fn set_dnd_(&self, value: bool) -> Result<(), dbus::Error>;
+}
+
+#[derive(Debug)]
+pub struct OrgFreedesktopNotificationsOnDndToggle {
+    pub dnd: bool,
+}
+
+impl arg::AppendAll for OrgFreedesktopNotificationsOnDndToggle {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.dnd, i);
+    }
+}
+
+impl arg::ReadAll for OrgFreedesktopNotificationsOnDndToggle {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(OrgFreedesktopNotificationsOnDndToggle {
+            dnd: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for OrgFreedesktopNotificationsOnDndToggle {
+    const NAME: &'static str = "OnDndToggle";
+    const INTERFACE: &'static str = "org.freedesktop.Notifications";
+}
+
+#[derive(Debug)]
+pub struct OrgFreedesktopNotificationsNotificationClosed {
+    pub id: u32,
+    pub reason: u32,
+}
+
+impl arg::AppendAll for OrgFreedesktopNotificationsNotificationClosed {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.id, i);
+        arg::RefArg::append(&self.reason, i);
+    }
+}
+
+impl arg::ReadAll for OrgFreedesktopNotificationsNotificationClosed {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(OrgFreedesktopNotificationsNotificationClosed {
+            id: i.read()?,
+            reason: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for OrgFreedesktopNotificationsNotificationClosed {
+    const NAME: &'static str = "NotificationClosed";
+    const INTERFACE: &'static str = "org.freedesktop.Notifications";
+}
+
+#[derive(Debug)]
+pub struct OrgFreedesktopNotificationsActionInvoked {
+    pub id: u32,
+    pub action_key: String,
+}
+
+impl arg::AppendAll for OrgFreedesktopNotificationsActionInvoked {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.id, i);
+        arg::RefArg::append(&self.action_key, i);
+    }
+}
+
+impl arg::ReadAll for OrgFreedesktopNotificationsActionInvoked {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(OrgFreedesktopNotificationsActionInvoked {
+            id: i.read()?,
+            action_key: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for OrgFreedesktopNotificationsActionInvoked {
+    const NAME: &'static str = "ActionInvoked";
+    const INTERFACE: &'static str = "org.freedesktop.Notifications";
+}
+
+#[derive(Debug)]
+pub struct OrgFreedesktopNotificationsNotificationReplied {
+    pub id: u32,
+    pub text: String,
+}
+
+impl arg::AppendAll for OrgFreedesktopNotificationsNotificationReplied {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.id, i);
+        arg::RefArg::append(&self.text, i);
+    }
+}
+
+impl arg::ReadAll for OrgFreedesktopNotificationsNotificationReplied {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(OrgFreedesktopNotificationsNotificationReplied {
+            id: i.read()?,
+            text: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for OrgFreedesktopNotificationsNotificationReplied {
+    const NAME: &'static str = "NotificationReplied";
+    const INTERFACE: &'static str = "org.freedesktop.Notifications";
+}
+
+impl<'a, T: blocking::BlockingSender, C: ::std::ops::Deref<Target=T>> OrgFreedesktopNotifications for blocking::Proxy<'a, C> {
+
+    fn set_noti_window_visibility(&self, value: bool) -> Result<(), dbus::Error> {
+        self.method_call("org.freedesktop.Notifications", "SetNotiWindowVisibility", (value, ))
+    }
+
+    fn toggle_dnd(&self) -> Result<bool, dbus::Error> {
+        self.method_call("org.freedesktop.Notifications", "ToggleDnd", ())
+            .and_then(|r: (bool, )| Ok(r.0, ))
+    }
+
+    fn set_dnd(&self, state: bool) -> Result<(), dbus::Error> {
+        self.method_call("org.freedesktop.Notifications", "SetDnd", (state, ))
+    }
+
+    fn get_dnd(&self) -> Result<bool, dbus::Error> {
+        self.method_call("org.freedesktop.Notifications", "GetDnd", ())
+            .and_then(|r: (bool, )| Ok(r.0, ))
+    }
+
+    fn manually_close_notification(&self, id: u32, timeout: bool) -> Result<(), dbus::Error> {
+        self.method_call("org.freedesktop.Notifications", "ManuallyCloseNotification", (id, timeout, ))
+    }
+
+    fn close_all_notifications(&self) -> Result<(), dbus::Error> {
+        self.method_call("org.freedesktop.Notifications", "CloseAllNotifications", ())
+    }
+
+    fn hide_latest_notification(&self, close: bool) -> Result<(), dbus::Error> {
+        self.method_call("org.freedesktop.Notifications", "HideLatestNotification", (close, ))
+    }
+
+    fn get_capabilities(&self) -> Result<Vec<String>, dbus::Error> {
+        self.method_call("org.freedesktop.Notifications", "GetCapabilities", ())
+            .and_then(|r: (Vec<String>, )| Ok(r.0, ))
+    }
+
+    fn notify(&self, app_name: &str, replaces_id: u32, app_icon: &str, summary: &str, body: &str, actions: Vec<&str>, hints: arg::PropMap, expire_timeout: i32) -> Result<u32, dbus::Error> {
+        self.method_call("org.freedesktop.Notifications", "Notify", (app_name, replaces_id, app_icon, summary, body, actions, hints, expire_timeout, ))
+            .and_then(|r: (u32, )| Ok(r.0, ))
+    }
+
+    fn close_notification(&self, id: u32) -> Result<(), dbus::Error> {
+        self.method_call("org.freedesktop.Notifications", "CloseNotification", (id, ))
+    }
+
+    fn get_server_information(&self) -> Result<(String, String, String, String), dbus::Error> {
+        self.method_call("org.freedesktop.Notifications", "GetServerInformation", ())
+    }
+
+    fn dnd(&self) -> Result<bool, dbus::Error> {
+        <Self as blocking::stdintf::org_freedesktop_dbus::Properties>::get(self, "org.freedesktop.Notifications", "Dnd")
+    }
+
+    fn set_dnd_(&self, value: bool) -> Result<(), dbus::Error> {
+        <Self as blocking::stdintf::org_freedesktop_dbus::Properties>::set(self, "org.freedesktop.Notifications", "Dnd", value)
+    }
+}
@@ -132,21 +132,14 @@ pub(super) unsafe fn create_overlay_session(
    }
 }

-pub(super) fn hmd_pose_from_views(views: &[xr::View]) -> (Affine3A, f32) {
-    let ipd;
-    let pos = {
-        let pos0: Vec3 = unsafe { std::mem::transmute(views[0].pose.position) };
-        let pos1: Vec3 = unsafe { std::mem::transmute(views[1].pose.position) };
-        ipd = (pos0.distance(pos1) * 1000.0).round() * 0.1;
-        (pos0 + pos1) * 0.5
-    };
-    let rot = {
-        let rot0: Quat = unsafe { std::mem::transmute(views[0].pose.orientation) };
-        let rot1: Quat = unsafe { std::mem::transmute(views[1].pose.orientation) };
-        rot0.lerp(rot1, 0.5)
-    };
+type Vec3M = mint::Vector3<f32>;
+type QuatM = mint::Quaternion<f32>;

-    (Affine3A::from_rotation_translation(rot, pos), ipd)
+pub(super) fn ipd_from_views(views: &[xr::View]) -> f32 {
+    let p0: Vec3 = Vec3M::from(views[0].pose.position).into();
+    let p1: Vec3 = Vec3M::from(views[1].pose.position).into();
+
+    (p0.distance(p1) * 1000.0).round() * 0.1
 }

 pub(super) fn transform_to_norm_quat(transform: &Affine3A) -> Quat {
@@ -181,3 +174,9 @@ pub(super) fn transform_to_posef(transform: &Affine3A) -> xr::Posef {
    let rotation = transform_to_norm_quat(transform);
    translation_rotation_to_posef(translation, rotation)
 }
+
+pub(super) fn posef_to_transform(pose: &xr::Posef) -> Affine3A {
+    let rotation = QuatM::from(pose.orientation).into();
+    let translation = Vec3M::from(pose.position).into();
+    Affine3A::from_rotation_translation(rotation, translation)
+}
@@ -15,7 +15,7 @@ use crate::{
    state::{AppSession, AppState},
 };

-use super::XrState;
+use super::{helpers::posef_to_transform, XrState};

 type XrSession = xr::Session<xr::Vulkan>;

@@ -156,6 +156,7 @@ pub(super) struct OpenXrHandSource {
    action_show_hide: CustomClickAction,
    action_space_drag: CustomClickAction,
    action_space_rotate: CustomClickAction,
+    action_space_reset: CustomClickAction,
    action_modifier_right: CustomClickAction,
    action_modifier_middle: CustomClickAction,
    action_move_mouse: CustomClickAction,
@@ -204,6 +205,22 @@ impl OpenXrInputSource {
    pub fn update(&mut self, xr: &XrState, state: &mut AppState) -> anyhow::Result<()> {
        xr.session.sync_actions(&[(&self.action_set).into()])?;

+        let loc = xr.view.locate(&xr.stage, xr.predicted_display_time)?;
+        let hmd = posef_to_transform(&loc.pose);
+        if loc
+            .location_flags
+            .contains(xr::SpaceLocationFlags::ORIENTATION_VALID)
+        {
+            state.input_state.hmd.matrix3 = hmd.matrix3;
+        }
+
+        if loc
+            .location_flags
+            .contains(xr::SpaceLocationFlags::POSITION_VALID)
+        {
+            state.input_state.hmd.translation = hmd.translation;
+        }
+
        for i in 0..2 {
            self.hands[i].update(&mut state.input_state.pointers[i], xr, &state.session)?;
        }
@@ -299,13 +316,21 @@ impl OpenXrHand {
            .location_flags
            .contains(xr::SpaceLocationFlags::ORIENTATION_VALID)
        {
-            let (quat, pos) = unsafe {
+            let (cur_quat, cur_pos) = (Quat::from_affine3(&pointer.pose), pointer.pose.translation);
+
+            let (new_quat, new_pos) = unsafe {
                (
                    transmute::<Quaternionf, Quat>(location.pose.orientation),
                    transmute::<Vector3f, Vec3>(location.pose.position),
                )
            };
-            pointer.pose = Affine3A::from_rotation_translation(quat, pos);
+            let lerp_factor =
+                (1.0 / (xr.fps / 100.0) * session.config.pointer_lerp_factor).clamp(0.1, 1.0);
+            pointer.raw_pose = Affine3A::from_rotation_translation(new_quat, new_pos);
+            pointer.pose = Affine3A::from_rotation_translation(
+                cur_quat.lerp(new_quat, lerp_factor),
+                cur_pos.lerp(new_pos.into(), lerp_factor).into(),
+            );
        }

        pointer.now.click = self
@@ -361,6 +386,11 @@ impl OpenXrHand {
                .action_space_rotate
                .state(pointer.before.space_rotate, xr, session)?;

+        pointer.now.space_reset =
+            self.source
+                .action_space_reset
+                .state(pointer.before.space_reset, xr, session)?;
+
        Ok(())
    }
 }
@@ -394,6 +424,7 @@ impl OpenXrHandSource {
            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_space_reset: CustomClickAction::new(action_set, "space_reset", side)?,
            action_modifier_right: CustomClickAction::new(
                action_set,
                "click_modifier_right",
@@ -563,6 +594,14 @@ fn suggest_bindings(instance: &xr::Instance, hands: &[&OpenXrHandSource; 2]) ->
            instance
        );

+        add_custom!(
+            profile.space_reset,
+            &hands[0].action_space_reset,
+            &hands[1].action_space_reset,
+            bindings,
+            instance
+        );
+
        add_custom!(
            profile.click_modifier_right,
            &hands[0].action_modifier_right,
@@ -618,6 +657,7 @@ struct OpenXrActionConfProfile {
    show_hide: Option<OpenXrActionConfAction>,
    space_drag: Option<OpenXrActionConfAction>,
    space_rotate: Option<OpenXrActionConfAction>,
+    space_reset: Option<OpenXrActionConfAction>,
    click_modifier_right: Option<OpenXrActionConfAction>,
    click_modifier_middle: Option<OpenXrActionConfAction>,
    move_mouse: Option<OpenXrActionConfAction>,
@@ -48,7 +48,9 @@ struct XrState {
    system: xr::SystemId,
    session: xr::Session<xr::Vulkan>,
    predicted_display_time: xr::Time,
+    fps: f32,
    stage: Arc<xr::Space>,
+    view: Arc<xr::Space>,
    stage_offset: Affine3A,
 }

@@ -123,12 +125,16 @@ pub fn openxr_run(running: Arc<AtomicBool>, show_by_default: bool) -> Result<(),
    let stage =
        session.create_reference_space(xr::ReferenceSpaceType::STAGE, xr::Posef::IDENTITY)?;

+    let view = session.create_reference_space(xr::ReferenceSpaceType::VIEW, xr::Posef::IDENTITY)?;
+
    let mut xr_state = XrState {
        instance: xr_instance,
        system,
        session,
        predicted_display_time: xr::Time::from_nanos(0),
+        fps: 30.0,
        stage: Arc::new(stage),
+        view: Arc::new(view),
        stage_offset: Affine3A::IDENTITY,
    };

@@ -149,6 +155,8 @@ pub fn openxr_run(running: Arc<AtomicBool>, show_by_default: bool) -> Result<(),
    let mut next_device_update = Instant::now();
    let mut due_tasks = VecDeque::with_capacity(4);

+    let mut fps_counter: VecDeque<Instant> = VecDeque::new();
+
    let mut main_session_visible = false;

    'main_loop: loop {
@@ -227,6 +235,24 @@ pub fn openxr_run(running: Arc<AtomicBool>, show_by_default: bool) -> Result<(),
        frame_stream.begin()?;

        xr_state.predicted_display_time = xr_frame_state.predicted_display_time;
+        xr_state.fps = {
+            fps_counter.push_back(Instant::now());
+
+            while let Some(time) = fps_counter.front() {
+                if time.elapsed().as_secs_f32() > 1. {
+                    fps_counter.pop_front();
+                } else {
+                    break;
+                }
+            }
+
+            let total_elapsed = fps_counter
+                .front()
+                .map(|time| time.elapsed().as_secs_f32())
+                .unwrap_or(0f32);
+
+            fps_counter.len() as f32 / total_elapsed
+        };

        if !xr_frame_state.should_render {
            frame_stream.end(
@@ -274,8 +300,7 @@ pub fn openxr_run(running: Arc<AtomicBool>, show_by_default: bool) -> Result<(),
            &xr_state.stage,
        )?;

-        let (hmd, ipd) = helpers::hmd_pose_from_views(&views);
-        app_state.input_state.hmd = hmd;
+        let ipd = helpers::ipd_from_views(&views);
        if (app_state.input_state.ipd - ipd).abs() > 0.01 {
            log::info!("IPD changed: {} -> {}", app_state.input_state.ipd, ipd);
            app_state.input_state.ipd = ipd;
@@ -15,6 +15,9 @@
 // -- space_rotate --
 // rotate your stage (playspace rotate, WIP)
 //
+// -- space_reset --
+// reset your stage (reset the offset from playspace drag)
+//
 // -- click_modifier_right --
 // while this is held, your pointer will turn ORANGE and your mouse clicks will be RIGHT clicks
 //
@@ -132,6 +135,10 @@
      left: "/user/hand/left/input/trackpad/force",
      // right trackpad is alt_click
    },
+    space_reset: {
+      double_click: true,
+      left: "/user/hand/left/input/trackpad/force",
+    },
    click_modifier_right: {
      left: "/user/hand/left/input/b/touch",
      right: "/user/hand/right/input/b/touch"
@@ -55,6 +55,16 @@ impl PlayspaceMover {
        state: &AppState,
        monado: &mut Monado,
    ) {
+        for pointer in state.input_state.pointers.iter() {
+            if pointer.now.space_reset {
+                if !pointer.before.space_reset {
+                    log::info!("Space reset");
+                    self.reset_offset(monado);
+                }
+                return;
+            }
+        }
+
        if let Some(mut data) = self.rotate.take() {
            let pointer = &state.input_state.pointers[data.hand];
            if !pointer.now.space_rotate {
@@ -64,32 +74,25 @@ impl PlayspaceMover {
            }

            let new_hand =
-                Quat::from_affine3(&(data.pose * state.input_state.pointers[data.hand].pose));
+                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 = if state.session.config.space_rotate_unlocked {
+                Affine3A::from_quat(dq)
+            } else {
+                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_translation(dq, Vec3::ZERO);
-            let mut space_transform = Affine3A::from_rotation_y(rel_y);
+                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;

@@ -98,7 +101,7 @@ impl PlayspaceMover {
        } 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);
+                    let hand_pose = Quat::from_affine3(&(self.last_transform * pointer.raw_pose));
                    self.rotate = Some(MoverData {
                        pose: self.last_transform,
                        hand: i,
@@ -121,7 +124,7 @@ impl PlayspaceMover {

            let new_hand = data
                .pose
-                .transform_point3a(state.input_state.pointers[data.hand].pose.translation);
+                .transform_point3a(state.input_state.pointers[data.hand].raw_pose.translation);
            let relative_pos =
                (new_hand - data.hand_pose) * state.session.config.space_drag_multiplier;

@@ -149,7 +152,7 @@ impl PlayspaceMover {
                if pointer.now.space_drag {
                    let hand_pos = self
                        .last_transform
-                        .transform_point3a(pointer.pose.translation);
+                        .transform_point3a(pointer.raw_pose.translation);
                    self.drag = Some(MoverData {
                        pose: self.last_transform,
                        hand: i,
@@ -186,8 +189,8 @@ impl PlayspaceMover {
            self.rotate = None;
        }

-        let y1 = input.pointers[0].pose.translation.y;
-        let y2 = input.pointers[1].pose.translation.y;
+        let y1 = input.pointers[0].raw_pose.translation.y;
+        let y2 = input.pointers[1].raw_pose.translation.y;
        let delta = y1.min(y2) - 0.03;
        self.last_transform.translation.y += delta;
        self.apply_offset(self.last_transform, monado);
@@ -121,6 +121,10 @@ pub fn def_point7() -> f32 {
    0.7
 }

+pub fn def_point3() -> f32 {
+    0.3
+}
+
 fn def_osc_port() -> u16 {
    9000
 }
@@ -260,6 +264,15 @@ pub struct GeneralConfig {

    #[serde(default = "def_max_height")]
    pub screen_max_height: u16,
+
+    #[serde(default = "def_false")]
+    pub screen_render_down: bool,
+
+    #[serde(default = "def_point3")]
+    pub pointer_lerp_factor: f32,
+
+    #[serde(default = "def_false")]
+    pub space_rotate_unlocked: bool,
 }

 impl GeneralConfig {
@@ -44,8 +44,8 @@ use vulkano::{
        allocator::StandardDescriptorSetAllocator, DescriptorSet, WriteDescriptorSet,
    },
    device::{
-        physical::PhysicalDevice, Device, DeviceCreateInfo, DeviceExtensions, DeviceFeatures,
-        Queue, QueueCreateInfo, QueueFlags,
+        physical::PhysicalDevice, Device, DeviceCreateInfo, DeviceExtensions, Features, Queue,
+        QueueCreateInfo, QueueFlags,
    },
    format::Format,
    image::{
@@ -195,7 +195,7 @@ impl WlxGraphics {
        let target_version = vulkano::Version::V1_3;
        let library = get_vulkan_library();

-        let vk_app_info_raw = vk::ApplicationInfo::default()
+        let vk_app_info_raw = vk::ApplicationInfo::builder()
            .application_version(0)
            .engine_version(0)
            .api_version(vk_target_version);
@@ -205,7 +205,7 @@ impl WlxGraphics {
                .create_vulkan_instance(
                    system,
                    get_instance_proc_addr,
-                    &vk::InstanceCreateInfo::default()
+                    &vk::InstanceCreateInfo::builder()
                        .application_info(&vk_app_info_raw)
                        .enabled_extension_names(&instance_extensions_raw)
                        as *const _ as *const _,
@@ -286,23 +286,25 @@ impl WlxGraphics {
            })
            .collect::<Vec<_>>();

-        let features = DeviceFeatures {
+        let features = Features {
            dynamic_rendering: true,
            ..Default::default()
        };

        let queue_priorities = [1.0];

-        let queue_create_infos = [vk::DeviceQueueCreateInfo::default()
+        let queue_create_infos = [vk::DeviceQueueCreateInfo::builder()
            .queue_family_index(queue_family_index)
-            .queue_priorities(&queue_priorities)];
+            .queue_priorities(&queue_priorities)
+            .build()];

-        let mut device_create_info = vk::DeviceCreateInfo::default()
+        let mut device_create_info = vk::DeviceCreateInfo::builder()
            .queue_create_infos(&queue_create_infos)
-            .enabled_extension_names(&device_extensions_raw);
+            .enabled_extension_names(&device_extensions_raw)
+            .build();

        let mut dynamic_rendering =
-            PhysicalDeviceDynamicRenderingFeatures::default().dynamic_rendering(true);
+            PhysicalDeviceDynamicRenderingFeatures::builder().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;
@@ -487,9 +489,9 @@ impl WlxGraphics {
            physical_device,
            DeviceCreateInfo {
                enabled_extensions: my_extensions,
-                enabled_features: DeviceFeatures {
+                enabled_features: Features {
                    dynamic_rendering: true,
-                    ..DeviceFeatures::empty()
+                    ..Features::empty()
                },
                queue_create_infos: vec![QueueCreateInfo {
                    queue_family_index,
@@ -625,9 +627,9 @@ impl WlxGraphics {
            physical_device,
            DeviceCreateInfo {
                enabled_extensions: my_extensions,
-                enabled_features: DeviceFeatures {
+                enabled_features: Features {
                    dynamic_rendering: true,
-                    ..DeviceFeatures::empty()
+                    ..Features::empty()
                },
                queue_create_infos: vec![QueueCreateInfo {
                    queue_family_index,
@@ -1034,7 +1036,10 @@ impl WlxGraphics {
            (fns.v1_0.queue_submit)(
                self.queue.handle(),
                1,
-                [SubmitInfo::default().command_buffers(&[command_buffer.handle()])].as_ptr(),
+                [SubmitInfo::builder()
+                    .command_buffers(&[command_buffer.handle()])
+                    .build()]
+                .as_ptr(),
                fence.handle(),
            )
        }
@@ -1165,7 +1170,6 @@ pub struct WlxPipelineDynamic {}
 pub struct WlxPipelineLegacy {
    pub render_pass: Arc<RenderPass>,
    pub framebuffer: Arc<Framebuffer>,
-    pub view: Arc<ImageView>,
 }

 pub struct WlxPipeline<D> {
@@ -1187,7 +1191,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)?;
+        let vertex_input_state = Vert2Uv::per_vertex().definition(&vep.info().input_interface)?;

        let stages = smallvec![
            vulkano::pipeline::PipelineShaderStageCreateInfo::new(vep),
@@ -1344,7 +1348,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)?;
+        let vertex_input_state = Vert2Uv::per_vertex().definition(&vep.info().input_interface)?;

        let stages = smallvec![
            vulkano::pipeline::PipelineShaderStageCreateInfo::new(vep),
@@ -1399,7 +1403,6 @@ impl WlxPipeline<WlxPipelineLegacy> {
            data: WlxPipelineLegacy {
                render_pass,
                framebuffer,
-                view: render_target,
            },
        })
    }
@@ -52,7 +52,15 @@ impl<D, S> CanvasBuilder<D, S> {
    }

    // Creates a label with fg_color, font_size inherited from the canvas
-    pub fn label(&mut self, x: f32, y: f32, w: f32, h: f32, radius: f32, text: Arc<str>) -> &mut Control<D, S> {
+    pub fn label(
+        &mut self,
+        x: f32,
+        y: f32,
+        w: f32,
+        h: f32,
+        radius: f32,
+        text: Arc<str>,
+    ) -> &mut Control<D, S> {
        let idx = self.canvas.controls.len();
        self.canvas.controls.push(Control {
            rect: Rect { x, y, w, h },
@@ -116,7 +124,15 @@ impl<D, S> CanvasBuilder<D, S> {
    }

    // Creates a button with fg_color, bg_color, font_size inherited from the canvas
-    pub fn button(&mut self, x: f32, y: f32, w: f32, h: f32, radius: f32, text: Arc<str>) -> &mut Control<D, S> {
+    pub fn button(
+        &mut self,
+        x: f32,
+        y: f32,
+        w: f32,
+        h: f32,
+        radius: f32,
+        text: Arc<str>,
+    ) -> &mut Control<D, S> {
        let idx = self.canvas.controls.len();

        self.canvas.interactive_set_idx(x, y, w, h, idx);
@@ -120,21 +120,24 @@ impl<D, S> Control<D, S> {
                self.rect.h,
            )?;

-            let clamped_radius = self.corner_radius.min(self.rect.w / 2.0).min(self.rect.h / 2.0);
+            let clamped_radius = self
+                .corner_radius
+                .min(self.rect.w / 2.0)
+                .min(self.rect.h / 2.0);

-            let skew_radius = vec![
-                clamped_radius / self.rect.w,
-                clamped_radius / self.rect.h];
+            let skew_radius = [clamped_radius / self.rect.w, clamped_radius / self.rect.h];

-            let set0 = canvas
-                .pipeline_bg_color
-                .uniform_buffer(0, vec![
+            let set0 = canvas.pipeline_bg_color.uniform_buffer(
+                0,
+                vec![
                    self.bg_color.x,
                    self.bg_color.y,
                    self.bg_color.z,
                    self.bg_color.w,
                    skew_radius[0],
-                    skew_radius[1]])?;
+                    skew_radius[1],
+                ],
+            )?;

            canvas.pipeline_bg_color.create_pass(
                [canvas.width as _, canvas.height as _],
@@ -163,21 +166,24 @@ impl<D, S> Control<D, S> {
            self.rect.h,
        )?;

-        let clamped_radius = self.corner_radius.min(self.rect.w / 2.0).min(self.rect.h / 2.0);
+        let clamped_radius = self
+            .corner_radius
+            .min(self.rect.w / 2.0)
+            .min(self.rect.h / 2.0);

-        let skew_radius = vec![
-            clamped_radius / self.rect.w,
-            clamped_radius / self.rect.h];
+        let skew_radius = [clamped_radius / self.rect.w, clamped_radius / self.rect.h];

-        let set0 = canvas
-            .pipeline_bg_color
-            .uniform_buffer(0, vec![
+        let set0 = canvas.pipeline_bg_color.uniform_buffer(
+            0,
+            vec![
                color.x,
                color.y,
                color.z,
                color.w,
                skew_radius[0],
-                skew_radius[1]])?;
+                skew_radius[1],
+            ],
+        )?;

        let pass = canvas.pipeline_bg_color.create_pass(
            [canvas.width as _, canvas.height as _],
@@ -220,6 +220,10 @@ impl<D, S> Canvas<D, S> {
        cmd_buffer.end_render_pass()?;
        cmd_buffer.build_and_execute_now()
    }
+
+    pub fn data_mut(&mut self) -> &mut D {
+        &mut self.canvas.data
+    }
 }

 impl<D, S> InteractionHandler for Canvas<D, S> {
@@ -17,6 +17,7 @@ use crate::{
        task::{ColorChannel, SystemTask, TaskType},
    },
    config::{save_layout, save_settings, AStrSetExt},
+    hid::VirtualKey,
    overlays::{
        toast::{Toast, ToastTopic},
        watch::WATCH_NAME,
@@ -26,6 +27,12 @@ use crate::{

 use super::{ExecArgs, ModularControl, ModularData};

+#[derive(Deserialize, Clone)]
+pub enum PressRelease {
+    Release,
+    Press,
+}
+
 #[derive(Deserialize, Clone, Copy)]
 pub enum ViewAngleKind {
    /// The cosine of the angle at which the watch becomes fully transparent
@@ -47,6 +54,7 @@ pub enum HighlightTest {
    AutoRealign,
    NotificationSounds,
    Notifications,
+    RorateLock,
 }

 #[derive(Deserialize, Clone)]
@@ -55,6 +63,7 @@ pub enum SystemAction {
    ToggleAutoRealign,
    ToggleNotificationSounds,
    ToggleNotifications,
+    ToggleRotateLock,
    PlayspaceResetOffset,
    PlayspaceFixFloor,
    RecalculateExtent,
@@ -114,6 +123,10 @@ pub enum ButtonAction {
        command: ExecArgs,
        toast: Option<Arc<str>>,
    },
+    VirtualKey {
+        keycode: VirtualKey,
+        action: PressRelease,
+    },
    Watch {
        action: WatchAction,
    },
@@ -298,6 +311,7 @@ fn modular_button_highlight(
            HighlightTest::AutoRealign => app.session.config.realign_on_showhide,
            HighlightTest::NotificationSounds => app.session.config.notifications_sound_enabled,
            HighlightTest::Notifications => app.session.config.notifications_enabled,
+            HighlightTest::RorateLock => !app.session.config.space_rotate_unlocked,
        };

        if lit {
@@ -313,6 +327,9 @@ fn handle_action(action: &ButtonAction, press: &mut PressData, app: &mut AppStat
        ButtonAction::Watch { action } => run_watch(action, app),
        ButtonAction::Overlay { target, action } => run_overlay(target, action, app),
        ButtonAction::Window { target, action } => run_window(target, action, app),
+        ButtonAction::VirtualKey { keycode, action } => app
+            .hid_provider
+            .send_key(*keycode, matches!(*action, PressRelease::Press)),
        ButtonAction::Toast {
            message,
            body,
@@ -369,6 +386,19 @@ fn run_system(action: &SystemAction, app: &mut AppState) {
            )
            .submit(app);
        }
+        SystemAction::ToggleRotateLock => {
+            app.session.config.space_rotate_unlocked = !app.session.config.space_rotate_unlocked;
+            Toast::new(
+                ToastTopic::System,
+                format!(
+                    "Space rotate axis lock now {}.",
+                    ENABLED_DISABLED[!app.session.config.space_rotate_unlocked as usize]
+                )
+                .into(),
+                "".into(),
+            )
+            .submit(app);
+        }
        SystemAction::PlayspaceResetOffset => {
            app.tasks
                .enqueue(TaskType::System(SystemTask::ResetPlayspace));
@@ -54,12 +54,12 @@ pub struct OverlayListTemplate {
 pub enum ModularElement {
    Panel {
        rect: [f32; 4],
-        corner_radius: f32,
+        corner_radius: Option<f32>,
        bg_color: Arc<str>,
    },
    Label {
        rect: [f32; 4],
-        corner_radius: f32,
+        corner_radius: Option<f32>,
        font_size: isize,
        fg_color: Arc<str>,
        #[serde(flatten)]
@@ -67,7 +67,7 @@ pub enum ModularElement {
    },
    CenteredLabel {
        rect: [f32; 4],
-        corner_radius: f32,
+        corner_radius: Option<f32>,
        font_size: isize,
        fg_color: Arc<str>,
        #[serde(flatten)]
@@ -80,7 +80,7 @@ pub enum ModularElement {
    },
    Button {
        rect: [f32; 4],
-        corner_radius: f32,
+        corner_radius: Option<f32>,
        font_size: isize,
        fg_color: Arc<str>,
        bg_color: Arc<str>,
@@ -91,7 +91,7 @@ pub enum ModularElement {
    /// Convenience type to save you from having to create a bunch of labels
    BatteryList {
        rect: [f32; 4],
-        corner_radius: f32,
+        corner_radius: Option<f32>,
        font_size: isize,
        fg_color: Arc<str>,
        fg_color_low: Arc<str>,
@@ -102,7 +102,7 @@ pub enum ModularElement {
    },
    OverlayList {
        rect: [f32; 4],
-        corner_radius: f32,
+        corner_radius: Option<f32>,
        font_size: isize,
        fg_color: Arc<str>,
        bg_color: Arc<str>,
@@ -150,7 +150,7 @@ pub fn modular_canvas(
                bg_color,
            } => {
                canvas.bg_color = color_parse(bg_color).unwrap_or(*FALLBACK_COLOR);
-                canvas.panel(*x, *y, *w, *h, *corner_radius);
+                canvas.panel(*x, *y, *w, *h, corner_radius.unwrap_or_default());
            }
            ModularElement::Label {
                rect: [x, y, w, h],
@@ -161,7 +161,14 @@ pub fn modular_canvas(
            } => {
                canvas.font_size = *font_size;
                canvas.fg_color = color_parse(fg_color).unwrap_or(*FALLBACK_COLOR);
-                let label = canvas.label(*x, *y, *w, *h, *corner_radius, empty_str.clone());
+                let label = canvas.label(
+                    *x,
+                    *y,
+                    *w,
+                    *h,
+                    corner_radius.unwrap_or_default(),
+                    empty_str.clone(),
+                );
                modular_label_init(label, data);
            }
            ModularElement::CenteredLabel {
@@ -173,7 +180,14 @@ pub fn modular_canvas(
            } => {
                canvas.font_size = *font_size;
                canvas.fg_color = color_parse(fg_color).unwrap_or(*FALLBACK_COLOR);
-                let label = canvas.label_centered(*x, *y, *w, *h, *corner_radius, empty_str.clone());
+                let label = canvas.label_centered(
+                    *x,
+                    *y,
+                    *w,
+                    *h,
+                    corner_radius.unwrap_or_default(),
+                    empty_str.clone(),
+                );
                modular_label_init(label, data);
            }
            ModularElement::Sprite {
@@ -207,7 +221,14 @@ pub fn modular_canvas(
                canvas.bg_color = color_parse(bg_color).unwrap_or(*FALLBACK_COLOR);
                canvas.fg_color = color_parse(fg_color).unwrap_or(*FALLBACK_COLOR);
                canvas.font_size = *font_size;
-                let button = canvas.button(*x, *y, *w, *h, *corner_radius, text.clone());
+                let button = canvas.button(
+                    *x,
+                    *y,
+                    *w,
+                    *h,
+                    corner_radius.unwrap_or_default(),
+                    text.clone(),
+                );
                modular_button_init(button, data);
            }
            ModularElement::BatteryList {
@@ -240,7 +261,7 @@ pub fn modular_canvas(
                        button_y + 2.,
                        button_w - 4.,
                        button_h - 4.,
-                        *corner_radius,
+                        corner_radius.unwrap_or_default(),
                        empty_str.clone(),
                    );
                    modular_label_init(
@@ -290,7 +311,7 @@ pub fn modular_canvas(
                        button_y + 2.,
                        button_w - 4.,
                        button_h - 4.,
-                        *corner_radius,
+                        corner_radius.unwrap_or_default(),
                        screen.name.clone(),
                    );

@@ -7,6 +7,7 @@ use input_linux::{
 };
 use libc::{input_event, timeval};
 use once_cell::sync::Lazy;
+use serde::Deserialize;
 use std::mem::transmute;
 use std::{fs::File, sync::atomic::AtomicBool};
 use strum::{EnumIter, EnumString, IntoEnumIterator};
@@ -242,7 +243,7 @@ impl HidProvider for UInputProvider {
        self.desktop_origin = origin;
    }
    fn mouse_move(&mut self, pos: Vec2) {
-        if self.current_action.pos.is_none() {
+        if self.current_action.pos.is_none() && self.current_action.scroll.is_none() {
            self.current_action.pos = Some(pos);
        }
        self.current_action.last_requested_pos = Some(pos);
@@ -256,6 +257,9 @@ impl HidProvider for UInputProvider {
    fn wheel(&mut self, delta: i32) {
        if self.current_action.scroll.is_none() {
            self.current_action.scroll = Some(delta);
+            // Pass mouse motion events only if not scrolling
+            // (allows scrolling on all Chromium-based applications)
+            self.current_action.pos = None;
        }
    }
    fn commit(&mut self) {
@@ -313,7 +317,7 @@ pub const META: KeyModifier = 0x80;

 #[allow(non_camel_case_types)]
 #[repr(u16)]
-#[derive(Debug, PartialEq, Clone, Copy, IntegerId, EnumString, EnumIter)]
+#[derive(Debug, Deserialize, PartialEq, Clone, Copy, IntegerId, EnumString, EnumIter)]
 pub enum VirtualKey {
    Escape = 9,
    N1, // number row
@@ -533,7 +537,6 @@ pub fn get_key_type(key: VirtualKey) -> KeyType {
 }

 pub struct XkbKeymap {
-    pub context: xkb::Context,
    pub keymap: xkb::Keymap,
 }

@@ -120,7 +120,7 @@ impl Dispatch<WlKeyboard, ()> for WlKeymapHandler {

                    match maybe_keymap {
                        Ok(Some(keymap)) => {
-                            state.keymap = Some(XkbKeymap { context, keymap });
+                            state.keymap = Some(XkbKeymap { keymap });
                        }
                        Ok(None) => {
                            log::error!("Could not load keymap: no keymap");
@@ -31,5 +31,5 @@ pub fn get_keymap_x11() -> anyhow::Result<XkbKeymap> {
    }
    let keymap = keymap_new_from_device(&context, &conn, device_id, xkb::KEYMAP_COMPILE_NO_FLAGS);

-    Ok(XkbKeymap { context, keymap })
+    Ok(XkbKeymap { keymap })
 }
@@ -79,7 +79,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
    log::info!(
        "Welcome to {} version {}!",
        env!("CARGO_PKG_NAME"),
-        env!("CARGO_PKG_VERSION")
+        env!("WLX_BUILD"),
    );
    log::info!("It is {}.", chrono::Local::now().format("%c"));

@@ -6,12 +6,12 @@ use std::{

 use crate::{
    backend::{
-        input::PointerMode,
-        overlay::{OverlayData, OverlayState},
+        input::{InteractionHandler, PointerMode},
+        overlay::{OverlayBackend, OverlayData, OverlayRenderer, OverlayState},
    },
    config::{self, ConfigType},
    gui::{
-        canvas::{builder::CanvasBuilder, control::Control},
+        canvas::{builder::CanvasBuilder, control::Control, Canvas},
        color_parse, KeyCapType,
    },
    hid::{
@@ -180,7 +180,7 @@ where
            interaction_transform,
            ..Default::default()
        },
-        backend: Box::new(canvas),
+        backend: Box::new(KeyboardBackend { canvas }),
        ..Default::default()
    })
 }
@@ -329,7 +329,7 @@ enum KeyButtonData {
 static LAYOUT: Lazy<Layout> = Lazy::new(Layout::load_from_disk);

 static MACRO_REGEX: Lazy<Regex> =
-    Lazy::new(|| Regex::new(r"^([A-Za-z0-1_-]+)(?: +(UP|DOWN))?$").unwrap()); // want panic
+    Lazy::new(|| Regex::new(r"^([A-Za-z0-9_-]+)(?: +(UP|DOWN))?$").unwrap()); // want panic

 #[derive(Debug, Deserialize, Serialize)]
 pub struct Layout {
@@ -435,3 +435,68 @@ fn key_events_for_macro(macro_verbs: &Vec<String>) -> Vec<(VirtualKey, bool)> {
    }
    key_events
 }
+
+struct KeyboardBackend {
+    canvas: Canvas<KeyboardData, KeyButtonData>,
+}
+
+impl OverlayBackend for KeyboardBackend {
+    fn set_interaction(&mut self, interaction: Box<dyn crate::backend::input::InteractionHandler>) {
+        self.canvas.set_interaction(interaction)
+    }
+    fn set_renderer(&mut self, renderer: Box<dyn crate::backend::overlay::OverlayRenderer>) {
+        self.canvas.set_renderer(renderer)
+    }
+}
+
+impl InteractionHandler for KeyboardBackend {
+    fn on_pointer(
+        &mut self,
+        app: &mut AppState,
+        hit: &crate::backend::input::PointerHit,
+        pressed: bool,
+    ) {
+        self.canvas.on_pointer(app, hit, pressed)
+    }
+    fn on_scroll(
+        &mut self,
+        app: &mut AppState,
+        hit: &crate::backend::input::PointerHit,
+        delta: f32,
+    ) {
+        self.canvas.on_scroll(app, hit, delta)
+    }
+    fn on_left(&mut self, app: &mut AppState, pointer: usize) {
+        self.canvas.on_left(app, pointer)
+    }
+    fn on_hover(
+        &mut self,
+        app: &mut AppState,
+        hit: &crate::backend::input::PointerHit,
+    ) -> Option<crate::backend::input::Haptics> {
+        self.canvas.on_hover(app, hit)
+    }
+}
+
+impl OverlayRenderer for KeyboardBackend {
+    fn init(&mut self, app: &mut AppState) -> anyhow::Result<()> {
+        self.canvas.init(app)
+    }
+    fn render(&mut self, app: &mut AppState) -> anyhow::Result<()> {
+        self.canvas.render(app)
+    }
+    fn extent(&mut self) -> Option<[u32; 3]> {
+        self.canvas.extent()
+    }
+    fn view(&mut self) -> Option<std::sync::Arc<vulkano::image::view::ImageView>> {
+        self.canvas.view()
+    }
+    fn pause(&mut self, app: &mut AppState) -> anyhow::Result<()> {
+        self.canvas.data_mut().modifiers = 0;
+        app.hid_provider.set_modifiers(0);
+        self.canvas.pause(app)
+    }
+    fn resume(&mut self, app: &mut AppState) -> anyhow::Result<()> {
+        self.canvas.resume(app)
+    }
+}
@@ -4,7 +4,6 @@ use std::{
 };

 use futures::{Future, FutureExt};
-use glam::vec3a;
 use wlx_capture::pipewire::{pipewire_select_screen, PipewireCapture, PipewireSelectScreenResult};

 use crate::{
@@ -137,7 +136,6 @@ pub fn new_mirror(
        show_hide,
        want_visible: true,
        spawn_scale: 0.5 * session.config.desktop_view_scale,
-        spawn_point: vec3a(0., 0.5, 0.5),
        ..Default::default()
    };
    let backend = Box::new(SplitOverlayBackend {
@@ -15,9 +15,10 @@ use vulkano::{
 };
 use wlx_capture::{
    frame::{
-        DrmFormat, MouseMeta, WlxFrame, DRM_FORMAT_ABGR2101010, DRM_FORMAT_ABGR8888,
+        DrmFormat, FrameFormat, MouseMeta, WlxFrame, DRM_FORMAT_ABGR2101010, DRM_FORMAT_ABGR8888,
        DRM_FORMAT_ARGB8888, DRM_FORMAT_XBGR2101010, DRM_FORMAT_XBGR8888, DRM_FORMAT_XRGB8888,
    },
+    pipewire::PipewireSelectScreenResult,
    WlxCapture,
 };

@@ -25,10 +26,13 @@ use wlx_capture::{
 use {
    crate::config_io,
    std::error::Error,
-    std::{ops::Deref, path::PathBuf},
-    wlx_capture::pipewire::{pipewire_select_screen, PipewireCapture, PipewireStream},
+    std::{ops::Deref, path::PathBuf, task},
+    wlx_capture::pipewire::PipewireCapture,
 };

+#[cfg(all(feature = "x11", feature = "pipewire"))]
+use wlx_capture::pipewire::PipewireStream;
+
 #[cfg(feature = "wayland")]
 use {
    crate::config::AStrMapExt,
@@ -280,7 +284,7 @@ pub struct ScreenRenderer {
    capture: Box<dyn WlxCapture>,
    pipeline: Option<ScreenPipeline>,
    last_view: Option<Arc<ImageView>>,
-    extent: [u32; 3],
+    extent: Option<[u32; 3]>,
 }

 impl ScreenRenderer {
@@ -291,12 +295,12 @@ impl ScreenRenderer {
            capture,
            pipeline: None,
            last_view: None,
-            extent: [0; 3],
+            extent: None,
        }
    }

    #[cfg(feature = "wayland")]
-    pub fn new_wlr_dmabuf(output: &WlxOutput, config: &GeneralConfig) -> Option<ScreenRenderer> {
+    pub fn new_wlr_dmabuf(output: &WlxOutput) -> Option<ScreenRenderer> {
        let client = WlxClient::new()?;
        let capture = WlrDmabufCapture::new(client, output.id);

@@ -305,15 +309,12 @@ impl ScreenRenderer {
            capture: Box::new(capture),
            pipeline: None,
            last_view: None,
-            extent: extent_from_res(output.size, config),
+            extent: None,
        })
    }

    #[cfg(feature = "wayland")]
-    pub fn new_wlr_screencopy(
-        output: &WlxOutput,
-        config: &GeneralConfig,
-    ) -> Option<ScreenRenderer> {
+    pub fn new_wlr_screencopy(output: &WlxOutput) -> Option<ScreenRenderer> {
        let client = WlxClient::new()?;
        let capture = WlrScreencopyCapture::new(client, output.id);

@@ -322,7 +323,7 @@ impl ScreenRenderer {
            capture: Box::new(capture),
            pipeline: None,
            last_view: None,
-            extent: extent_from_res(output.size, config),
+            extent: None,
        })
    }

@@ -337,21 +338,22 @@ impl ScreenRenderer {
    )> {
        let name = output.name.clone();
        let embed_mouse = !session.config.double_cursor_fix;
-        log::info!(
-            "On screen share prompt, pick: {} {} {} (pos {}, {})",
-            &output.name,
-            &output.make,
-            &output.model,
-            &output.logical_pos.0,
-            &output.logical_pos.1,
-        );
-        let select_screen_result = futures::executor::block_on(pipewire_select_screen(
+
+        let select_screen_result = select_pw_screen(
+            &format!(
+                "Now select: {} {} {} @ {},{}",
+                &output.name,
+                &output.make,
+                &output.model,
+                &output.logical_pos.0,
+                &output.logical_pos.1
+            ),
            token,
            embed_mouse,
            true,
            true,
            false,
-        ))?;
+        )?;

        let node_id = select_screen_result.streams.first().unwrap().node_id; // streams guaranteed to have at least one element

@@ -363,14 +365,14 @@ impl ScreenRenderer {
                capture: Box::new(capture),
                pipeline: None,
                last_view: None,
-                extent: extent_from_res(output.size, &session.config),
+                extent: None,
            },
            select_screen_result.restore_token,
        ))
    }

    #[cfg(feature = "x11")]
-    pub fn new_xshm(screen: Arc<XshmScreen>, config: &GeneralConfig) -> ScreenRenderer {
+    pub fn new_xshm(screen: Arc<XshmScreen>) -> ScreenRenderer {
        let capture = XshmCapture::new(screen.clone());

        ScreenRenderer {
@@ -378,7 +380,7 @@ impl ScreenRenderer {
            capture: Box::new(capture),
            pipeline: None,
            last_view: None,
-            extent: extent_from_res((screen.monitor.width(), screen.monitor.height()), config),
+            extent: None,
        }
    }
 }
@@ -466,11 +468,28 @@ impl OverlayRenderer for ScreenRenderer {
                        log::error!("Invalid frame");
                        continue;
                    }
+                    self.extent.get_or_insert_with(|| {
+                        extent_from_format(frame.format, &app.session.config)
+                    });
                    match app.graphics.dmabuf_texture(frame) {
                        Ok(new) => {
-                            let view = ImageView::new_default(new.clone())?;
-
-                            self.last_view = Some(view);
+                            let pipeline = match self.pipeline {
+                                Some(ref mut p) => Some(p),
+                                None if app.session.config.screen_render_down => {
+                                    log::info!("{}: Using render-down pass.", self.name);
+                                    let pipeline = ScreenPipeline::new(&self.extent.unwrap(), app)?; // safe
+                                    self.last_view = Some(pipeline.view.clone());
+                                    self.pipeline = Some(pipeline);
+                                    self.pipeline.as_mut()
+                                }
+                                None => None,
+                            };
+                            if let Some(pipeline) = pipeline {
+                                pipeline.render(new.clone(), None, app)?;
+                            } else {
+                                let view = ImageView::new_default(new.clone())?;
+                                self.last_view = Some(view);
+                            }
                        }
                        Err(e) => {
                            log::error!(
@@ -491,6 +510,9 @@ impl OverlayRenderer for ScreenRenderer {
                        log::error!("No fd");
                        continue;
                    };
+                    self.extent.get_or_insert_with(|| {
+                        extent_from_format(frame.format, &app.session.config)
+                    });
                    log::debug!("{}: New MemFd frame", self.name);
                    let format = fourcc_to_vk(frame.format.fourcc)?;

@@ -543,10 +565,13 @@ impl OverlayRenderer for ScreenRenderer {
                    let pipeline = Some(match self.pipeline {
                        Some(ref mut p) => p,
                        _ => {
-                            let mut pipeline = ScreenPipeline::new(&self.extent, app)?;
+                            log::info!("{}: Using render-down pass.", self.name);
+                            let extent = extent_from_format(frame.format, &app.session.config);
+                            let mut pipeline = ScreenPipeline::new(&extent, app)?;
                            self.last_view = Some(pipeline.view.clone());
                            pipeline.ensure_mouse_initialized(&mut upload)?;
                            self.pipeline = Some(pipeline);
+                            self.extent = Some(extent);
                            self.pipeline.as_mut().unwrap() // safe
                        }
                    });
@@ -577,7 +602,7 @@ impl OverlayRenderer for ScreenRenderer {
        self.last_view.clone()
    }
    fn extent(&mut self) -> Option<[u32; 3]> {
-        Some(self.extent)
+        self.extent
    }
 }

@@ -590,16 +615,14 @@ pub fn create_screen_renderer_wl(
    session: &AppSession,
 ) -> Option<ScreenRenderer> {
    let mut capture: Option<ScreenRenderer> = None;
-    if (&*session.config.capture_method == "auto" || &*session.config.capture_method == "dmabuf")
-        && has_wlr_dmabuf
-    {
+    if (&*session.config.capture_method == "wlr-dmabuf") && has_wlr_dmabuf {
        log::info!("{}: Using Wlr DMA-Buf", &output.name);
-        capture = ScreenRenderer::new_wlr_dmabuf(output, &session.config);
+        capture = ScreenRenderer::new_wlr_dmabuf(output);
    }

    if &*session.config.capture_method == "screencopy" && has_wlr_screencopy {
        log::info!("{}: Using Wlr Screencopy Wl-SHM", &output.name);
-        capture = ScreenRenderer::new_wlr_screencopy(output, &session.config);
+        capture = ScreenRenderer::new_wlr_screencopy(output);
    }

    if capture.is_none() {
@@ -845,8 +868,16 @@ pub fn create_screens_x11pw(app: &mut AppState) -> anyhow::Result<ScreenCreateDa
    let pw_tokens_copy = pw_tokens.clone();
    let token = pw_tokens.arc_get("x11").map(|s| s.as_str());
    let embed_mouse = !app.session.config.double_cursor_fix;
-    let select_screen_result =
-        futures::executor::block_on(pipewire_select_screen(token, embed_mouse, true, true, true))?;
+
+    let select_screen_result = select_pw_screen(
+        "Select ALL screens on the screencast pop-up!",
+        token,
+        embed_mouse,
+        true,
+        true,
+        true,
+    )?;
+
    if let Some(restore_token) = select_screen_result.restore_token {
        if pw_tokens.arc_set("x11".into(), restore_token.clone()) {
            log::info!("Adding Pipewire token {}", restore_token);
@@ -899,7 +930,11 @@ pub fn create_screens_x11pw(app: &mut AppState) -> anyhow::Result<ScreenCreateDa
                capture: Box::new(PipewireCapture::new(m.name.clone(), s.node_id)),
                pipeline: None,
                last_view: None,
-                extent: extent_from_res(size, &app.session.config),
+                extent: Some(extent_from_res(
+                    size.0 as _,
+                    size.1 as _,
+                    &app.session.config,
+                )),
            };

            let backend = Box::new(SplitOverlayBackend {
@@ -937,7 +972,7 @@ pub fn create_screens_xshm(app: &mut AppState) -> anyhow::Result<ScreenCreateDat

            let size = (s.monitor.width(), s.monitor.height());
            let pos = (s.monitor.x(), s.monitor.y());
-            let renderer = ScreenRenderer::new_xshm(s.clone(), &app.session.config);
+            let renderer = ScreenRenderer::new_xshm(s.clone());

            log::info!(
                "{}: Init X11 screen of res {:?} at {:?}",
@@ -1003,11 +1038,14 @@ impl From<wl_output::Transform> for Transform {
    }
 }

-fn extent_from_res(res: (i32, i32), config: &GeneralConfig) -> [u32; 3] {
-    // screens above a certain resolution will have severe aliasing
+fn extent_from_format(fmt: FrameFormat, config: &GeneralConfig) -> [u32; 3] {
+    extent_from_res(fmt.width, fmt.height, config)
+}

-    let h = res.1.min(config.screen_max_height as i32) as u32;
-    let w = (res.0 as f32 / res.1 as f32 * h as f32) as u32;
+fn extent_from_res(width: u32, height: u32, config: &GeneralConfig) -> [u32; 3] {
+    // screens above a certain resolution will have severe aliasing
+    let h = height.min(config.screen_max_height as u32);
+    let w = (width as f32 / height as f32 * h as f32) as u32;
    [w, h, 1]
 }

@@ -1038,3 +1076,54 @@ fn best_match<'a>(
    log::debug!("best: {:?}", best.map(|b| &b.monitor));
    best
 }
+
+#[cfg(feature = "pipewire")]
+fn select_pw_screen(
+    instructions: &str,
+    token: Option<&str>,
+    embed_mouse: bool,
+    screens_only: bool,
+    persist: bool,
+    multiple: bool,
+) -> Result<PipewireSelectScreenResult, wlx_capture::pipewire::AshpdError> {
+    use crate::backend::notifications::DbusNotificationSender;
+    use wlx_capture::pipewire::pipewire_select_screen;
+
+    let future = async move {
+        let print_at = Instant::now() + Duration::from_millis(250);
+        let mut notify = None;
+
+        let f = pipewire_select_screen(token, embed_mouse, screens_only, persist, multiple);
+        futures::pin_mut!(f);
+
+        loop {
+            match futures::poll!(&mut f) {
+                task::Poll::Ready(result) => return result,
+                task::Poll::Pending => {
+                    if Instant::now() >= print_at {
+                        log::info!("{}", instructions);
+                        if let Ok(sender) = DbusNotificationSender::new() {
+                            if let Ok(id) = sender.notify_send(instructions, "", 2, 0, 0, true) {
+                                notify = Some((sender, id));
+                            }
+                        }
+                        break;
+                    }
+                    futures::future::lazy(|_| {
+                        std::thread::sleep(Duration::from_millis(10));
+                    })
+                    .await;
+                    continue;
+                }
+            }
+        }
+
+        let result = f.await;
+        if let Some((sender, id)) = notify {
+            let _ = sender.notify_close(id);
+        }
+        result
+    };
+
+    futures::executor::block_on(future)
+}
@@ -9,14 +9,14 @@ size: [400, 200]
 elements:
  # background panel
  - type: Panel
-    rect: [0, 0, 400, 200]
-    corner_radius: 4
+    rect: [0, 30, 400, 130]
+    corner_radius: 20
    bg_color: "#24273a"

  - type: Button
    rect: [2, 162, 26, 36]
    corner_radius: 4
-    font_size: 14
+    font_size: 15
    bg_color: "#c6a0f6"
    fg_color: "#24273a"
    text: "C"
@@ -32,7 +32,7 @@ elements:
  - type: Button
    rect: [32, 162, 60, 36]
    corner_radius: 4
-    font_size: 14
+    font_size: 15
    fg_color: "#24273a"
    bg_color: "#a6da95"
    text: Kbd
@@ -67,7 +67,7 @@ elements:
  - type: OverlayList
    rect: [94, 160, 306, 40]
    corner_radius: 4
-    font_size: 14
+    font_size: 15
    fg_color: "#cad3f5"
    bg_color: "#1e2030"
    layout: Horizontal
@@ -147,9 +147,9 @@ elements:

  # batteries
  - type: BatteryList
-    rect: [0, 0, 400, 30]
+    rect: [0, 5, 400, 30]
    corner_radius: 4
-    font_size: 14
+    font_size: 16
    fg_color: "#8bd5ca"
    fg_color_low: "#B06060"
    fg_color_charging: "#6080A0"
@@ -161,7 +161,7 @@ elements:
  - type: Button
    rect: [315, 52, 70, 32]
    corner_radius: 4
-    font_size: 14
+    font_size: 13
    fg_color: "#cad3f5"
    bg_color: "#5b6078"
    text: "Vol +"
@@ -171,7 +171,7 @@ elements:
  - type: Button
    rect: [315, 116, 70, 32]
    corner_radius: 4
-    font_size: 14
+    font_size: 13
    fg_color: "#cad3f5"
    bg_color: "#5b6078"
    text: "Vol -"
@@ -1,7 +1,7 @@
-use std::{io::Cursor, path::PathBuf, sync::Arc};
+use std::{io::Cursor, sync::Arc};

 use anyhow::bail;
-use glam::{Affine3A, Vec3};
+use glam::Affine3A;
 use idmap::IdMap;
 use rodio::{Decoder, OutputStream, OutputStreamHandle, Source};
 use serde::{Deserialize, Serialize};
@@ -89,15 +89,9 @@ impl AppState {
 }

 pub struct AppSession {
-    pub config_root_path: PathBuf,
    pub config: GeneralConfig,

    pub toast_topics: IdMap<ToastTopic, DisplayMethod>,
-
-    pub color_norm: Vec3,
-    pub color_shift: Vec3,
-    pub color_alt: Vec3,
-    pub color_grab: Vec3,
 }

 impl AppSession {
@@ -116,29 +110,8 @@ impl AppSession {
        });

        AppSession {
-            config_root_path,
            config,
            toast_topics,
-            color_norm: Vec3 {
-                x: 0.,
-                y: 1.,
-                z: 1.,
-            },
-            color_shift: Vec3 {
-                x: 1.,
-                y: 1.,
-                z: 0.,
-            },
-            color_alt: Vec3 {
-                x: 1.,
-                y: 0.,
-                z: 1.,
-            },
-            color_grab: Vec3 {
-                x: 1.,
-                y: 0.,
-                z: 0.,
-            },
        }
    }
 }
Author	SHA1	Message	Date
galister	85aa0fb1bc	release 0.6	2024-09-28 01:54:53 +09:00
galister	7f72abc62a	release modifiers on keyboard hide	2024-09-28 01:53:20 +09:00
galister	83ae798215	add virtualkey action for modular button	2024-09-27 02:23:13 +09:00
galister	bdbdbea20b	screen notification popups	2024-09-26 23:51:46 +09:00
galister	a077f2dda4	fix dragging cursor off-screen	2024-09-26 23:51:44 +09:00
galister	8d35b45c2b	rollback vulkano	2024-09-24 11:45:29 +02:00
galister	6af5623fa7	update readme	2024-09-19 06:18:06 +00:00
galister	62ef7a1210	update readme	2024-09-19 06:47:01 +09:00
galister	3f425820d7	release 0.5.0	2024-09-19 05:29:27 +09:00
galister	6a2d8b9f90	fresh watch style	2024-09-19 03:09:09 +09:00
galister	583a5f7fe0	openxr: toggle for space rotate axis lock	2024-09-18 04:06:37 +09:00
galister	03f2eaf97f	fps-stabilize openxr smoothing	2024-09-16 07:05:26 +09:00
galister	21331b5c42	fps-aware openxr pointer smoothing	2024-09-16 05:09:10 +09:00
galister	72a82530ae	fix openxr space rotate	2024-09-16 05:01:15 +09:00
galister	13d9284bb8	move mouse move-scroll exclusivity to hid module	2024-09-11 06:03:22 +09:00
galister	b0a33a1181	openxr: laser pointer smoothing	2024-09-09 07:54:19 +09:00
galister	4f38d1ad44	make pipewire default on wlroots	2024-08-24 02:21:43 +09:00
galister	c6bc880bc3	add logging for screen pipeline	2024-08-20 16:49:35 +09:00
galister	0a2be76150	change some version stuff	2024-08-20 16:40:08 +09:00
galister	1a87823847	rename github action	2024-08-20 14:04:44 +09:00
galister	e763e15bdc	build dev appimages	2024-08-20 14:02:12 +09:00
galister	6a3b60f298	feat: screen_render_down	2024-08-20 13:54:18 +09:00
Adalyn Black	397b3eedd1	Use git hash if no tags can be found	2024-08-19 17:35:58 +02:00
hypevhs	9d18628354	feat: XR binding for playspace reset	2024-08-15 21:30:39 +02:00
galister	dc985f6da6	docs: update known issues	2024-08-13 07:43:37 +00:00
raku-cat	850601b3b9	Update wlx-capture	2024-08-12 12:16:10 +00:00
galister	8a4c7a400f	dirty versions	2024-08-11 06:41:17 +09:00
galister	d9287f3250	Release 0.4.4	2024-08-11 06:23:38 +09:00
hypevhs	378ea120c8	Fix mirrors spawning behind head	2024-08-10 20:34:55 +00:00
galister	f4cc49ca69	fix keyboard macro regex	2024-08-09 23:25:59 +00:00
galister	57ff3aa1dd	clippy	2024-08-09 10:19:57 +00:00
galister	0808383e70	corner_radius is optional	2024-08-09 10:19:57 +00:00
galister	c71911998e	upright screen fix	2024-08-09 08:38:37 +09:00
galister	50c3f49989	hmd pose from view space	2024-08-09 08:38:37 +09:00
Aleksander	b6a07c43a5	Fix scrolling for all Electron-based applications	2024-08-07 18:12:20 +00:00