WayVR: Add DashboardShown and DashboardHidden events, add WlxInputState support (#167)

Wlx: Fix various Clippy warnings

Author: oo8dev

Cargo.lock

@@ -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 = "3c411d09ba1bba2609288e29739c0f1ec736b012", default-features = false, optional = true }
+wayvr_ipc = { git = "https://github.com/olekolek1000/wayvr-ipc.git", rev = "a72587d23f3bb8624d9aeb1f13c0a21e65350f51", default-features = false, optional = true }
 ################################
 
 [build-dependencies]

Cargo.toml

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

src/backend/osc.rs

@@ -291,8 +291,7 @@ 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_loc_and_size((0, 0), size);
+        let damage: Rectangle<i32, smithay::utils::Physical> = Rectangle::from_size(size);
 
         let elements: Vec<WaylandSurfaceRenderElement<GlesRenderer>> = self
             .displayed_windows

src/backend/wayvr/display.rs

@@ -40,6 +40,8 @@ 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";
 
@@ -277,12 +279,13 @@ impl WayVR {
         Ok(())
     }
 
-    pub fn tick_events(&mut self) -> anyhow::Result<Vec<TickTask>> {
+    pub fn tick_events(&mut self, app: &AppState) -> 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/mod.rs

@@ -1,12 +1,15 @@
+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},
+    packet_server::{self, PacketServer, WlxInputStatePointer},
 };
 
 pub struct AuthInfo {
@@ -70,6 +73,7 @@ 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> {
@@ -177,6 +181,34 @@ 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,
@@ -471,6 +503,9 @@ 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)?;
             }
@@ -633,10 +668,11 @@ impl WayVRServer {
         Ok(())
     }
 
-    pub fn broadcast(&mut self, packet: packet_server::PacketServer) -> anyhow::Result<()> {
+    pub fn broadcast(&mut self, packet: packet_server::PacketServer) {
         for connection in &mut self.connections {
-            send_packet(&mut connection.conn, &ipc::data_encode(&packet))?;
+            if let Err(e) = send_packet(&mut connection.conn, &ipc::data_encode(&packet)) {
+                log::error!("failed to broadcast packet: {:?}", e);
+            }
         }
-        Ok(())
     }
 }

src/backend/wayvr/server_ipc.rs

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

src/graphics/mod.rs

@@ -153,6 +153,7 @@ 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/builder.rs

@@ -19,6 +19,7 @@ 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/gui/canvas/control.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().map_or(false, |k| k.has_altgr());
+    let has_altgr = keymap.as_ref().is_some_and(|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().map_or(false, |f| f.is_alphabetic()) {
+                                if label0.chars().next().is_some_and(|f| f.is_alphabetic()) {
                                     label.push(label1);
                                     if has_altgr {
                                         cap_type = KeyCapType::RegularAltGr;