Jayden/wayvr
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor rendering interface, working edit overlay

Browse Source
This commit is contained in:
galister
2025-11-12 20:02:20 +09:00
parent 350c931749
commit 6b5b95bd88
25 changed files with 371 additions and 341 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
wgui/src/gfx/cmd.rs
View File

@@ -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<CmdBufGfx>;
pub type XferCommandBuffer = WCommandBuffer<CmdBufXfer>;
@@ -44,13 +44,24 @@ impl<T> WCommandBuffer<T> {
}
}
#[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<CmdBufGfx> {
pub fn begin_rendering(&mut self, render_target: Arc<ImageView>, clear_mode: WGfxClearMode) -> anyhow::Result<()> {
self.command_buffer.begin_rendering(RenderingInfo {

2
wlx-overlay-s/src/assets/gui/adjust.xml → wlx-overlay-s/src/assets/gui/edit.xml
View File

@@ -15,7 +15,7 @@
border_color="#0044CC" border="2" round="8" color="#000A1C" color2="#000002" gradient="vertical" />
<elements>
<div width="600" height="600">
<div width="100%" height="100%">
<rectangle width="100%" height="100%" padding="4" gap="4" align_items="center" justify_content="center" color="#000000DD" flex_direction="row">
<div></div>
<div flex_direction="column">

35
wlx-overlay-s/src/assets/gui/toolbox.xml Normal file
View File

@@ -0,0 +1,35 @@
<layout>
<theme>
<var key="border" value="2" />
</theme>
<macro name="button_style"
margin="2" overflow="hidden" box_sizing="border_box" align_items="center" justify_content="center"
border_color="#0044CC" border="2" round="8" color="#000A1C" color2="#000002" gradient="vertical" />
<template name="Set">
<Button macro="button_style" _press="::SetToggle ${handle}">
<sprite width="40" height="40" color="~set_color" src="watch/set2.svg" />
<div position="absolute" margin_top="9">
<label text="${display}" size="24" color="#00050F" weight="bold" />
</div>
</Button>
</template>
<elements>
<div width="400" height="200">
<rectangle width="100%" height="100%" padding="4" box_sizing="content_box" flex_wrap="wrap" flex_direction="column" gap="4" color="~bg_color">
<label text="Select set to edit" size="48" color="#ffffff" weight="bold" />
<div width="100%" flex_direction="row">
<div id="sets">
<!-- Will populate <Set> tags at runtime -->
</div>
<Button macro="button_style" _press="::EditToggle">
<sprite color="~set_color" width="40" height="40" src="watch/edit.svg" />
</Button>
</div>
<label text="" size="48" color="#ffffff" weight="bold" />
</rectangle>
</div>
</elements>
</layout>

21
wlx-overlay-s/src/backend/openvr/lines.rs
View File

@@ -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<ShouldRender> {
Ok(ShouldRender::Unable)
}
fn render(
&mut self,
_: &mut AppState,
_: Arc<ImageView>,
_: &mut CommandBuffers,
_: f32,
) -> anyhow::Result<bool> {
Ok(false)
fn render(&mut self, _: &mut AppState, _: &mut RenderResources) -> anyhow::Result<()> {
unreachable!()
}
fn frame_meta(&mut self) -> Option<FrameMeta> {
Some(FrameMeta {

33
wlx-overlay-s/src/backend/openvr/mod.rs
View File

@@ -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()

32
wlx-overlay-s/src/backend/openvr/overlay.rs
View File

@@ -62,21 +62,33 @@ impl OverlayWindowData<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);
pub(super) fn ensure_staging_image(
&mut self,
app: &mut AppState,
extent: [u32; 3],
) -> anyhow::Result<Arc<ImageView>> {
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(

6
wlx-overlay-s/src/backend/openxr/lines.rs
View File

@@ -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()?))?;
}
}

36
wlx-overlay-s/src/backend/openxr/mod.rs
View File

@@ -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

44
wlx-overlay-s/src/backend/openxr/overlay.rs
View File

@@ -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<OpenXrOverlayData> {
pub(super) fn ensure_swapchain<'a>(
pub(super) fn ensure_swapchain_acquire<'a>(
&'a mut self,
app: &AppState,
xr: &'a XrState,
) -> anyhow::Result<bool> {
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<Arc<ImageView>> {
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>(

12
wlx-overlay-s/src/backend/openxr/skybox.rs
View File

@@ -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)?;

36
wlx-overlay-s/src/graphics/mod.rs
View File

@@ -636,28 +636,32 @@ fn queue_families_priorities(
}
#[derive(Default)]
pub struct CommandBuffers {
inner: Vec<Arc<PrimaryAutoCommandBuffer>>,
pub struct GpuFutures {
futures: Vec<Box<dyn GpuFuture>>,
}
impl CommandBuffers {
pub fn push(&mut self, buffer: Arc<PrimaryAutoCommandBuffer>) {
self.inner.push(buffer);
impl GpuFutures {
pub fn execute(
&mut self,
cmd: (Arc<Queue>, Arc<PrimaryAutoCommandBuffer>),
) -> anyhow::Result<()> {
self.futures.push(cmd.1.execute(cmd.0)?.boxed());
Ok(())
}
pub fn execute_now(self, queue: Arc<Queue>) -> anyhow::Result<Option<Box<dyn GpuFuture>>> {
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<dyn GpuFuture> = 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(())
}
}

44
wlx-overlay-s/src/gui/panel/mod.rs
View File

@@ -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<S: 'static> OverlayBackend for GuiPanel<S> {
})
}
fn render(
&mut self,
app: &mut AppState,
tgt: Arc<ImageView>,
buf: &mut CommandBuffers,
mut alpha: f32,
) -> anyhow::Result<bool> {
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<S: 'static> OverlayBackend for GuiPanel<S> {
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<FrameMeta> {
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 _,

55
wlx-overlay-s/src/overlays/adjust.rs → wlx-overlay-s/src/overlays/edit.rs
View File

@@ -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<EditModeWrapPanel>,
inner: ManuallyDrop<Box<dyn OverlayBackend>>,
image: Option<Arc<ImageView>>,
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<ShouldRender> {
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<vulkano::image::view::ImageView>,
buf: &mut crate::graphics::CommandBuffers,
alpha: f32,
) -> anyhow::Result<bool> {
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<crate::windowing::backend::FrameMeta> {
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<glam::Affine2> {
self.inner.get_interaction_transform()
}
}
fn make_adjustment_panel(app: &mut AppState) -> anyhow::Result<EditModeWrapPanel> {
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<EditModeWrapPanel> {
let panel = GuiPanel::new_from_template(app, "gui/edit.xml", "".into(), None, true)?;
Ok(panel)
}

2
wlx-overlay-s/src/overlays/keyboard/builder.rs
View File

@@ -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},

17
wlx-overlay-s/src/overlays/keyboard/mod.rs
View File

@@ -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<ShouldRender> {
self.panel.should_render(app)
}
fn render(
&mut self,
app: &mut AppState,
tgt: Arc<ImageView>,
buf: &mut CommandBuffers,
alpha: f32,
) -> anyhow::Result<bool> {
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<FrameMeta> {
self.panel.frame_meta()

37
wlx-overlay-s/src/overlays/mirror.rs
View File

@@ -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<ImageView>,
buf: &mut CommandBuffers,
alpha: f32,
) -> anyhow::Result<bool> {
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() {

3
wlx-overlay-s/src/overlays/mod.rs
View File

@@ -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;

36
wlx-overlay-s/src/overlays/screen/backend.rs
View File

@@ -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();

30
wlx-overlay-s/src/overlays/screen/capture.rs
View File

@@ -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(),

80
wlx-overlay-s/src/overlays/toolbox.rs Normal file
View File

@@ -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<OverlayWindowConfig> {
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<str>, Rc<str>> = 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))
})
}

45
wlx-overlay-s/src/overlays/wayvr.rs
View File

@@ -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<ImageView>,
buf: &mut CommandBuffers,
alpha: f32,
) -> anyhow::Result<bool> {
_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<FrameMeta> {

2
wlx-overlay-s/src/subsystem/hid/mod.rs
View File

@@ -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,

65
wlx-overlay-s/src/windowing/backend.rs
View File

@@ -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<WGfx>,
tgt: Arc<ImageView>,
meta: &FrameMeta,
alpha: f32,
) -> anyhow::Result<Self> {
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<Queue>, Arc<PrimaryAutoCommandBuffer>)> {
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<ShouldRender>;
/// Called when the contents need to be rendered to the swapchain
fn render(
&mut self,
app: &mut AppState,
tgt: Arc<ImageView>,
buf: &mut CommandBuffers,
alpha: f32,
) -> anyhow::Result<bool>;
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<ShouldRender> {
Ok(ShouldRender::Unable)
}
fn render(
&mut self,
_: &mut AppState,
_: Arc<ImageView>,
_: &mut CommandBuffers,
_: f32,
) -> anyhow::Result<bool> {
Ok(false)
fn render(&mut self, _: &mut AppState, _: &mut RenderResources) -> anyhow::Result<()> {
unreachable!()
}
fn frame_meta(&mut self) -> Option<FrameMeta> {
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<glam::Affine2> {
None
}

2
wlx-overlay-s/src/windowing/manager.rs
View File

@@ -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,

14
wlx-overlay-s/src/windowing/window.rs
View File

@@ -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<T> OverlayWindowData<T> {
pub fn should_render(&mut self, app: &mut AppState) -> anyhow::Result<ShouldRender> {
self.config.backend.should_render(app)
}
pub fn render(
&mut self,
app: &mut AppState,
tgt: Arc<ImageView>,
buf: &mut CommandBuffers,
alpha: f32,
) -> anyhow::Result<bool> {
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<FrameMeta> {
self.config.backend.frame_meta()