omg big commit

src/backend/common.rs

@@ -20,7 +20,7 @@ use crate::{
     state::AppState,
 };
 
-use super::overlay::{OverlayData, OverlayState};
+use super::overlay::{OverlayBackend, OverlayData, OverlayState};
 
 #[derive(Error, Debug)]
 pub enum BackendError {
@@ -91,6 +91,22 @@ where
         }
     }
 
+    pub fn drop_by_selector(&mut self, selector: &OverlaySelector) {
+        match selector {
+            OverlaySelector::Id(id) => {
+                self.overlays.remove(id);
+            }
+            OverlaySelector::Name(name) => {
+                let id = self
+                    .overlays
+                    .iter()
+                    .find(|(_, o)| *o.state.name == **name)
+                    .map(|(id, _)| *id);
+                id.and_then(|id| self.overlays.remove(&id));
+            }
+        };
+    }
+
     pub fn get_by_id<'a>(&'a mut self, id: usize) -> Option<&'a OverlayData<T>> {
         self.overlays.get(&id)
     }
@@ -115,6 +131,10 @@ where
         self.overlays.values_mut()
     }
 
+    pub fn add(&mut self, overlay: OverlayData<T>) {
+        self.overlays.insert(overlay.state.id, overlay);
+    }
+
     pub fn show_hide(&mut self, app: &mut AppState) {
         let any_shown = self
             .overlays
@@ -170,6 +190,11 @@ pub enum TaskType {
         OverlaySelector,
         Box<dyn FnOnce(&mut AppState, &mut OverlayState) + Send>,
     ),
+    CreateOverlay(
+        OverlaySelector,
+        Box<dyn FnOnce(&mut AppState) -> Option<(OverlayState, Box<dyn OverlayBackend>)> + Send>,
+    ),
+    DropOverlay(OverlaySelector),
     Toast(Toast),
 }
 

src/backend/openvr/lines.rs

@@ -64,7 +64,6 @@ impl LinePool {
             state: OverlayState {
                 name: Arc::from(format!("wlx-line{}", id)),
                 show_hide: true,
-                size: (0, 0),
                 ..Default::default()
             },
             backend: Box::new(SplitOverlayBackend {
@@ -181,7 +180,4 @@ impl OverlayRenderer for StaticRenderer {
     fn view(&mut self) -> Option<Arc<ImageView>> {
         Some(self.view.clone())
     }
-    fn extent(&self) -> [u32; 3] {
-        self.view.image().extent().clone()
-    }
 }

src/backend/openvr/mod.rs

@@ -27,6 +27,7 @@ use crate::{
             manifest::{install_manifest, uninstall_manifest},
             overlay::OpenVrOverlayData,
         },
+        overlay::OverlayData,
     },
     graphics::WlxGraphics,
     overlays::watch::{watch_fade, WATCH_NAME},
@@ -157,6 +158,27 @@ pub fn openvr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
                         f(&mut state, &mut o.state);
                     }
                 }
+                TaskType::CreateOverlay(sel, f) => {
+                    let None = overlays.mut_by_selector(&sel) else {
+                        continue;
+                    };
+
+                    let Some((state, backend)) = f(&mut state) else {
+                        continue;
+                    };
+
+                    overlays.add(OverlayData {
+                        state,
+                        backend,
+                        ..Default::default()
+                    });
+                }
+                TaskType::DropOverlay(sel) => {
+                    if let Some(o) = overlays.mut_by_selector(&sel) {
+                        o.destroy(&mut overlay_mngr);
+                        overlays.drop_by_selector(&sel);
+                    }
+                }
                 TaskType::Toast(t) => {
                     // TODO toasts
                     log::info!("Toast: {} {}", t.title, t.body);
@@ -209,7 +231,7 @@ pub fn openvr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
             let _ = sender.send_params(&overlays);
         };
 
-        log::debug!("Rendering frame");
+        log::trace!("Rendering frame");
 
         for o in overlays.iter_mut() {
             if o.state.want_visible {
@@ -217,7 +239,7 @@ pub fn openvr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
             }
         }
 
-        log::debug!("Rendering overlays");
+        log::trace!("Rendering overlays");
 
         overlays
             .iter_mut()

src/backend/openvr/overlay.rs

@@ -254,4 +254,13 @@ impl OverlayData<OpenVrOverlayData> {
             log::error!("{}: Failed to set overlay texture: {}", self.state.name, e);
         }
     }
+
+    pub(super) fn destroy(&mut self, overlay: &mut OverlayManager) {
+        if let Some(handle) = self.data.handle {
+            log::debug!("{}: destroy", self.state.name);
+            if let Err(e) = overlay.destroy_overlay(handle) {
+                log::error!("{}: Failed to destroy overlay: {}", self.state.name, e);
+            }
+        }
+    }
 }

src/backend/openxr/mod.rs

@@ -16,6 +16,7 @@ use crate::{
         common::{OverlayContainer, TaskType},
         input::interact,
         openxr::{input::DoubleClickCounter, lines::LinePool, overlay::OpenXrOverlayData},
+        overlay::OverlayData,
     },
     graphics::WlxGraphics,
     overlays::watch::{watch_fade, WATCH_NAME},
@@ -187,6 +188,24 @@ pub fn openxr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
                         f(&mut app_state, &mut o.state);
                     }
                 }
+                TaskType::CreateOverlay(sel, f) => {
+                    let None = overlays.mut_by_selector(&sel) else {
+                        continue;
+                    };
+
+                    let Some((state, backend)) = f(&mut app_state) else {
+                        continue;
+                    };
+
+                    overlays.add(OverlayData {
+                        state,
+                        backend,
+                        ..Default::default()
+                    });
+                }
+                TaskType::DropOverlay(sel) => {
+                    overlays.drop_by_selector(&sel);
+                }
                 TaskType::Toast(t) => {
                     // TODO toasts
                     log::info!("Toast: {} {}", t.title, t.body);

src/backend/overlay.rs

@@ -7,7 +7,7 @@ use std::{
 };
 
 use anyhow::Ok;
-use glam::{Affine2, Affine3A, Mat3A, Quat, Vec3, Vec3A};
+use glam::{Affine2, Affine3A, Mat3A, Quat, Vec2, Vec3, Vec3A};
 use vulkano::image::view::ImageView;
 
 use crate::state::AppState;
@@ -21,7 +21,6 @@ pub trait OverlayBackend: OverlayRenderer + InteractionHandler {}
 pub struct OverlayState {
     pub id: usize,
     pub name: Arc<str>,
-    pub size: (i32, i32),
     pub want_visible: bool,
     pub show_hide: bool,
     pub grabbable: bool,
@@ -44,7 +43,6 @@ impl Default for OverlayState {
         OverlayState {
             id: AUTO_INCREMENT.fetch_add(1, Ordering::Relaxed),
             name: Arc::from(""),
-            size: (0, 0),
             want_visible: false,
             show_hide: false,
             grabbable: false,
@@ -208,7 +206,6 @@ pub trait OverlayRenderer {
     fn resume(&mut self, app: &mut AppState) -> anyhow::Result<()>;
     fn render(&mut self, app: &mut AppState) -> anyhow::Result<()>;
     fn view(&mut self) -> Option<Arc<ImageView>>;
-    fn extent(&self) -> [u32; 3];
 }
 
 pub struct FallbackRenderer;
@@ -229,9 +226,6 @@ impl OverlayRenderer for FallbackRenderer {
     fn view(&mut self) -> Option<Arc<ImageView>> {
         None
     }
-    fn extent(&self) -> [u32; 3] {
-        [0, 0, 0]
-    }
 }
 // Boilerplate and dummies
 
@@ -274,9 +268,6 @@ impl OverlayRenderer for SplitOverlayBackend {
     fn view(&mut self) -> Option<Arc<ImageView>> {
         self.renderer.view()
     }
-    fn extent(&self) -> [u32; 3] {
-        self.renderer.extent()
-    }
 }
 impl InteractionHandler for SplitOverlayBackend {
     fn on_left(&mut self, app: &mut AppState, pointer: usize) {
@@ -292,3 +283,20 @@ impl InteractionHandler for SplitOverlayBackend {
         self.interaction.on_pointer(app, hit, pressed);
     }
 }
+
+pub fn ui_transform(extent: &[u32; 2]) -> Affine2 {
+    let center = Vec2 { x: 0.5, y: 0.5 };
+    if extent[1] > extent[0] {
+        Affine2::from_cols(
+            Vec2::X * (extent[1] as f32 / extent[0] as f32),
+            Vec2::NEG_Y,
+            center,
+        )
+    } else {
+        Affine2::from_cols(
+            Vec2::X,
+            Vec2::NEG_Y * (extent[0] as f32 / extent[1] as f32),
+            center,
+        )
+    }
+}