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

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