refactor rendering interface, working edit overlay

wlx-overlay-s/src/overlays/screen/backend.rs

@@ -1,21 +1,20 @@
 use std::{
-    sync::{Arc, LazyLock, atomic::AtomicU64},
+    sync::{atomic::AtomicU64, Arc, LazyLock},
     time::Instant,
 };
 
-use glam::{Affine2, Vec2, vec2};
-use vulkano::image::view::ImageView;
-use wlx_capture::{WlxCapture, frame::Transform};
+use glam::{vec2, Affine2, Vec2};
+use wlx_capture::{frame::Transform, WlxCapture};
 
 use crate::{
     backend::input::{HoverResult, PointerHit, PointerMode},
-    graphics::{CommandBuffers, ExtentExt},
+    graphics::ExtentExt,
     state::AppState,
-    subsystem::hid::{MOUSE_LEFT, MOUSE_MIDDLE, MOUSE_RIGHT, WheelDelta},
-    windowing::backend::{FrameMeta, OverlayBackend, ShouldRender},
+    subsystem::hid::{WheelDelta, MOUSE_LEFT, MOUSE_MIDDLE, MOUSE_RIGHT},
+    windowing::backend::{FrameMeta, OverlayBackend, RenderResources, ShouldRender},
 };
 
-use super::capture::{ScreenPipeline, WlxCaptureIn, WlxCaptureOut, receive_callback};
+use super::capture::{receive_callback, ScreenPipeline, WlxCaptureIn, WlxCaptureOut};
 
 const CURSOR_SIZE: f32 = 16. / 1440.;
 
@@ -179,25 +178,14 @@ impl OverlayBackend for ScreenBackend {
             Ok(ShouldRender::Unable)
         }
     }
-    fn render(
-        &mut self,
-        app: &mut AppState,
-        tgt: Arc<ImageView>,
-        buf: &mut CommandBuffers,
-        alpha: f32,
-    ) -> anyhow::Result<bool> {
-        let Some(capture) = self.cur_frame.take() else {
-            return Ok(false);
-        };
+    fn render(&mut self, app: &mut AppState, rdr: &mut RenderResources) -> anyhow::Result<()> {
+        // want panic; must be some if should_render was not Unable
+        let capture = self.cur_frame.take().unwrap();
 
         // want panic; must be Some if cur_frame is also Some
-        self.pipeline
-            .as_mut()
-            .unwrap()
-            .render(&capture, app, tgt, buf, alpha)?;
-
+        self.pipeline.as_mut().unwrap().render(&capture, app, rdr)?;
         self.capture.request_new_frame();
-        Ok(true)
+        Ok(())
     }
     fn pause(&mut self, _app: &mut AppState) -> anyhow::Result<()> {
         self.capture.pause();

wlx-overlay-s/src/overlays/screen/capture.rs

@@ -7,29 +7,28 @@ use vulkano::{
     command_buffer::CommandBufferUsage,
     device::Queue,
     format::Format,
-    image::{Image, sampler::Filter, view::ImageView},
+    image::{sampler::Filter, view::ImageView, Image},
     pipeline::graphics::color_blend::AttachmentBlend,
 };
 use wgui::gfx::{
-    WGfx,
     cmd::WGfxClearMode,
     pass::WGfxPass,
     pipeline::{WGfxPipeline, WPipelineCreateInfo},
+    WGfx,
 };
 use wlx_capture::{
-    WlxCapture,
     frame::{self as wlx_frame, DrmFormat, FrameFormat, MouseMeta, Transform, WlxFrame},
+    WlxCapture,
 };
 
 use crate::{
     config::GeneralConfig,
     graphics::{
-        CommandBuffers, Vert2Uv,
-        dmabuf::{WGfxDmabuf, fourcc_to_vk},
-        upload_quad_vertices,
+        dmabuf::{fourcc_to_vk, WGfxDmabuf},
+        upload_quad_vertices, Vert2Uv,
     },
     state::AppState,
-    windowing::backend::FrameMeta,
+    windowing::backend::{FrameMeta, RenderResources},
 };
 
 const CURSOR_SIZE: f32 = 16. / 1440.;
@@ -147,20 +146,14 @@ impl ScreenPipeline {
         &mut self,
         capture: &WlxCaptureOut,
         app: &mut AppState,
-        tgt: Arc<ImageView>,
-        buf: &mut CommandBuffers,
-        alpha: f32,
+        rdr: &mut RenderResources,
     ) -> anyhow::Result<()> {
         let view = ImageView::new_default(capture.image.clone())?;
 
         self.pass.update_sampler(0, view, app.gfx.texture_filter)?;
-        self.buf_alpha.write()?[0] = alpha;
+        self.buf_alpha.write()?[0] = rdr.alpha;
 
-        let mut cmd = app
-            .gfx
-            .create_gfx_command_buffer(CommandBufferUsage::OneTimeSubmit)?;
-        cmd.begin_rendering(tgt, WGfxClearMode::DontCare)?;
-        cmd.run_ref(&self.pass)?;
+        rdr.cmd_buf.run_ref(&self.pass)?;
 
         if let Some(mouse) = capture.mouse.as_ref() {
             let size = CURSOR_SIZE * self.extentf[1];
@@ -176,11 +169,9 @@ impl ScreenPipeline {
                 size,
             )?;
 
-            cmd.run_ref(&self.mouse.pass)?;
+            rdr.cmd_buf.run_ref(&self.mouse.pass)?;
         }
 
-        cmd.end_rendering()?;
-        buf.push(cmd.build()?);
         Ok(())
     }
 }
@@ -217,6 +208,7 @@ pub struct WlxCaptureOut {
 impl WlxCaptureOut {
     pub(super) fn get_frame_meta(&self, config: &GeneralConfig) -> FrameMeta {
         FrameMeta {
+            clear: WGfxClearMode::DontCare,
             extent: extent_from_format(self.format, config),
             transform: affine_from_format(&self.format),
             format: self.image.format(),