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

Wlx: Fix various Clippy warnings

src/backend/osc.rs

@@ -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/wayvr/display.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/mod.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/server_ipc.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(())
     }
 }