Release 25.2

Cargo.lock

@@ -4655,7 +4655,7 @@ dependencies = [
 [[package]]
 name = "wayvr_ipc"
 version = "0.1.0"
-source = "git+https://github.com/olekolek1000/wayvr-ipc.git?rev=a72587d23f3bb8624d9aeb1f13c0a21e65350f51#a72587d23f3bb8624d9aeb1f13c0a21e65350f51"
+source = "git+https://github.com/olekolek1000/wayvr-ipc.git?rev=3c411d09ba1bba2609288e29739c0f1ec736b012#3c411d09ba1bba2609288e29739c0f1ec736b012"
 dependencies = [
  "anyhow",
  "bytes",
@@ -5121,7 +5121,7 @@ dependencies = [
 
 [[package]]
 name = "wlx-overlay-s"
-version = "25.3.0"
+version = "25.2.0"
 dependencies = [
  "anyhow",
  "ash",

Cargo.toml

@@ -4,7 +4,7 @@ debug = true
 
 [package]
 name = "wlx-overlay-s"
-version = "25.3.0"
+version = "25.2.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -86,7 +86,7 @@ wayland-client = { version = "0.31.6", optional = true }
 wayland-egl = { version = "0.32.4", optional = true }
 interprocess = { version = "2.2.2", optional = true }
 bytes = { version = "1.9.0", optional = true }
-wayvr_ipc = { git = "https://github.com/olekolek1000/wayvr-ipc.git", rev = "a72587d23f3bb8624d9aeb1f13c0a21e65350f51", default-features = false, optional = true }
+wayvr_ipc = { git = "https://github.com/olekolek1000/wayvr-ipc.git", rev = "3c411d09ba1bba2609288e29739c0f1ec736b012", default-features = false, optional = true }
 ################################
 
 [build-dependencies]

contrib/wayvr/watch_wayvr_example.yaml

@@ -28,21 +28,9 @@ elements:
         target: settings
         action: Destroy # only triggers if exists since before current frame
 
-  # Dashboard toggle button
-  - type: Button
-    rect: [32, 162, 48, 36]
-    corner_radius: 4
-    font_size: 15
-    bg_color: "#2288FF"
-    fg_color: "#24273a"
-    text: "Dash"
-    click_up:
-      - type: WayVR
-        action: ToggleDashboard
-
   # Keyboard button
   - type: Button
-    rect: [84, 162, 48, 36]
+    rect: [32, 162, 60, 36]
     corner_radius: 4
     font_size: 15
     fg_color: "#24273a"
@@ -77,7 +65,7 @@ elements:
 
   # bottom row, of keyboard + overlays
   - type: OverlayList
-    rect: [134, 160, 266, 40]
+    rect: [94, 160, 306, 40]
     corner_radius: 4
     font_size: 15
     fg_color: "#cad3f5"

src/backend/osc.rs

@@ -146,24 +146,24 @@ impl OscSender {
 
                 // send device battery parameters
                 self.send_message(
-                    format!("/avatar/parameters/{parameter}Battery"),
+                    format!("/avatar/parameters/{parameter}Battery").into(),
                     vec![OscType::Float(level)],
                 )?;
                 self.send_message(
-                    format!("/avatar/parameters/{parameter}Charging"),
+                    format!("/avatar/parameters/{parameter}Charging").into(),
                     vec![OscType::Bool(device.charging)],
                 )?;
             }
 
             // send average controller and tracker battery parameters
             self.send_message(
-                String::from("/avatar/parameters/averageControllerBattery"),
+                format!("/avatar/parameters/averageControllerBattery").into(),
                 vec![OscType::Float(
                     controller_total_bat / controller_count as f32,
                 )],
             )?;
             self.send_message(
-                String::from("/avatar/parameters/averageTrackerBattery"),
+                format!("/avatar/parameters/averageTrackerBattery").into(),
                 vec![OscType::Float(tracker_total_bat / tracker_count as f32)],
             )?;
         }

src/backend/wayvr/display.rs

@@ -291,7 +291,8 @@ impl Display {
         renderer.bind(self.gles_texture.clone())?;
 
         let size = Size::from((self.width as i32, self.height as i32));
-        let damage: Rectangle<i32, smithay::utils::Physical> = Rectangle::from_size(size);
+        let damage: Rectangle<i32, smithay::utils::Physical> =
+            Rectangle::from_loc_and_size((0, 0), size);
 
         let elements: Vec<WaylandSurfaceRenderElement<GlesRenderer>> = self
             .displayed_windows

src/backend/wayvr/mod.rs

@@ -40,8 +40,6 @@ use std::{
 use time::get_millis;
 use wayvr_ipc::{packet_client, packet_server};
 
-use crate::state::AppState;
-
 const STR_INVALID_HANDLE_DISP: &str = "Invalid display handle";
 const STR_INVALID_HANDLE_PROCESS: &str = "Invalid process handle";
 
@@ -187,10 +185,12 @@ impl WayVR {
             }
             Ok(None) => {
                 log::warn!("dmabuf: Failed to query render node");
+                debug_assert!(false);
                 None
             }
             Err(err) => {
                 log::warn!("dmabuf: Failed to get egl device for display: {}", err);
+                debug_assert!(false);
                 None
             }
         };
@@ -279,13 +279,12 @@ impl WayVR {
         Ok(())
     }
 
-    pub fn tick_events(&mut self, app: &AppState) -> anyhow::Result<Vec<TickTask>> {
+    pub fn tick_events(&mut self) -> anyhow::Result<Vec<TickTask>> {
         let mut tasks: Vec<TickTask> = Vec::new();
 
         self.ipc_server.tick(&mut server_ipc::TickParams {
             state: &mut self.state,
             tasks: &mut tasks,
-            app,
         })?;
 
         // Check for redraw events

src/backend/wayvr/server_ipc.rs

@@ -1,15 +1,12 @@
-use crate::state::AppState;
-
 use super::{display, process, window, TickTask, WayVRSignal};
 use bytes::BufMut;
-use glam::Vec3A;
 use interprocess::local_socket::{self, traits::Listener, ToNsName};
 use smallvec::SmallVec;
 use std::io::{Read, Write};
 use wayvr_ipc::{
     ipc::{self},
     packet_client::{self, PacketClient},
-    packet_server::{self, PacketServer, WlxInputStatePointer},
+    packet_server::{self, PacketServer},
 };
 
 pub struct AuthInfo {
@@ -73,7 +70,6 @@ fn read_payload(conn: &mut local_socket::Stream, size: u32) -> Option<Payload> {
 pub struct TickParams<'a> {
     pub state: &'a mut super::WayVRState,
     pub tasks: &'a mut Vec<TickTask>,
-    pub app: &'a AppState,
 }
 
 pub fn gen_args_vec(input: &str) -> Vec<&str> {
@@ -181,34 +177,6 @@ impl Connection {
         Ok(())
     }
 
-    fn handle_wlx_input_state(
-        &mut self,
-        params: &TickParams,
-        serial: ipc::Serial,
-    ) -> anyhow::Result<()> {
-        let input_state = &params.app.input_state;
-
-        let to_arr = |vec: &Vec3A| -> [f32; 3] { [vec.x, vec.y, vec.z] };
-
-        send_packet(
-            &mut self.conn,
-            &ipc::data_encode(&PacketServer::WlxInputStateResponse(
-                serial,
-                packet_server::WlxInputState {
-                    hmd_pos: to_arr(&input_state.hmd.translation),
-                    left: WlxInputStatePointer {
-                        pos: to_arr(&input_state.pointers[0].raw_pose.translation),
-                    },
-                    right: WlxInputStatePointer {
-                        pos: to_arr(&input_state.pointers[0].raw_pose.translation),
-                    },
-                },
-            )),
-        )?;
-
-        Ok(())
-    }
-
     fn handle_wvr_display_create(
         &mut self,
         params: &mut TickParams,
@@ -503,9 +471,6 @@ impl Connection {
 
         match packet {
             PacketClient::Handshake(_) => unreachable!(), // handled previously
-            PacketClient::WlxInputState(serial) => {
-                self.handle_wlx_input_state(params, serial)?;
-            }
             PacketClient::WvrDisplayList(serial) => {
                 self.handle_wvr_display_list(params, serial)?;
             }
@@ -668,11 +633,10 @@ impl WayVRServer {
         Ok(())
     }
 
-    pub fn broadcast(&mut self, packet: packet_server::PacketServer) {
+    pub fn broadcast(&mut self, packet: packet_server::PacketServer) -> anyhow::Result<()> {
         for connection in &mut self.connections {
-            if let Err(e) = send_packet(&mut connection.conn, &ipc::data_encode(&packet)) {
-                log::error!("failed to broadcast packet: {:?}", e);
-            }
+            send_packet(&mut connection.conn, &ipc::data_encode(&packet))?;
         }
+        Ok(())
     }
 }

src/graphics/mod.rs

@@ -942,7 +942,6 @@ impl WlxGraphics {
         )?))
     }
 
-    #[allow(clippy::too_many_arguments)]
     pub fn create_pipeline_with_layouts(
         self: &Arc<Self>,
         render_target: Arc<ImageView>,
@@ -1305,7 +1304,6 @@ impl WlxPipeline<WlxPipelineLegacy> {
         )
     }
 
-    #[allow(clippy::too_many_arguments)]
     fn new_with_layout(
         render_target: Arc<ImageView>,
         graphics: Arc<WlxGraphics>,

src/gui/canvas/builder.rs

@@ -153,7 +153,6 @@ impl<D, S> CanvasBuilder<D, S> {
         &mut self.canvas.controls[idx]
     }
 
-    #[allow(clippy::too_many_arguments)]
     pub fn key_button(
         &mut self,
         x: f32,

src/gui/canvas/control.rs

@@ -19,7 +19,6 @@ pub type ControlRendererHl<D, S> = fn(
     Vec4,
 ) -> anyhow::Result<()>;
 
-#[allow(clippy::type_complexity)]
 pub(crate) struct Control<D, S> {
     pub state: Option<S>,
     pub rect: Rect,

src/hid/mod.rs

@@ -68,8 +68,7 @@ struct MouseAction {
 }
 
 pub struct UInputProvider {
-    keyboard_handle: UInputHandle<File>,
-    mouse_handle: UInputHandle<File>,
+    handle: UInputHandle<File>,
     desktop_extent: Vec2,
     desktop_origin: Vec2,
     cur_modifiers: u8,
@@ -91,89 +90,97 @@ const EV_ABS: u16 = 0x3;
 
 impl UInputProvider {
     fn try_new() -> Option<Self> {
-        let keyboard_file = File::create("/dev/uinput").ok()?;
-        let keyboard_handle = UInputHandle::new(keyboard_file);
+        if let Ok(file) = File::create("/dev/uinput") {
+            let handle = UInputHandle::new(file);
 
-        let mouse_file = File::create("/dev/uinput").ok()?;
-        let mouse_handle = UInputHandle::new(mouse_file);
+            let id = InputId {
+                bustype: 0x03,
+                vendor: 0x4711,
+                product: 0x0829,
+                version: 5,
+            };
 
-        let kbd_id = InputId {
-            bustype: 0x03,
-            vendor: 0x4711,
-            product: 0x0829,
-            version: 5,
-        };
-        let mouse_id = InputId {
-            bustype: 0x03,
-            vendor: 0x4711,
-            product: 0x0830,
-            version: 5,
-        };
-        let kbd_name = b"WlxOverlay-S Keyboard\0";
-        let mouse_name = b"WlxOverlay-S Mouse\0";
+            let name = b"WlxOverlay-S Keyboard-Mouse Hybrid Thing\0";
 
-        let abs_info = vec![
-            AbsoluteInfoSetup {
-                axis: input_linux::AbsoluteAxis::X,
-                info: AbsoluteInfo {
-                    value: 0,
-                    minimum: 0,
-                    maximum: MOUSE_EXTENT as _,
-                    fuzz: 0,
-                    flat: 0,
-                    resolution: 10,
+            let abs_info = vec![
+                AbsoluteInfoSetup {
+                    axis: input_linux::AbsoluteAxis::X,
+                    info: AbsoluteInfo {
+                        value: 0,
+                        minimum: 0,
+                        maximum: MOUSE_EXTENT as _,
+                        fuzz: 0,
+                        flat: 0,
+                        resolution: 10,
+                    },
                 },
-            },
-            AbsoluteInfoSetup {
-                axis: input_linux::AbsoluteAxis::Y,
-                info: AbsoluteInfo {
-                    value: 0,
-                    minimum: 0,
-                    maximum: MOUSE_EXTENT as _,
-                    fuzz: 0,
-                    flat: 0,
-                    resolution: 10,
+                AbsoluteInfoSetup {
+                    axis: input_linux::AbsoluteAxis::Y,
+                    info: AbsoluteInfo {
+                        value: 0,
+                        minimum: 0,
+                        maximum: MOUSE_EXTENT as _,
+                        fuzz: 0,
+                        flat: 0,
+                        resolution: 10,
+                    },
                 },
-            },
-        ];
+            ];
 
-        keyboard_handle.set_evbit(EventKind::Key).ok()?;
-        for key in VirtualKey::iter() {
-            let mapped_key: Key = unsafe { std::mem::transmute((key as u16) - 8) };
-            keyboard_handle.set_keybit(mapped_key).ok()?;
+            if handle.set_evbit(EventKind::Key).is_err() {
+                return None;
+            }
+            if handle.set_evbit(EventKind::Absolute).is_err() {
+                return None;
+            }
+            if handle.set_evbit(EventKind::Relative).is_err() {
+                return None;
+            }
+
+            for btn in MOUSE_LEFT..=MOUSE_MIDDLE {
+                let key: Key = unsafe { transmute(btn) };
+                if handle.set_keybit(key).is_err() {
+                    return None;
+                }
+            }
+
+            for key in VirtualKey::iter() {
+                let key: Key = unsafe { transmute((key as u16) - 8) };
+                if handle.set_keybit(key).is_err() {
+                    return None;
+                }
+            }
+
+            if handle.set_absbit(AbsoluteAxis::X).is_err() {
+                return None;
+            }
+            if handle.set_absbit(AbsoluteAxis::Y).is_err() {
+                return None;
+            }
+            if handle.set_relbit(RelativeAxis::Wheel).is_err() {
+                return None;
+            }
+
+            if handle.create(&id, name, 0, &abs_info).is_ok() {
+                return Some(UInputProvider {
+                    handle,
+                    desktop_extent: Vec2::ZERO,
+                    desktop_origin: Vec2::ZERO,
+                    current_action: Default::default(),
+                    cur_modifiers: 0,
+                });
+            }
         }
-
-        keyboard_handle.create(&kbd_id, kbd_name, 0, &[]).ok()?;
-
-        mouse_handle.set_evbit(EventKind::Absolute).ok()?;
-        mouse_handle.set_evbit(EventKind::Relative).ok()?;
-        mouse_handle.set_absbit(AbsoluteAxis::X).ok()?;
-        mouse_handle.set_absbit(AbsoluteAxis::Y).ok()?;
-        mouse_handle.set_relbit(RelativeAxis::Wheel).ok()?;
-        mouse_handle.set_evbit(EventKind::Key).ok()?;
-
-        for btn in MOUSE_LEFT..=MOUSE_MIDDLE {
-            let mouse_btn: Key = unsafe { transmute(btn) };
-            mouse_handle.set_keybit(mouse_btn).ok()?;
-        }
-        mouse_handle.create(&mouse_id, mouse_name, 0, &abs_info).ok()?;
-
-        Some(UInputProvider {
-            keyboard_handle,
-            mouse_handle,
-            desktop_extent: Vec2::ZERO,
-            desktop_origin: Vec2::ZERO,
-            current_action: Default::default(),
-            cur_modifiers: 0,
-        })
+        None
     }
+
     fn send_button_internal(&self, button: u16, down: bool) {
         let time = get_time();
         let events = [
             new_event(time, EV_KEY, button, down as _),
             new_event(time, EV_SYN, 0, 0),
         ];
-        if let Err(res) = self.mouse_handle.write(&events) {
+        if let Err(res) = self.handle.write(&events) {
             log::error!("send_button: {}", res.to_string());
         }
     }
@@ -189,7 +196,7 @@ impl UInputProvider {
             new_event(time, EV_ABS, AbsoluteAxis::Y as _, pos.y as i32),
             new_event(time, EV_SYN, 0, 0),
         ];
-        if let Err(res) = self.mouse_handle.write(&events) {
+        if let Err(res) = self.handle.write(&events) {
             log::error!("{}", res.to_string());
         }
     }
@@ -199,7 +206,7 @@ impl UInputProvider {
             new_event(time, EV_REL, RelativeAxis::Wheel as _, delta),
             new_event(time, EV_SYN, 0, 0),
         ];
-        if let Err(res) = self.mouse_handle.write(&events) {
+        if let Err(res) = self.handle.write(&events) {
             log::error!("wheel: {}", res.to_string());
         }
     }
@@ -225,7 +232,7 @@ impl HidProvider for UInputProvider {
             new_event(time, EV_KEY, (key as u16) - 8, down as _),
             new_event(time, EV_SYN, 0, 0),
         ];
-        if let Err(res) = self.keyboard_handle.write(&events) {
+        if let Err(res) = self.handle.write(&events) {
             log::error!("send_key: {}", res.to_string());
         }
     }

src/overlays/keyboard.rs

@@ -95,7 +95,7 @@ where
     canvas.fg_color = color_parse("#cad3f5").unwrap(); //safe
     canvas.bg_color = color_parse("#1e2030").unwrap(); //safe
 
-    let has_altgr = keymap.as_ref().is_some_and(|k| k.has_altgr());
+    let has_altgr = keymap.as_ref().map_or(false, |k| k.has_altgr());
 
     if !LAYOUT.auto_labels.unwrap_or(true) {
         keymap = None;
@@ -125,7 +125,7 @@ where
                                 let label0 = keymap.label_for_key(vk, 0);
                                 let label1 = keymap.label_for_key(vk, SHIFT);
 
-                                if label0.chars().next().is_some_and(|f| f.is_alphabetic()) {
+                                if label0.chars().next().map_or(false, |f| f.is_alphabetic()) {
                                     label.push(label1);
                                     if has_altgr {
                                         cap_type = KeyCapType::RegularAltGr;

src/overlays/wayvr.rs

@@ -1,7 +1,7 @@
 use glam::{vec3a, Affine2, Vec3, Vec3A};
 use std::{cell::RefCell, collections::HashMap, rc::Rc, sync::Arc};
 use vulkano::image::SubresourceLayout;
-use wayvr_ipc::packet_server::{self, PacketServer, WvrStateChanged};
+use wayvr_ipc::packet_server;
 use wlx_capture::frame::{DmabufFrame, FourCC, FrameFormat, FramePlane};
 
 use crate::{
@@ -332,23 +332,12 @@ where
         anyhow::bail!("Overlay ID not set for dashboard display");
     };
 
-    let cur_visibility = !display.visible;
-
-    wayvr
-        .data
-        .ipc_server
-        .broadcast(PacketServer::WvrStateChanged(if cur_visibility {
-            WvrStateChanged::DashboardShown
-        } else {
-            WvrStateChanged::DashboardHidden
-        }));
-
     app.tasks.enqueue(TaskType::Overlay(
         OverlaySelector::Id(overlay_id),
         Box::new(move |app, o| {
             // Toggle visibility
-            o.want_visible = cur_visibility;
-            if cur_visibility {
+            o.want_visible = !o.want_visible;
+            if o.want_visible {
                 o.reset(app, true);
             }
         }),
@@ -458,12 +447,12 @@ where
                 wayvr
                     .data
                     .ipc_server
-                    .broadcast(packet_server::PacketServer::WvrStateChanged(packet));
+                    .broadcast(packet_server::PacketServer::WvrStateChanged(packet))?;
             }
         }
     }
 
-    let res = wayvr.data.tick_events(app)?;
+    let res = wayvr.data.tick_events()?;
     drop(wayvr);
 
     for result in res {