diff --git a/wgui/src/gfx/cmd.rs b/wgui/src/gfx/cmd.rs index 745ddb3..77ce322 100644 --- a/wgui/src/gfx/cmd.rs +++ b/wgui/src/gfx/cmd.rs @@ -1,7 +1,6 @@ use std::{marker::PhantomData, sync::Arc}; use vulkano::{ - DeviceSize, buffer::{Buffer, BufferCreateInfo, BufferUsage, Subbuffer}, command_buffer::{ AutoCommandBufferBuilder, ClearColorImageInfo, CommandBufferExecFuture, CopyBufferToImageInfo, CopyImageInfo, @@ -9,13 +8,14 @@ use vulkano::{ }, device::Queue, format::{ClearColorValue, ClearValue, Format}, - image::{Image, ImageCreateInfo, ImageType, ImageUsage, view::ImageView}, + image::{view::ImageView, Image, ImageCreateInfo, ImageType, ImageUsage}, memory::allocator::{AllocationCreateInfo, MemoryTypeFilter}, render_pass::{AttachmentLoadOp, AttachmentStoreOp}, - sync::{GpuFuture, future::NowFuture}, + sync::{future::NowFuture, GpuFuture}, + DeviceSize, }; -use super::{WGfx, pass::WGfxPass}; +use super::{pass::WGfxPass, WGfx}; pub type GfxCommandBuffer = WCommandBuffer; pub type XferCommandBuffer = WCommandBuffer; @@ -44,13 +44,24 @@ impl WCommandBuffer { } } -#[derive(Clone, Copy)] +#[derive(Default, Clone, Copy)] pub enum WGfxClearMode { - Keep, + #[default] DontCare, + Keep, Clear([f32; 4]), } +#[allow(dead_code)] +impl WGfxClearMode { + pub fn or_default(self, def: WGfxClearMode) -> WGfxClearMode { + match self { + Self::DontCare => def, + s => s, + } + } +} + impl WCommandBuffer { pub fn begin_rendering(&mut self, render_target: Arc, clear_mode: WGfxClearMode) -> anyhow::Result<()> { self.command_buffer.begin_rendering(RenderingInfo { diff --git a/wlx-overlay-s/src/assets/gui/adjust.xml b/wlx-overlay-s/src/assets/gui/edit.xml similarity index 98% rename from wlx-overlay-s/src/assets/gui/adjust.xml rename to wlx-overlay-s/src/assets/gui/edit.xml index 4845e57..2b8420b 100644 --- a/wlx-overlay-s/src/assets/gui/adjust.xml +++ b/wlx-overlay-s/src/assets/gui/edit.xml @@ -15,7 +15,7 @@ border_color="#0044CC" border="2" round="8" color="#000A1C" color2="#000002" gradient="vertical" /> -
+
diff --git a/wlx-overlay-s/src/assets/gui/toolbox.xml b/wlx-overlay-s/src/assets/gui/toolbox.xml new file mode 100644 index 0000000..49568fa --- /dev/null +++ b/wlx-overlay-s/src/assets/gui/toolbox.xml @@ -0,0 +1,35 @@ + + + + + + + + + + +
+ + +
+ + diff --git a/wlx-overlay-s/src/backend/openvr/lines.rs b/wlx-overlay-s/src/backend/openvr/lines.rs index a381b6e..46147f4 100644 --- a/wlx-overlay-s/src/backend/openvr/lines.rs +++ b/wlx-overlay-s/src/backend/openvr/lines.rs @@ -1,6 +1,6 @@ use std::f32::consts::PI; -use std::sync::Arc; use std::sync::atomic::{AtomicUsize, Ordering}; +use std::sync::Arc; use ash::vk::SubmitInfo; use glam::{Affine3A, Vec3, Vec3A, Vec4}; @@ -8,7 +8,6 @@ use idmap::IdMap; use ovr_overlay::overlay::OverlayManager; use ovr_overlay::sys::ETrackingUniverseOrigin; use vulkano::{ - VulkanObject, command_buffer::{ CommandBufferBeginInfo, CommandBufferLevel, CommandBufferUsage, RecordingCommandBuffer, }, @@ -16,19 +15,19 @@ use vulkano::{ image::view::ImageView, image::{Image, ImageLayout}, sync::{ - AccessFlags, DependencyInfo, ImageMemoryBarrier, PipelineStages, fence::{Fence, FenceCreateInfo}, + AccessFlags, DependencyInfo, ImageMemoryBarrier, PipelineStages, }, + VulkanObject, }; use wgui::gfx::WGfx; use crate::backend::input::{HoverResult, PointerHit}; -use crate::graphics::CommandBuffers; use crate::state::AppState; use crate::subsystem::hid::WheelDelta; -use crate::windowing::Z_ORDER_LINES; -use crate::windowing::backend::{FrameMeta, OverlayBackend, ShouldRender}; +use crate::windowing::backend::{FrameMeta, OverlayBackend, RenderResources, ShouldRender}; use crate::windowing::window::{OverlayWindowConfig, OverlayWindowData}; +use crate::windowing::Z_ORDER_LINES; use super::overlay::OpenVrOverlayData; @@ -189,14 +188,8 @@ impl OverlayBackend for LineBackend { fn should_render(&mut self, _: &mut AppState) -> anyhow::Result { Ok(ShouldRender::Unable) } - fn render( - &mut self, - _: &mut AppState, - _: Arc, - _: &mut CommandBuffers, - _: f32, - ) -> anyhow::Result { - Ok(false) + fn render(&mut self, _: &mut AppState, _: &mut RenderResources) -> anyhow::Result<()> { + unreachable!() } fn frame_meta(&mut self) -> Option { Some(FrameMeta { diff --git a/wlx-overlay-s/src/backend/openvr/mod.rs b/wlx-overlay-s/src/backend/openvr/mod.rs index 91bb56f..55bbae9 100644 --- a/wlx-overlay-s/src/backend/openvr/mod.rs +++ b/wlx-overlay-s/src/backend/openvr/mod.rs @@ -29,14 +29,18 @@ use crate::{ BackendError, }, config::save_state, - graphics::{init_openvr_graphics, CommandBuffers}, + graphics::{init_openvr_graphics, GpuFutures}, overlays::{ toast::{Toast, ToastTopic}, watch::{watch_fade, WATCH_NAME}, }, state::AppState, subsystem::notifications::NotificationManager, - windowing::{backend::ShouldRender, manager::OverlayWindowManager, window::OverlayWindowData}, + windowing::{ + backend::{RenderResources, ShouldRender}, + manager::OverlayWindowManager, + window::OverlayWindowData, + }, }; #[cfg(feature = "wayvr")] @@ -311,7 +315,7 @@ pub fn openvr_run( } app.hid_provider.inner.commit(); - let mut buffers = CommandBuffers::default(); + let mut futures = GpuFutures::default(); lines.update(universe.clone(), &mut overlay_mgr, &mut app)?; @@ -338,26 +342,17 @@ pub fn openvr_run( let ShouldRender::Should = o.should_render(&mut app)? else { continue; }; - if !o.ensure_image_allocated(&mut app)? { - continue; - } - o.data.image_dirty = o.render( - &mut app, - o.data.image_view.as_ref().unwrap().clone(), - &mut buffers, - 1.0, // alpha is instead set using OVR API - )?; + let meta = o.config.backend.frame_meta().unwrap(); + let tgt = o.ensure_staging_image(&mut app, meta.extent)?; + let mut rdr = RenderResources::new(app.gfx.clone(), tgt, &meta, 1.0)?; + o.render(&mut app, &mut rdr)?; + o.data.image_dirty = true; + futures.execute(rdr.end()?)?; } } log::trace!("Rendering overlays"); - - if let Some(mut future) = buffers.execute_now(app.gfx.queue_gfx.clone())? { - if let Err(e) = future.flush() { - return Err(BackendError::Fatal(e.into())); - } - future.cleanup_finished(); - } + futures.wait()?; overlays .values_mut() diff --git a/wlx-overlay-s/src/backend/openvr/overlay.rs b/wlx-overlay-s/src/backend/openvr/overlay.rs index 2f8e8a7..850e654 100644 --- a/wlx-overlay-s/src/backend/openvr/overlay.rs +++ b/wlx-overlay-s/src/backend/openvr/overlay.rs @@ -62,21 +62,33 @@ impl OverlayWindowData { Ok(handle) } - pub(super) fn ensure_image_allocated(&mut self, app: &mut AppState) -> anyhow::Result { - if self.data.image_view.is_some() { - return Ok(true); + pub(super) fn ensure_staging_image( + &mut self, + app: &mut AppState, + extent: [u32; 3], + ) -> anyhow::Result> { + if let Some(image_view) = self.data.image_view.as_ref() + && image_view.image().extent() == extent + { + return Ok(image_view.clone()); } - let Some(meta) = self.config.backend.frame_meta() else { - return Ok(false); - }; + + log::debug!( + "{}: recreating staging image at {}x{}", + self.config.name, + extent[0], + extent[1], + ); + let image = app.gfx.new_image( - meta.extent[0], - meta.extent[1], + extent[0], + extent[1], app.gfx.surface_format, ImageUsage::TRANSFER_SRC | ImageUsage::COLOR_ATTACHMENT | ImageUsage::SAMPLED, )?; - self.data.image_view = Some(ImageView::new_default(image)?); - Ok(true) + let image_view = ImageView::new_default(image)?; + self.data.image_view = Some(image_view.clone()); + Ok(image_view) } pub(super) fn after_input( diff --git a/wlx-overlay-s/src/backend/openxr/lines.rs b/wlx-overlay-s/src/backend/openxr/lines.rs index 8f8da63..221b06b 100644 --- a/wlx-overlay-s/src/backend/openxr/lines.rs +++ b/wlx-overlay-s/src/backend/openxr/lines.rs @@ -18,7 +18,7 @@ use wgui::gfx::{ use crate::{ backend::openxr::helpers, - graphics::{CommandBuffers, Vert2Uv}, + graphics::{GpuFutures, Vert2Uv}, state::AppState, }; use vulkano::{ @@ -152,7 +152,7 @@ impl LinePool { pub(super) fn render( &mut self, app: &AppState, - buf: &mut CommandBuffers, + futures: &mut GpuFutures, ) -> anyhow::Result<()> { for line in self.lines.values_mut() { if let Some(inner) = line.maybe_line.as_mut() { @@ -167,7 +167,7 @@ impl LinePool { cmd_buffer.run_ref(&self.pass)?; cmd_buffer.end_rendering()?; - buf.push(cmd_buffer.build()?); + futures.execute((cmd_buffer.queue.clone(), cmd_buffer.build()?))?; } } diff --git a/wlx-overlay-s/src/backend/openxr/mod.rs b/wlx-overlay-s/src/backend/openxr/mod.rs index 3774401..fa7609f 100644 --- a/wlx-overlay-s/src/backend/openxr/mod.rs +++ b/wlx-overlay-s/src/backend/openxr/mod.rs @@ -23,14 +23,18 @@ use crate::{ BackendError, }, config::save_state, - graphics::{init_openxr_graphics, CommandBuffers}, + graphics::{init_openxr_graphics, GpuFutures}, overlays::{ toast::{Toast, ToastTopic}, watch::{watch_fade, WATCH_NAME}, }, state::AppState, subsystem::notifications::NotificationManager, - windowing::{backend::ShouldRender, manager::OverlayWindowManager, window::OverlayWindowData}, + windowing::{ + backend::{RenderResources, ShouldRender}, + manager::OverlayWindowManager, + window::OverlayWindowData, + }, }; #[cfg(feature = "wayvr")] @@ -378,10 +382,10 @@ pub fn openxr_run( } // Begin rendering - let mut buffers = CommandBuffers::default(); + let mut futures = GpuFutures::default(); if !main_session_visible && let Some(skybox) = skybox.as_mut() { - skybox.render(&xr_state, &app, &mut buffers)?; + skybox.render(&xr_state, &app, &mut futures)?; } for o in overlays.values_mut() { @@ -402,30 +406,20 @@ pub fn openxr_run( }; if should_render { - if !o.ensure_swapchain(&app, &xr_state)? { - continue; - } - let tgt = o.data.swapchain.as_mut().unwrap().acquire_wait_image()?; // want - if !o.render(&mut app, tgt, &mut buffers, alpha)? { - o.data.swapchain.as_mut().unwrap().ensure_image_released()?; // want - continue; - } + let meta = o.config.backend.frame_meta().unwrap(); // want panic + let tgt = o.ensure_swapchain_acquire(&app, &xr_state, meta.extent)?; + let mut rdr = RenderResources::new(app.gfx.clone(), tgt, &meta, alpha)?; + o.render(&mut app, &mut rdr)?; o.data.last_alpha = alpha; + futures.execute(rdr.end()?)?; } else if o.data.swapchain.is_none() { continue; } o.data.cur_visible = true; } - lines.render(&app, &mut buffers)?; - - let future = buffers.execute_now(app.gfx.queue_gfx.clone())?; - if let Some(mut future) = future { - if let Err(e) = future.flush() { - return Err(BackendError::Fatal(e.into())); - } - future.cleanup_finished(); - } + lines.render(&app, &mut futures)?; + futures.wait()?; // End rendering // Layer composition diff --git a/wlx-overlay-s/src/backend/openxr/overlay.rs b/wlx-overlay-s/src/backend/openxr/overlay.rs index a99ea7d..cb42535 100644 --- a/wlx-overlay-s/src/backend/openxr/overlay.rs +++ b/wlx-overlay-s/src/backend/openxr/overlay.rs @@ -1,11 +1,12 @@ use glam::Vec3A; use openxr::{self as xr, CompositionLayerFlags}; -use std::f32::consts::PI; +use std::{f32::consts::PI, sync::Arc}; +use vulkano::image::view::ImageView; use xr::EyeVisibility; -use super::{CompositionLayer, XrState, helpers, swapchain::WlxSwapchain}; +use super::{helpers, swapchain::WlxSwapchain, CompositionLayer, XrState}; use crate::{ - backend::openxr::swapchain::{SwapchainOpts, create_swapchain}, + backend::openxr::swapchain::{create_swapchain, SwapchainOpts}, state::AppState, windowing::window::OverlayWindowData, }; @@ -20,41 +21,28 @@ pub struct OpenXrOverlayData { } impl OverlayWindowData { - pub(super) fn ensure_swapchain<'a>( + pub(super) fn ensure_swapchain_acquire<'a>( &'a mut self, app: &AppState, xr: &'a XrState, - ) -> anyhow::Result { - let Some(meta) = self.frame_meta() else { - log::warn!( - "{}: swapchain cannot be created due to missing metadata", - self.config.name - ); - return Ok(false); - }; - - if self - .data - .swapchain - .as_ref() - .is_some_and(|s| s.extent == meta.extent) + extent: [u32; 3], + ) -> anyhow::Result> { + if let Some(swapchain) = self.data.swapchain.as_mut() + && swapchain.extent == extent { - return Ok(true); + return Ok(swapchain.acquire_wait_image()?); } log::debug!( "{}: recreating swapchain at {}x{}", self.config.name, - meta.extent[0], - meta.extent[1], + extent[0], + extent[1], ); - self.data.swapchain = Some(create_swapchain( - xr, - app.gfx.clone(), - meta.extent, - SwapchainOpts::new(), - )?); - Ok(true) + let mut swapchain = create_swapchain(xr, app.gfx.clone(), extent, SwapchainOpts::new())?; + let tgt = swapchain.acquire_wait_image()?; + self.data.swapchain = Some(swapchain); + Ok(tgt) } pub(super) fn present<'a>( diff --git a/wlx-overlay-s/src/backend/openxr/skybox.rs b/wlx-overlay-s/src/backend/openxr/skybox.rs index 1c59ff2..05ca8a3 100644 --- a/wlx-overlay-s/src/backend/openxr/skybox.rs +++ b/wlx-overlay-s/src/backend/openxr/skybox.rs @@ -15,7 +15,7 @@ use wgui::gfx::{cmd::WGfxClearMode, pipeline::WPipelineCreateInfo}; use crate::{ backend::openxr::{helpers::translation_rotation_to_posef, swapchain::SwapchainOpts}, config_io, - graphics::{dds::WlxCommandBufferDds, CommandBuffers, ExtentExt}, + graphics::{dds::WlxCommandBufferDds, ExtentExt, GpuFutures}, state::AppState, }; @@ -85,7 +85,7 @@ impl Skybox { &'a mut self, xr: &'a XrState, app: &AppState, - buf: &mut CommandBuffers, + futures: &mut GpuFutures, ) -> anyhow::Result<()> { if self.sky.is_some() { return Ok(()); @@ -119,7 +119,7 @@ impl Skybox { cmd_buffer.run_ref(&pass)?; cmd_buffer.end_rendering()?; - buf.push(cmd_buffer.build()?); + futures.execute((cmd_buffer.queue.clone(), cmd_buffer.build()?))?; self.sky = Some(swapchain); Ok(()) @@ -129,7 +129,7 @@ impl Skybox { &'a mut self, xr: &'a XrState, app: &AppState, - buf: &mut CommandBuffers, + futures: &mut GpuFutures, ) -> anyhow::Result<()> { if self.grid.is_some() { return Ok(()); @@ -165,7 +165,7 @@ impl Skybox { cmd_buffer.run_ref(&pass)?; cmd_buffer.end_rendering()?; - buf.push(cmd_buffer.build()?); + futures.execute((cmd_buffer.queue.clone(), cmd_buffer.build()?))?; self.grid = Some(swapchain); Ok(()) @@ -175,7 +175,7 @@ impl Skybox { &mut self, xr: &XrState, app: &AppState, - buf: &mut CommandBuffers, + buf: &mut GpuFutures, ) -> anyhow::Result<()> { self.prepare_sky(xr, app, buf)?; self.prepare_grid(xr, app, buf)?; diff --git a/wlx-overlay-s/src/graphics/mod.rs b/wlx-overlay-s/src/graphics/mod.rs index 33ea94c..f9f86a7 100644 --- a/wlx-overlay-s/src/graphics/mod.rs +++ b/wlx-overlay-s/src/graphics/mod.rs @@ -636,28 +636,32 @@ fn queue_families_priorities( } #[derive(Default)] -pub struct CommandBuffers { - inner: Vec>, +pub struct GpuFutures { + futures: Vec>, } -impl CommandBuffers { - pub fn push(&mut self, buffer: Arc) { - self.inner.push(buffer); +impl GpuFutures { + pub fn execute( + &mut self, + cmd: (Arc, Arc), + ) -> anyhow::Result<()> { + self.futures.push(cmd.1.execute(cmd.0)?.boxed()); + + Ok(()) } - pub fn execute_now(self, queue: Arc) -> anyhow::Result>> { - let mut buffers = self.inner.into_iter(); - let Some(first) = buffers.next() else { - return Ok(None); + pub fn wait(self) -> anyhow::Result<()> { + let mut it = self.futures.into_iter(); + let Some(mut all) = it.next() else { + return Ok(()); }; - - let future = first.execute(queue)?; - let mut future: Box = Box::new(future); - - for buf in buffers { - future = Box::new(future.then_execute_same_queue(buf)?); + for f in it { + all = all.join(f).boxed(); } - Ok(Some(future)) + let finished = all.then_signal_fence_and_flush()?; + finished.wait(None)?; + + Ok(()) } } diff --git a/wlx-overlay-s/src/gui/panel/mod.rs b/wlx-overlay-s/src/gui/panel/mod.rs index e8e062b..a6f0c8a 100644 --- a/wlx-overlay-s/src/gui/panel/mod.rs +++ b/wlx-overlay-s/src/gui/panel/mod.rs @@ -1,9 +1,8 @@ -use std::{cell::RefCell, rc::Rc, sync::Arc}; +use std::{cell::RefCell, rc::Rc}; use button::setup_custom_button; -use glam::{Affine2, Vec2, vec2}; +use glam::{vec2, Affine2, Vec2}; use label::setup_custom_label; -use vulkano::{command_buffer::CommandBufferUsage, image::view::ImageView}; use wgui::{ assets::AssetPath, drawing, @@ -16,15 +15,14 @@ use wgui::{ layout::{Layout, LayoutParams, WidgetID}, parser::ParserState, renderer_vk::context::Context as WguiContext, - widget::{EventResult, label::WidgetLabel, rectangle::WidgetRectangle}, + widget::{label::WidgetLabel, rectangle::WidgetRectangle, EventResult}, }; use crate::{ backend::input::{Haptics, HoverResult, PointerHit, PointerMode}, - graphics::{CommandBuffers, ExtentExt}, state::AppState, subsystem::hid::WheelDelta, - windowing::backend::{FrameMeta, OverlayBackend, ShouldRender, ui_transform}, + windowing::backend::{ui_transform, FrameMeta, OverlayBackend, RenderResources, ShouldRender}, }; use super::{timer::GuiTimer, timestep::Timestep}; @@ -222,31 +220,11 @@ impl OverlayBackend for GuiPanel { }) } - fn render( - &mut self, - app: &mut AppState, - tgt: Arc, - buf: &mut CommandBuffers, - mut alpha: f32, - ) -> anyhow::Result { + fn render(&mut self, app: &mut AppState, rdr: &mut RenderResources) -> anyhow::Result<()> { self.context - .update_viewport(&mut app.wgui_shared, tgt.extent_u32arr(), 1.0)?; + .update_viewport(&mut app.wgui_shared, rdr.extent, 1.0)?; self.layout.update(self.max_size, self.timestep.alpha)?; - // FIXME: pass this properly - let mut clear = WGfxClearMode::Clear([0., 0., 0., 0.]); - if alpha < 0. { - alpha *= -1.; - clear = WGfxClearMode::Keep; - } - - let mut cmd_buf = app - .gfx - .create_gfx_command_buffer(CommandBufferUsage::OneTimeSubmit) - .unwrap(); // want panic - - cmd_buf.begin_rendering(tgt, clear)?; - let globals = self.layout.state.globals.clone(); // sorry let mut globals = globals.get(); @@ -254,22 +232,20 @@ impl OverlayBackend for GuiPanel { globals: &mut globals, layout: &mut self.layout, debug_draw: false, - alpha, + alpha: rdr.alpha, })?; self.context.draw( &globals.font_system, &mut app.wgui_shared, - &mut cmd_buf, + &mut rdr.cmd_buf, &primitives, )?; - cmd_buf.end_rendering()?; - buf.push(cmd_buf.build()?); - - Ok(true) + Ok(()) } fn frame_meta(&mut self) -> Option { Some(FrameMeta { + clear: WGfxClearMode::Clear([0., 0., 0., 0.]), extent: [ self.max_size.x.min(self.layout.content_size.x) as _, self.max_size.y.min(self.layout.content_size.y) as _, diff --git a/wlx-overlay-s/src/overlays/adjust.rs b/wlx-overlay-s/src/overlays/edit.rs similarity index 72% rename from wlx-overlay-s/src/overlays/adjust.rs rename to wlx-overlay-s/src/overlays/edit.rs index e060c9c..ead131a 100644 --- a/wlx-overlay-s/src/overlays/adjust.rs +++ b/wlx-overlay-s/src/overlays/edit.rs @@ -5,14 +5,14 @@ use std::{ }; use glam::vec2; -use vulkano::image::{view::ImageView, ImageUsage}; use crate::{ backend::input::HoverResult, gui::panel::GuiPanel, state::AppState, + subsystem::hid::WheelDelta, windowing::{ - backend::{DummyBackend, OverlayBackend, ShouldRender}, + backend::{DummyBackend, OverlayBackend, RenderResources, ShouldRender}, window::OverlayWindowConfig, }, }; @@ -38,15 +38,13 @@ impl EditModeManager { let inner = mem::replace(&mut owc.backend, Box::new(DummyBackend {})); let mut panel = self.panel_pool.pop(); if panel.is_none() { - panel = Some(make_adjustment_panel(app)?); + panel = Some(make_edit_panel(app)?); } let mut panel = panel.unwrap(); panel.state = owc.name.clone(); owc.backend = Box::new(EditModeBackendWrapper { inner: ManuallyDrop::new(inner), panel: ManuallyDrop::new(panel), - can_render_inner: false, - image: None, }); owc.editing = true; @@ -79,8 +77,6 @@ impl EditModeManager { pub struct EditModeBackendWrapper { panel: ManuallyDrop, inner: ManuallyDrop>, - image: Option>, - can_render_inner: bool, } impl OverlayBackend for EditModeBackendWrapper { @@ -99,8 +95,7 @@ impl OverlayBackend for EditModeBackendWrapper { fn should_render(&mut self, app: &mut crate::state::AppState) -> anyhow::Result { let i = self.inner.should_render(app)?; - self.can_render_inner = !matches!(i, ShouldRender::Unable); - if self.can_render_inner + if !matches!(i, ShouldRender::Unable) && let Some(ref frame_meta) = self.inner.frame_meta() { let new_size = vec2(frame_meta.extent[0] as _, frame_meta.extent[1] as _); @@ -109,6 +104,8 @@ impl OverlayBackend for EditModeBackendWrapper { self.panel.max_size = new_size; self.panel.update_layout()?; } + } else { + return Ok(ShouldRender::Unable); } let p = self.panel.should_render(app)?; @@ -118,39 +115,19 @@ impl OverlayBackend for EditModeBackendWrapper { (ShouldRender::Should, ShouldRender::Can) => ShouldRender::Should, (ShouldRender::Can, ShouldRender::Should) => ShouldRender::Should, (ShouldRender::Can, ShouldRender::Can) => ShouldRender::Can, - // (ShouldRender::Unable, ShouldRender::Should) if self.image.is_some() => { - // ShouldRender::Should - // } - // (ShouldRender::Unable, ShouldRender::Can) if self.image.is_some() => ShouldRender::Can, _ => ShouldRender::Unable, }) } fn render( &mut self, app: &mut crate::state::AppState, - tgt: std::sync::Arc, - buf: &mut crate::graphics::CommandBuffers, - alpha: f32, - ) -> anyhow::Result { - if self.can_render_inner { - if self.image.is_none() - && let Some(ref meta) = self.inner.frame_meta() - { - let image = app.gfx.new_image( - meta.extent[0], - meta.extent[1], - app.gfx.surface_format, - ImageUsage::COLOR_ATTACHMENT | ImageUsage::SAMPLED, - )?; - self.image = Some(ImageView::new_default(image)?); - } - self.inner.render(app, tgt.clone(), buf, alpha)?; - } - - self.panel.render(app, tgt, buf, -1.) + rdr: &mut RenderResources, + ) -> anyhow::Result<()> { + self.inner.render(app, rdr)?; + self.panel.render(app, rdr) } fn frame_meta(&mut self) -> Option { - self.inner.frame_meta().or_else(|| self.panel.frame_meta()) + self.inner.frame_meta() } fn on_hover( &mut self, @@ -177,19 +154,17 @@ impl OverlayBackend for EditModeBackendWrapper { &mut self, app: &mut crate::state::AppState, hit: &crate::backend::input::PointerHit, - delta_y: f32, - delta_x: f32, + delta: WheelDelta, ) { - self.panel.on_scroll(app, hit, delta_y, delta_x); + self.panel.on_scroll(app, hit, delta); } fn get_interaction_transform(&mut self) -> Option { self.inner.get_interaction_transform() } } -fn make_adjustment_panel(app: &mut AppState) -> anyhow::Result { - let mut panel = GuiPanel::new_from_template(app, "gui/adjust.xml", "".into(), None, true)?; - panel.update_layout()?; +fn make_edit_panel(app: &mut AppState) -> anyhow::Result { + let panel = GuiPanel::new_from_template(app, "gui/edit.xml", "".into(), None, true)?; Ok(panel) } diff --git a/wlx-overlay-s/src/overlays/keyboard/builder.rs b/wlx-overlay-s/src/overlays/keyboard/builder.rs index 0123d3f..9773e09 100644 --- a/wlx-overlay-s/src/overlays/keyboard/builder.rs +++ b/wlx-overlay-s/src/overlays/keyboard/builder.rs @@ -9,7 +9,7 @@ use wgui::{ layout::LayoutParams, parser::Fetchable, renderer_vk::util, - taffy::{self, prelude::length, BoxSizing}, + taffy::{self, prelude::length}, widget::{ div::WidgetDiv, rectangle::{WidgetRectangle, WidgetRectangleParams}, diff --git a/wlx-overlay-s/src/overlays/keyboard/mod.rs b/wlx-overlay-s/src/overlays/keyboard/mod.rs index 9bd50e2..9bdc7f0 100644 --- a/wlx-overlay-s/src/overlays/keyboard/mod.rs +++ b/wlx-overlay-s/src/overlays/keyboard/mod.rs @@ -1,10 +1,8 @@ use std::{ cell::Cell, process::{Child, Command}, - sync::Arc, }; -use vulkano::image::view::ImageView; use wgui::{ drawing, event::{InternalStateChangeEvent, MouseButton, MouseButtonIndex}, @@ -12,11 +10,10 @@ use wgui::{ use crate::{ backend::input::{HoverResult, PointerHit}, - graphics::CommandBuffers, gui::panel::GuiPanel, state::AppState, - subsystem::hid::{ALT, CTRL, KeyModifier, META, SHIFT, SUPER, VirtualKey, WheelDelta}, - windowing::backend::{FrameMeta, OverlayBackend, ShouldRender}, + subsystem::hid::{KeyModifier, VirtualKey, WheelDelta, ALT, CTRL, META, SHIFT, SUPER}, + windowing::backend::{FrameMeta, OverlayBackend, RenderResources, ShouldRender}, }; pub mod builder; @@ -36,14 +33,8 @@ impl OverlayBackend for KeyboardBackend { fn should_render(&mut self, app: &mut AppState) -> anyhow::Result { self.panel.should_render(app) } - fn render( - &mut self, - app: &mut AppState, - tgt: Arc, - buf: &mut CommandBuffers, - alpha: f32, - ) -> anyhow::Result { - self.panel.render(app, tgt, buf, alpha) + fn render(&mut self, app: &mut AppState, rdr: &mut RenderResources) -> anyhow::Result<()> { + self.panel.render(app, rdr) } fn frame_meta(&mut self) -> Option { self.panel.frame_meta() diff --git a/wlx-overlay-s/src/overlays/mirror.rs b/wlx-overlay-s/src/overlays/mirror.rs index 2e4ec07..5d15aa5 100644 --- a/wlx-overlay-s/src/overlays/mirror.rs +++ b/wlx-overlay-s/src/overlays/mirror.rs @@ -5,21 +5,19 @@ use std::{ use futures::{Future, FutureExt}; use glam::{Affine2, Affine3A, Vec3}; -use vulkano::image::view::ImageView; -use wlx_capture::pipewire::{PipewireCapture, PipewireSelectScreenResult, pipewire_select_screen}; +use wlx_capture::pipewire::{pipewire_select_screen, PipewireCapture, PipewireSelectScreenResult}; use crate::{ backend::{ input::{HoverResult, PointerHit}, task::TaskType, }, - graphics::CommandBuffers, state::{AppSession, AppState}, subsystem::hid::WheelDelta, windowing::{ - OverlaySelector, - backend::{FrameMeta, OverlayBackend, ShouldRender, ui_transform}, + backend::{ui_transform, FrameMeta, OverlayBackend, RenderResources, ShouldRender}, window::{OverlayWindowConfig, OverlayWindowState}, + OverlaySelector, }, }; @@ -93,26 +91,21 @@ impl OverlayBackend for MirrorBackend { .as_mut() .map_or(Ok(ShouldRender::Unable), |r| r.should_render(app)) } - fn render( - &mut self, - app: &mut AppState, - tgt: Arc, - buf: &mut CommandBuffers, - alpha: f32, - ) -> anyhow::Result { - let mut result = false; - if let Some(renderer) = self.renderer.as_mut() { - result = renderer.render(app, tgt, buf, alpha)?; - if let Some(meta) = renderer.frame_meta() { - let extent = meta.extent; - if self.last_extent != extent { - self.last_extent = extent; - self.interaction_transform = Some(ui_transform([extent[0], extent[1]])); - } + fn render(&mut self, app: &mut AppState, rdr: &mut RenderResources) -> anyhow::Result<()> { + let Some(renderer) = self.renderer.as_mut() else { + anyhow::bail!("render failed after should_render passed"); + }; + + renderer.render(app, rdr)?; + if let Some(meta) = renderer.frame_meta() { + let extent = meta.extent; + if self.last_extent != extent { + self.last_extent = extent; + self.interaction_transform = Some(ui_transform([extent[0], extent[1]])); } } - Ok(result) + Ok(()) } fn pause(&mut self, app: &mut AppState) -> anyhow::Result<()> { if let Some(renderer) = self.renderer.as_mut() { diff --git a/wlx-overlay-s/src/overlays/mod.rs b/wlx-overlay-s/src/overlays/mod.rs index c5ee319..0be5447 100644 --- a/wlx-overlay-s/src/overlays/mod.rs +++ b/wlx-overlay-s/src/overlays/mod.rs @@ -1,8 +1,7 @@ -pub mod adjust; pub mod anchor; pub mod bar; pub mod custom; -//pub mod edit; +pub mod edit; pub mod keyboard; #[cfg(feature = "wayland")] pub mod mirror; diff --git a/wlx-overlay-s/src/overlays/screen/backend.rs b/wlx-overlay-s/src/overlays/screen/backend.rs index dbcc21c..30c7175 100644 --- a/wlx-overlay-s/src/overlays/screen/backend.rs +++ b/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, - buf: &mut CommandBuffers, - alpha: f32, - ) -> anyhow::Result { - 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(); diff --git a/wlx-overlay-s/src/overlays/screen/capture.rs b/wlx-overlay-s/src/overlays/screen/capture.rs index 103d81f..5165ca4 100644 --- a/wlx-overlay-s/src/overlays/screen/capture.rs +++ b/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, - 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(), diff --git a/wlx-overlay-s/src/overlays/toolbox.rs b/wlx-overlay-s/src/overlays/toolbox.rs new file mode 100644 index 0000000..724a814 --- /dev/null +++ b/wlx-overlay-s/src/overlays/toolbox.rs @@ -0,0 +1,80 @@ +use std::time::Duration; + +use glam::{Affine3A, Vec3}; + +use crate::{ + gui::{panel::GuiPanel, timer::GuiTimer}, + state::AppState, + windowing::{ + window::{OverlayWindowConfig, OverlayWindowState, Positioning}, + Z_ORDER_WATCH, + }, +}; + +pub const EDIT_NAME: &str = "edit"; + +struct EditState { + num_sets: usize, + current_set: usize, +} + +#[allow(clippy::significant_drop_tightening)] +pub fn create_edit( + app: &mut AppState, + num_sets: usize, + current_set: usize, +) -> anyhow::Result { + let state = EditState { + num_sets, + current_set, + }; + let mut panel = GuiPanel::new_from_template( + app, + "gui/watch.xml", + state, + Some(Box::new( + move |id, widget, doc_params, layout, parser_state| { + if &*id != "sets" { + return Ok(()); + } + + for idx in 0..num_sets { + let mut params: HashMap, Rc> = HashMap::new(); + params.insert("display".into(), (idx + 1).to_string().into()); + params.insert("handle".into(), idx.to_string().into()); + parser_state.instantiate_template(doc_params, "Set", layout, widget, params)?; + } + Ok(()) + }, + )), + )?; + + panel + .timers + .push(GuiTimer::new(Duration::from_millis(100), 0)); + + let positioning = Positioning::FollowHand { + hand: app.session.config.watch_hand as _, + lerp: 1.0, + }; + + panel.update_layout()?; + + Ok(OverlayWindowConfig { + name: EDIT_NAME.into(), + z_order: Z_ORDER_WATCH, + default_state: OverlayWindowState { + interactable: true, + positioning, + transform: Affine3A::from_scale_rotation_translation( + Vec3::ONE * 0.115, + app.session.config.watch_rot, + app.session.config.watch_pos, + ) * Affine3A::from_translation(Vec3::Y * 0.075), + ..OverlayWindowState::default() + }, + show_on_spawn: true, + global: true, + ..OverlayWindowConfig::from_backend(Box::new(panel)) + }) +} diff --git a/wlx-overlay-s/src/overlays/wayvr.rs b/wlx-overlay-s/src/overlays/wayvr.rs index 622db07..f13101e 100644 --- a/wlx-overlay-s/src/overlays/wayvr.rs +++ b/wlx-overlay-s/src/overlays/wayvr.rs @@ -1,17 +1,17 @@ -use glam::{Affine2, Affine3A, Quat, Vec3, vec3}; +use glam::{vec3, Affine2, Affine3A, Quat, Vec3}; use smallvec::smallvec; use std::{cell::RefCell, collections::HashMap, rc::Rc, sync::Arc}; use vulkano::{ buffer::{BufferUsage, Subbuffer}, command_buffer::CommandBufferUsage, format::Format, - image::{Image, ImageTiling, SubresourceLayout, view::ImageView}, + image::{view::ImageView, Image, ImageTiling, SubresourceLayout}, }; use wayvr_ipc::packet_server::{self, PacketServer, WvrStateChanged}; use wgui::gfx::{ - WGfx, pass::WGfxPass, pipeline::{WGfxPipeline, WPipelineCreateInfo}, + WGfx, }; use wlx_capture::frame::{DmabufFrame, FourCC, FrameFormat, FramePlane}; @@ -20,19 +20,20 @@ use crate::{ input::{self, HoverResult}, task::TaskType, wayvr::{ - self, WayVR, WayVRAction, WayVRDisplayClickAction, display, + self, display, server_ipc::{gen_args_vec, gen_env_vec}, + WayVR, WayVRAction, WayVRDisplayClickAction, }, }, config_wayvr, - graphics::{CommandBuffers, Vert2Uv, dmabuf::WGfxDmabuf}, + graphics::{dmabuf::WGfxDmabuf, Vert2Uv}, state::{self, AppState}, subsystem::{hid::WheelDelta, input::KeyboardFocus}, windowing::{ - OverlayID, OverlaySelector, Z_ORDER_DASHBOARD, - backend::{FrameMeta, OverlayBackend, ShouldRender, ui_transform}, + backend::{ui_transform, FrameMeta, OverlayBackend, RenderResources, ShouldRender}, manager::OverlayWindowManager, window::{OverlayWindowConfig, OverlayWindowData, OverlayWindowState}, + OverlayID, OverlaySelector, Z_ORDER_DASHBOARD, }, }; @@ -660,11 +661,9 @@ impl OverlayBackend for WayVRBackend { fn render( &mut self, - app: &mut state::AppState, - tgt: Arc, - buf: &mut CommandBuffers, - alpha: f32, - ) -> anyhow::Result { + _app: &mut state::AppState, + rdr: &mut RenderResources, + ) -> anyhow::Result<()> { let ctx = self.context.borrow(); let wayvr = ctx.wayvr.borrow_mut(); @@ -689,26 +688,12 @@ impl OverlayBackend for WayVRBackend { } } - let Some(image) = self.image.as_ref() else { - return Ok(false); - }; - + let image = self.image.as_ref().unwrap(); self.pass .update_sampler(0, image.vk_image_view.clone(), self.graphics.texture_filter)?; - self.buf_alpha.write()?[0] = alpha; - - let mut cmd_buffer = app - .gfx - .create_gfx_command_buffer(CommandBufferUsage::OneTimeSubmit)?; - cmd_buffer.begin_rendering( - tgt, - wgui::gfx::cmd::WGfxClearMode::Clear([0.0, 0.0, 0.0, 1.0]), - )?; - cmd_buffer.run_ref(&self.pass)?; - cmd_buffer.end_rendering()?; - buf.push(cmd_buffer.build()?); - - Ok(true) + self.buf_alpha.write()?[0] = rdr.alpha; + rdr.cmd_buf.run_ref(&self.pass)?; + Ok(()) } fn frame_meta(&mut self) -> Option { diff --git a/wlx-overlay-s/src/subsystem/hid/mod.rs b/wlx-overlay-s/src/subsystem/hid/mod.rs index 8e4ff6b..ee94160 100644 --- a/wlx-overlay-s/src/subsystem/hid/mod.rs +++ b/wlx-overlay-s/src/subsystem/hid/mod.rs @@ -1,5 +1,5 @@ use glam::Vec2; -use idmap::{IdMap, idmap}; +use idmap::{idmap, IdMap}; use idmap_derive::IntegerId; use input_linux::{ AbsoluteAxis, AbsoluteInfo, AbsoluteInfoSetup, EventKind, InputId, Key, RelativeAxis, diff --git a/wlx-overlay-s/src/windowing/backend.rs b/wlx-overlay-s/src/windowing/backend.rs index bb04c36..61e3776 100644 --- a/wlx-overlay-s/src/windowing/backend.rs +++ b/wlx-overlay-s/src/windowing/backend.rs @@ -1,10 +1,19 @@ use glam::{Affine2, Affine3A, Vec2}; use std::{any::Any, sync::Arc}; -use vulkano::{format::Format, image::view::ImageView}; +use vulkano::{ + command_buffer::{CommandBufferUsage, PrimaryAutoCommandBuffer}, + device::Queue, + format::Format, + image::view::ImageView, +}; +use wgui::gfx::{ + cmd::{GfxCommandBuffer, WGfxClearMode}, + WGfx, +}; use crate::{ backend::input::{HoverResult, PointerHit}, - graphics::CommandBuffers, + graphics::ExtentExt, state::AppState, subsystem::hid::WheelDelta, }; @@ -14,6 +23,7 @@ pub struct FrameMeta { pub extent: [u32; 3], pub transform: Affine3A, pub format: Format, + pub clear: WGfxClearMode, } pub enum ShouldRender { @@ -25,6 +35,35 @@ pub enum ShouldRender { Unable, } +pub struct RenderResources { + pub alpha: f32, + pub cmd_buf: GfxCommandBuffer, + pub extent: [u32; 2], +} + +impl RenderResources { + pub fn new( + gfx: Arc, + tgt: Arc, + meta: &FrameMeta, + alpha: f32, + ) -> anyhow::Result { + let mut cmd_buf = gfx.create_gfx_command_buffer(CommandBufferUsage::OneTimeSubmit)?; + cmd_buf.begin_rendering(tgt, meta.clear)?; + + Ok(Self { + cmd_buf, + alpha, + extent: meta.extent.extent_u32arr(), + }) + } + + pub fn end(mut self) -> anyhow::Result<(Arc, Arc)> { + self.cmd_buf.end_rendering()?; + Ok((self.cmd_buf.queue.clone(), self.cmd_buf.build()?)) + } +} + pub trait OverlayBackend: Any { /// Called once, before the first frame is rendered fn init(&mut self, app: &mut AppState) -> anyhow::Result<()>; @@ -35,13 +74,7 @@ pub trait OverlayBackend: Any { fn should_render(&mut self, app: &mut AppState) -> anyhow::Result; /// Called when the contents need to be rendered to the swapchain - fn render( - &mut self, - app: &mut AppState, - tgt: Arc, - buf: &mut CommandBuffers, - alpha: f32, - ) -> anyhow::Result; + fn render(&mut self, app: &mut AppState, rdr: &mut RenderResources) -> anyhow::Result<()>; /// Called to retrieve the effective extent of the image /// Used for creating swapchains. @@ -85,17 +118,11 @@ impl OverlayBackend for DummyBackend { fn should_render(&mut self, _: &mut AppState) -> anyhow::Result { Ok(ShouldRender::Unable) } - fn render( - &mut self, - _: &mut AppState, - _: Arc, - _: &mut CommandBuffers, - _: f32, - ) -> anyhow::Result { - Ok(false) + fn render(&mut self, _: &mut AppState, _: &mut RenderResources) -> anyhow::Result<()> { + unreachable!() } fn frame_meta(&mut self) -> Option { - None + unreachable!() } fn on_hover(&mut self, _: &mut AppState, _: &PointerHit) -> HoverResult { @@ -103,7 +130,7 @@ impl OverlayBackend for DummyBackend { } fn on_left(&mut self, _: &mut AppState, _: usize) {} fn on_pointer(&mut self, _: &mut AppState, _: &PointerHit, _: bool) {} - fn on_scroll(&mut self, _: &mut AppState, _: &PointerHit, _: f32, _: f32) {} + fn on_scroll(&mut self, _: &mut AppState, _: &PointerHit, _: WheelDelta) {} fn get_interaction_transform(&mut self) -> Option { None } diff --git a/wlx-overlay-s/src/windowing/manager.rs b/wlx-overlay-s/src/windowing/manager.rs index 92309f4..ea92179 100644 --- a/wlx-overlay-s/src/windowing/manager.rs +++ b/wlx-overlay-s/src/windowing/manager.rs @@ -5,7 +5,7 @@ use slotmap::{HopSlotMap, Key, SecondaryMap}; use crate::{ overlays::{ - adjust::EditModeManager, anchor::create_anchor, keyboard::builder::create_keyboard, + anchor::create_anchor, edit::EditModeManager, keyboard::builder::create_keyboard, screen::create_screens, watch::create_watch, }, state::AppState, diff --git a/wlx-overlay-s/src/windowing/window.rs b/wlx-overlay-s/src/windowing/window.rs index e52e1a4..ac7a951 100644 --- a/wlx-overlay-s/src/windowing/window.rs +++ b/wlx-overlay-s/src/windowing/window.rs @@ -1,14 +1,12 @@ use glam::{Affine3A, Mat3A, Quat, Vec3, Vec3A}; use serde::{Deserialize, Serialize}; use std::{f32::consts::PI, sync::Arc}; -use vulkano::image::view::ImageView; use crate::{ - graphics::CommandBuffers, state::{AppState, LeftRight}, subsystem::input::KeyboardFocus, windowing::{ - backend::{FrameMeta, OverlayBackend, ShouldRender}, + backend::{FrameMeta, OverlayBackend, RenderResources, ShouldRender}, snap_upright, }, }; @@ -68,14 +66,8 @@ impl OverlayWindowData { pub fn should_render(&mut self, app: &mut AppState) -> anyhow::Result { self.config.backend.should_render(app) } - pub fn render( - &mut self, - app: &mut AppState, - tgt: Arc, - buf: &mut CommandBuffers, - alpha: f32, - ) -> anyhow::Result { - self.config.backend.render(app, tgt, buf, alpha) + pub fn render(&mut self, app: &mut AppState, rdr: &mut RenderResources) -> anyhow::Result<()> { + self.config.backend.render(app, rdr) } pub fn frame_meta(&mut self) -> Option { self.config.backend.frame_meta()