rework rendering backend

src/backend/openvr/lines.rs

@@ -12,9 +12,10 @@ use vulkano::image::view::ImageView;
 use vulkano::image::ImageLayout;
 
 use crate::backend::overlay::{
-    FrameTransform, OverlayData, OverlayRenderer, OverlayState, SplitOverlayBackend, Z_ORDER_LINES,
+    FrameMeta, OverlayData, OverlayRenderer, OverlayState, ShouldRender, SplitOverlayBackend,
+    Z_ORDER_LINES,
 };
-use crate::graphics::WlxGraphics;
+use crate::graphics::{CommandBuffers, WlxGraphics};
 use crate::state::AppState;
 
 use super::overlay::OpenVrOverlayData;
@@ -185,14 +186,20 @@ impl OverlayRenderer for StaticRenderer {
     fn resume(&mut self, _app: &mut AppState) -> anyhow::Result<()> {
         Ok(())
     }
-    fn render(&mut self, _app: &mut AppState) -> anyhow::Result<()> {
-        Ok(())
+    fn should_render(&mut self, _app: &mut AppState) -> anyhow::Result<ShouldRender> {
+        Ok(ShouldRender::Unable)
     }
-    fn view(&mut self) -> Option<Arc<ImageView>> {
-        Some(self.view.clone())
+    fn render(
+        &mut self,
+        _app: &mut AppState,
+        _tgt: Arc<ImageView>,
+        _buf: &mut CommandBuffers,
+        _alpha: f32,
+    ) -> anyhow::Result<bool> {
+        Ok(false)
     }
-    fn frame_transform(&mut self) -> Option<FrameTransform> {
-        Some(FrameTransform {
+    fn frame_meta(&mut self) -> Option<FrameMeta> {
+        Some(FrameMeta {
             extent: self.view.image().extent(),
             ..Default::default()
         })

src/backend/openvr/mod.rs

@@ -31,10 +31,10 @@ use crate::{
             manifest::{install_manifest, uninstall_manifest},
             overlay::OpenVrOverlayData,
         },
-        overlay::OverlayData,
+        overlay::{OverlayData, ShouldRender},
         task::{SystemTask, TaskType},
     },
-    graphics::WlxGraphics,
+    graphics::{CommandBuffers, WlxGraphics},
     overlays::{
         toast::{Toast, ToastTopic},
         watch::{watch_fade, WATCH_NAME},
@@ -321,6 +321,7 @@ pub fn openvr_run(running: Arc<AtomicBool>, show_by_default: bool) -> Result<(),
         }
 
         state.hid_provider.commit();
+        let mut buffers = CommandBuffers::default();
 
         lines.update(universe.clone(), &mut overlay_mgr, &mut state)?;
 
@@ -344,12 +345,30 @@ pub fn openvr_run(running: Arc<AtomicBool>, show_by_default: bool) -> Result<(),
 
         for o in overlays.iter_mut() {
             if o.state.want_visible {
-                o.render(&mut state)?;
+                let ShouldRender::Should = o.should_render(&mut state)? else {
+                    continue;
+                };
+                if !o.ensure_image_allocated(&mut state)? {
+                    continue;
+                }
+                o.data.image_dirty = o.render(
+                    &mut state,
+                    o.data.image_view.as_ref().unwrap().clone(),
+                    &mut buffers,
+                    1.0, // alpha is instead set using OVR API
+                )?;
             }
         }
 
         log::trace!("Rendering overlays");
 
+        if let Some(mut future) = buffers.execute_now(state.graphics.queue.clone())? {
+            if let Err(e) = future.flush() {
+                return Err(BackendError::Fatal(e.into()));
+            };
+            future.cleanup_finished();
+        }
+
         overlays
             .iter_mut()
             .for_each(|o| o.after_render(universe.clone(), &mut overlay_mgr, &state.graphics));

src/backend/openvr/overlay.rs

@@ -1,4 +1,5 @@
 use core::f32;
+use std::sync::Arc;
 
 use glam::Vec4;
 use ovr_overlay::{
@@ -6,7 +7,7 @@ use ovr_overlay::{
     pose::Matrix3x4,
     sys::{ETrackingUniverseOrigin, VRVulkanTextureData_t},
 };
-use vulkano::{Handle, VulkanObject};
+use vulkano::{image::view::ImageView, Handle, VulkanObject};
 
 use crate::{
     backend::overlay::{OverlayData, RelativeTo},
@@ -19,12 +20,13 @@ use super::helpers::Affine3AConvert;
 #[derive(Default)]
 pub(super) struct OpenVrOverlayData {
     pub(super) handle: Option<OverlayHandle>,
-    pub(super) last_image: Option<u64>,
     pub(super) visible: bool,
     pub(super) color: Vec4,
     pub(crate) width: f32,
     pub(super) override_width: bool,
     pub(super) relative_to: RelativeTo,
+    pub(super) image_view: Option<Arc<ImageView>>,
+    pub(super) image_dirty: bool,
 }
 
 impl OverlayData<OpenVrOverlayData> {
@@ -61,6 +63,20 @@ impl OverlayData<OpenVrOverlayData> {
         Ok(handle)
     }
 
+    pub(super) fn ensure_image_allocated(&mut self, app: &mut AppState) -> anyhow::Result<bool> {
+        if self.data.image_view.is_some() {
+            return Ok(true);
+        }
+        let Some(meta) = self.backend.frame_meta() else {
+            return Ok(false);
+        };
+        let image = app
+            .graphics
+            .render_texture(meta.extent[0], meta.extent[1], meta.format)?;
+        self.data.image_view = Some(ImageView::new_default(image)?);
+        Ok(true)
+    }
+
     pub(super) fn after_input(
         &mut self,
         overlay: &mut OverlayManager,
@@ -200,7 +216,7 @@ impl OverlayData<OpenVrOverlayData> {
         let effective = self.state.transform
             * self
                 .backend
-                .frame_transform()
+                .frame_meta()
                 .map(|f| f.transform)
                 .unwrap_or_default();
 
@@ -221,21 +237,17 @@ impl OverlayData<OpenVrOverlayData> {
             return;
         };
 
-        let Some(view) = self.backend.view() else {
+        let Some(view) = self.data.image_view.as_ref() else {
             log::debug!("{}: Not rendered", self.state.name);
             return;
         };
 
-        let image = view.image().clone();
-
-        let raw_image = image.handle().as_raw();
-
-        if let Some(last_image) = self.data.last_image {
-            if last_image == raw_image {
-                return;
-            }
+        if !self.data.image_dirty {
+            return;
         }
+        self.data.image_dirty = false;
 
+        let image = view.image().clone();
         let dimensions = image.extent();
         if !self.data.override_width {
             let new_width = ((dimensions[0] as f32) / (dimensions[1] as f32)).min(1.0);
@@ -246,6 +258,7 @@ impl OverlayData<OpenVrOverlayData> {
             }
         }
 
+        let raw_image = image.handle().as_raw();
         let format = image.format();
 
         let mut texture = VRVulkanTextureData_t {