leyoda/cosmic-comp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

chore: smithay update

Browse source
This commit is contained in:
Victoria Brekenfeld 2025-03-11 19:14:49 +01:00 • committed by Victoria Brekenfeld
parent f8fae8a5b0
commit 95b27637ae
23 changed files with 336 additions and 373 deletions
Download patch file Download diff file Expand all files Collapse all files

39
Cargo.lock generated
View file

@ -1467,7 +1467,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "33d852cb9b869c2a9b3df2f71a3074817f01e1844f839a144f5fcef059a4eb5d"
dependencies = [
"libc",
"windows-sys 0.52.0",
"windows-sys 0.59.0",
]
[[package]]
@ -2934,9 +2934,9 @@ dependencies = [
[[package]]
name = "libseat"
version = "0.2.1"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "54a0adf8d8607a73a5b74cbe4132f57cb349e4bf860103cd089461bbcbc9907e"
checksum = "c23a245bbd5790c690791c4fe6eefafe4c75851226288a71cb657601135aa00c"
dependencies = [
"errno",
"libseat-sys",
@ -2945,9 +2945,9 @@ dependencies = [
[[package]]
name = "libseat-sys"
version = "0.1.7"
version = "0.1.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3671cb5e03871f1d6bf0b3b5daa9275549e348fa6359e0f9adb910ca163d4c34"
checksum = "134621e50557e8698a96ccff3eadbc6f4b449d5d12f8aa48fcef8d40b4b02725"
dependencies = [
"pkg-config",
]
@ -4386,7 +4386,7 @@ dependencies = [
"errno",
"libc",
"linux-raw-sys 0.4.15",
"windows-sys 0.52.0",
"windows-sys 0.59.0",
]
[[package]]
@ -4671,9 +4671,10 @@ checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
[[package]]
name = "smithay"
version = "0.4.0"
source = "git+https://github.com/smithay/smithay.git?rev=f93476c#f93476cebab3d47f6729354805b3e184f6878ef2"
version = "0.5.0"
source = "git+https://github.com/smithay/smithay?rev=a503d98#a503d981d1be9a54b286ab5e160e4b9edddb500f"
dependencies = [
"aliasable",
"appendlist",
"ash",
"bitflags 2.8.0",
@ -4760,7 +4761,7 @@ dependencies = [
[[package]]
name = "smithay-egui"
version = "0.1.0"
source = "git+https://github.com/Smithay/smithay-egui.git?rev=e9411da#e9411da9932316d6770661788c348f4b5a9be184"
source = "git+https://github.com/Smithay/smithay-egui.git?rev=e720136#e7201366b88e4fb20d0c6618a6cac9acc6299e07"
dependencies = [
"cgmath",
"egui",
@ -4986,7 +4987,7 @@ dependencies = [
"getrandom",
"once_cell",
"rustix",
"windows-sys 0.52.0",
"windows-sys 0.59.0",
]
[[package]]
@ -5691,9 +5692,9 @@ dependencies = [
[[package]]
name = "wayland-cursor"
version = "0.31.7"
version = "0.31.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "32b08bc3aafdb0035e7fe0fdf17ba0c09c268732707dca4ae098f60cb28c9e4c"
checksum = "a93029cbb6650748881a00e4922b076092a6a08c11e7fbdb923f064b23968c5d"
dependencies = [
"rustix",
"wayland-client",
@ -5702,9 +5703,9 @@ dependencies = [
[[package]]
name = "wayland-egl"
version = "0.32.4"
version = "0.32.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4e3cb8b84ff95310fe59ce6c61f1fa344ec22f4c240c369a2b20f15caebfede4"
checksum = "504838241a10e271f48ffd429ac4033e0ac468b399fe7c2e2840f5c3a82d9902"
dependencies = [
"wayland-backend",
"wayland-sys",
@ -5725,9 +5726,9 @@ dependencies = [
[[package]]
name = "wayland-protocols-misc"
version = "0.3.5"
version = "0.3.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "da2e42969764e469a115d4bb1c16e9588ef8b75b127ba7a2c9ddf1e140b25ca7"
checksum = "feb7ee1810026d1bb15d47086d03a7e5c68651c707e305ba1e8cc796fcbf5a54"
dependencies = [
"bitflags 2.8.0",
"wayland-backend",
@ -5751,9 +5752,9 @@ dependencies = [
[[package]]
name = "wayland-protocols-wlr"
version = "0.3.5"
version = "0.3.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "782e12f6cd923c3c316130d56205ebab53f55d6666b7faddfad36cecaeeb4022"
checksum = "248a02e6f595aad796561fa82d25601bd2c8c3b145b1c7453fc8f94c1a58f8b2"
dependencies = [
"bitflags 2.8.0",
"wayland-backend",
@ -5959,7 +5960,7 @@ version = "0.1.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
dependencies = [
"windows-sys 0.52.0",
"windows-sys 0.48.0",
]
[[package]]

8
Cargo.toml
View file

@ -84,13 +84,14 @@ features = [
"wayland_frontend",
"xwayland",
]
version = "0.4"
git = "https://github.com/smithay/smithay"
rev = "a503d98"
[dependencies.smithay-egui]
features = ["svg"]
git = "https://github.com/Smithay/smithay-egui.git"
optional = true
rev = "e9411da"
rev = "e720136"
[features]
debug = ["egui", "egui_plot", "smithay-egui", "anyhow/backtrace"]
@ -114,9 +115,6 @@ inherits = "release"
[profile.release]
lto = "fat"
[patch.crates-io]
smithay = { git = "https://github.com/smithay/smithay.git", rev = "f93476c" }
[patch."https://github.com/pop-os/cosmic-protocols"]
cosmic-protocols = { git = "https://github.com/pop-os//cosmic-protocols", rev = "e706814" }
cosmic-client-toolkit = { git = "https://github.com/pop-os//cosmic-protocols", rev = "e706814" }

4
src/backend/kms/render/gles.rs
View file

@ -11,7 +11,7 @@ use smithay::backend::{
gles::GlesError,
glow::GlowRenderer,
multigpu::{ApiDevice, Error as MultiError, GraphicsApi},
Renderer,
RendererSuper,
},
SwapBuffersError,
};
@ -182,7 +182,7 @@ impl ApiDevice for GbmGlowDevice {
impl<T: GraphicsApi, A: AsFd + Clone + 'static> FromGlesError for MultiError<GbmGlowBackend<A>, T>
where
T::Error: 'static,
<<T::Device as ApiDevice>::Renderer as Renderer>::Error: 'static,
<<T::Device as ApiDevice>::Renderer as RendererSuper>::Error: 'static,
{
#[inline]
fn from_gles_error(err: GlesError) -> MultiError<GbmGlowBackend<A>, T> {

65
src/backend/kms/surface/mod.rs
View file

@ -45,7 +45,7 @@ use smithay::{
multigpu::{Error as MultiError, GpuManager},
sync::SyncPoint,
utils::with_renderer_surface_state,
Bind, ImportDma, Offscreen, Renderer, Texture,
Bind, ImportDma, Offscreen, Renderer, RendererSuper, Texture,
},
},
desktop::utils::OutputPresentationFeedback,
@ -93,13 +93,6 @@ use super::{drm_helpers, render::gles::GbmGlowBackend};
#[cfg(feature = "debug")]
use smithay_egui::EguiState;
#[cfg(feature = "debug")]
static INTEL_LOGO: &'static [u8] = include_bytes!("../../../../resources/icons/intel.svg");
#[cfg(feature = "debug")]
static AMD_LOGO: &'static [u8] = include_bytes!("../../../../resources/icons/amd.svg");
#[cfg(feature = "debug")]
static NVIDIA_LOGO: &'static [u8] = include_bytes!("../../../../resources/icons/nvidia.svg");
#[derive(Debug)]
pub struct Surface {
pub(crate) connector: connector::Handle,
@ -740,19 +733,6 @@ impl SurfaceThreadState {
unsafe { GlowRenderer::new(egl) }.context("Failed to create renderer")?;
init_shaders(renderer.borrow_mut()).context("Failed to initialize shaders")?;
#[cfg(feature = "debug")]
{
self.egui
.load_svg(&mut renderer, String::from("intel"), INTEL_LOGO)
.unwrap();
self.egui
.load_svg(&mut renderer, String::from("amd"), AMD_LOGO)
.unwrap();
self.egui
.load_svg(&mut renderer, String::from("nvidia"), NVIDIA_LOGO)
.unwrap();
}
self.api.as_mut().add_node(node, gbm, renderer);
/*
} else {
@ -1107,10 +1087,11 @@ impl SurfaceThreadState {
mirroring_state
.texture
.render()
.draw::<_, <GlMultiRenderer as Renderer>::Error>(|tex| {
let res = match mirroring_state.damage_tracker.render_output_with(
.draw::<_, <GlMultiRenderer as RendererSuper>::Error>(|tex| {
let mut fb = renderer.bind(tex)?;
let res = match mirroring_state.damage_tracker.render_output(
&mut renderer,
tex.clone(),
&mut fb,
1,
&elements,
CLEAR_COLOR,
@ -1119,8 +1100,8 @@ impl SurfaceThreadState {
Err(RenderError::Rendering(err)) => return Err(err),
Err(RenderError::OutputNoMode(_)) => unreachable!(),
};
renderer.wait(&res.sync)?;
std::mem::drop(fb);
let transform = mirrored_output.current_transform();
let area = tex.size().to_logical(1, transform);
@ -1235,15 +1216,19 @@ impl SurfaceThreadState {
let mut sync = SyncPoint::default();
if let Some(ref damage) = damage {
let mut dmabuf_clone;
let mut render_buffer;
let buffer = frame.buffer();
if let Ok(dmabuf) = get_dmabuf(&buffer) {
let mut shm_buffer = false;
let mut fb = if let Ok(dmabuf) = get_dmabuf(&buffer) {
dmabuf_clone = dmabuf.clone();
renderer
.bind(dmabuf.clone())
.map_err(RenderError::<<GlMultiRenderer as Renderer>::Error>::Rendering)?;
.bind(&mut dmabuf_clone)
.map_err(RenderError::<<GlMultiRenderer as RendererSuper>::Error>::Rendering)?
} else {
shm_buffer = true;
let size = buffer_dimensions(&buffer).ok_or(RenderError::<
<GlMultiRenderer as Renderer>::Error,
<GlMultiRenderer as RendererSuper>::Error,
>::Rendering(
MultiError::ImportFailed,
))?;
@ -1251,18 +1236,19 @@ impl SurfaceThreadState {
with_buffer_contents(&buffer, |_, _, data| shm_format_to_fourcc(data.format))
.map_err(|_| OutputNoMode)? // eh, we have to do some error
.expect("We should be able to convert all hardcoded shm screencopy formats");
let render_buffer =
render_buffer =
Offscreen::<GlesRenderbuffer>::create_buffer(
&mut renderer,
format,
size,
)
.map_err(RenderError::<<GlMultiRenderer as Renderer>::Error>::Rendering)?;
.map_err(RenderError::<<GlMultiRenderer as RendererSuper>::Error>::Rendering)?;
renderer
.bind(render_buffer)
.map_err(RenderError::<<GlMultiRenderer as Renderer>::Error>::Rendering)?;
}
.bind(&mut render_buffer)
.map_err(RenderError::<<GlMultiRenderer as RendererSuper>::Error>::Rendering)?
};
if let Some(ref damage) = damage {
let (output_size, output_scale, output_transform) = (
self.output.current_mode().ok_or(OutputNoMode)?.size,
self.output.current_scale().fractional_scale(),
@ -1292,23 +1278,25 @@ impl SurfaceThreadState {
.to_physical(1);
d
});
match frame_result
.blit_frame_result(
output_size,
output_transform,
output_scale,
&mut renderer,
&mut fb,
adjusted,
filter,
)
.map_err(|err| match err {
BlitFrameResultError::Rendering(err) => RenderError::<
<GlMultiRenderer as Renderer>::Error,
<GlMultiRenderer as RendererSuper>::Error,
>::Rendering(
err
),
BlitFrameResultError::Export(_) => RenderError::<
<GlMultiRenderer as Renderer>::Error,
<GlMultiRenderer as RendererSuper>::Error,
>::Rendering(
MultiError::DeviceMissing,
),
@ -1329,13 +1317,14 @@ impl SurfaceThreadState {
continue;
}
};
}
};
let transform = self.output.current_transform();
match submit_buffer(
frame,
&mut renderer,
shm_buffer.then_some(&mut fb),
transform,
damage.as_deref(),
sync,

6
src/backend/render/cursor.rs
View file

@ -131,7 +131,7 @@ pub fn draw_surface_cursor<R>(
) -> Vec<(CursorRenderElement<R>, Point<i32, BufferCoords>)>
where
R: Renderer + ImportAll,
<R as Renderer>::TextureId: Clone + 'static,
R::TextureId: Clone + 'static,
{
let position = location.into();
let scale = scale.into();
@ -172,7 +172,7 @@ pub fn draw_dnd_icon<R>(
) -> Vec<WaylandSurfaceRenderElement<R>>
where
R: Renderer + ImportAll,
<R as Renderer>::TextureId: Clone + 'static,
R::TextureId: Clone + 'static,
{
if get_role(&surface) != Some("dnd_icon") {
warn!(
@ -262,7 +262,7 @@ pub fn draw_cursor<R>(
) -> Vec<(CursorRenderElement<R>, Point<i32, BufferCoords>)>
where
R: Renderer + ImportMem + ImportAll,
<R as Renderer>::TextureId: Send + Clone + 'static,
R::TextureId: Send + Clone + 'static,
{
// draw the cursor as relevant
// reset the cursor if the surface is no longer alive

46
src/backend/render/element.rs
View file

@ -22,7 +22,7 @@ use super::{cursor::CursorRenderElement, GlMultiRenderer};
pub enum CosmicElement<R>
where
R: AsGlowRenderer + Renderer + ImportAll + ImportMem,
<R as Renderer>::TextureId: 'static,
R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
Workspace(
@ -45,7 +45,7 @@ where
impl<R> Element for CosmicElement<R>
where
R: AsGlowRenderer + Renderer + ImportAll + ImportMem,
<R as Renderer>::TextureId: 'static,
R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn id(&self) -> &Id {
@ -196,13 +196,13 @@ where
impl<R> RenderElement<R> for CosmicElement<R>
where
R: AsGlowRenderer + Renderer + ImportAll + ImportMem,
<R as Renderer>::TextureId: 'static,
<R as Renderer>::Error: FromGlesError,
R::TextureId: 'static,
R::Error: FromGlesError,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn draw(
&self,
frame: &mut R::Frame<'_>,
frame: &mut R::Frame<'_, '_>,
src: Rectangle<f64, BufferCoords>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>],
@ -286,7 +286,7 @@ impl<R> From<CropRenderElement<RescaleRenderElement<WorkspaceRenderElement<R>>>>
for CosmicElement<R>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: CropRenderElement<RescaleRenderElement<WorkspaceRenderElement<R>>>) -> Self {
@ -301,7 +301,7 @@ where
impl<R> From<DamageElement> for CosmicElement<R>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: DamageElement) -> Self {
@ -312,7 +312,7 @@ where
impl<R> From<MemoryRenderBufferRenderElement<R>> for CosmicElement<R>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(value: MemoryRenderBufferRenderElement<R>) -> Self {
@ -324,7 +324,7 @@ where
impl<R> From<TextureRenderElement<GlesTexture>> for CosmicElement<R>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: TextureRenderElement<GlesTexture>) -> Self {
@ -338,8 +338,12 @@ where
{
fn glow_renderer(&self) -> &GlowRenderer;
fn glow_renderer_mut(&mut self) -> &mut GlowRenderer;
fn glow_frame<'a, 'frame>(frame: &'a Self::Frame<'frame>) -> &'a GlowFrame<'frame>;
fn glow_frame_mut<'a, 'frame>(frame: &'a mut Self::Frame<'frame>) -> &'a mut GlowFrame<'frame>;
fn glow_frame<'a, 'frame, 'buffer>(
frame: &'a Self::Frame<'frame, 'buffer>,
) -> &'a GlowFrame<'frame, 'buffer>;
fn glow_frame_mut<'a, 'frame, 'buffer>(
frame: &'a mut Self::Frame<'frame, 'buffer>,
) -> &'a mut GlowFrame<'frame, 'buffer>;
}
impl AsGlowRenderer for GlowRenderer {
@ -349,10 +353,14 @@ impl AsGlowRenderer for GlowRenderer {
fn glow_renderer_mut(&mut self) -> &mut GlowRenderer {
self
}
fn glow_frame<'a, 'frame>(frame: &'a Self::Frame<'frame>) -> &'a GlowFrame<'frame> {
fn glow_frame<'a, 'frame, 'buffer>(
frame: &'a Self::Frame<'frame, 'buffer>,
) -> &'a GlowFrame<'frame, 'buffer> {
frame
}
fn glow_frame_mut<'a, 'frame>(frame: &'a mut Self::Frame<'frame>) -> &'a mut GlowFrame<'frame> {
fn glow_frame_mut<'a, 'frame, 'buffer>(
frame: &'a mut Self::Frame<'frame, 'buffer>,
) -> &'a mut GlowFrame<'frame, 'buffer> {
frame
}
}
@ -364,10 +372,14 @@ impl<'a> AsGlowRenderer for GlMultiRenderer<'a> {
fn glow_renderer_mut(&mut self) -> &mut GlowRenderer {
self.as_mut()
}
fn glow_frame<'b, 'frame>(frame: &'b Self::Frame<'frame>) -> &'b GlowFrame<'frame> {
fn glow_frame<'b, 'frame, 'buffer>(
frame: &'b Self::Frame<'frame, 'buffer>,
) -> &'b GlowFrame<'frame, 'buffer> {
frame.as_ref()
}
fn glow_frame_mut<'b, 'frame>(frame: &'b mut Self::Frame<'frame>) -> &'b mut GlowFrame<'frame> {
fn glow_frame_mut<'b, 'frame, 'buffer>(
frame: &'b mut Self::Frame<'frame, 'buffer>,
) -> &'b mut GlowFrame<'frame, 'buffer> {
frame.as_mut()
}
}
@ -415,12 +427,12 @@ impl Element for DamageElement {
impl<R: Renderer> RenderElement<R> for DamageElement {
fn draw(
&self,
_frame: &mut <R as Renderer>::Frame<'_>,
_frame: &mut R::Frame<'_, '_>,
_src: Rectangle<f64, BufferCoords>,
_dst: Rectangle<i32, Physical>,
_damage: &[Rectangle<i32, Physical>],
_opaque_regions: &[Rectangle<i32, Physical>],
) -> Result<(), <R as Renderer>::Error> {
) -> Result<(), R::Error> {
Ok(())
}
}

98
src/backend/render/mod.rs
View file

@ -39,7 +39,6 @@ use smithay::{
allocator::dmabuf::Dmabuf,
drm::{DrmDeviceFd, DrmNode},
renderer::{
buffer_dimensions,
damage::{Error as RenderError, OutputDamageTracker, RenderOutputResult},
element::{
surface::{render_elements_from_surface_tree, WaylandSurfaceRenderElement},
@ -60,11 +59,7 @@ use smithay::{
input::Seat,
output::{Output, OutputNoMode},
utils::{IsAlive, Logical, Monotonic, Point, Rectangle, Scale, Time, Transform},
wayland::{
dmabuf::get_dmabuf,
session_lock::LockSurface,
shm::{shm_format_to_fourcc, with_buffer_contents},
},
wayland::{dmabuf::get_dmabuf, session_lock::LockSurface},
};
#[cfg(feature = "debug")]
@ -80,8 +75,8 @@ use super::kms::Timings;
pub type GlMultiRenderer<'a> =
MultiRenderer<'a, 'a, GbmGlowBackend<DrmDeviceFd>, GbmGlowBackend<DrmDeviceFd>>;
pub type GlMultiFrame<'a, 'frame> =
MultiFrame<'a, 'a, 'frame, GbmGlowBackend<DrmDeviceFd>, GbmGlowBackend<DrmDeviceFd>>;
pub type GlMultiFrame<'a, 'frame, 'buffer> =
MultiFrame<'a, 'a, 'frame, 'buffer, GbmGlowBackend<DrmDeviceFd>, GbmGlowBackend<DrmDeviceFd>>;
pub type GlMultiError = MultiError<GbmGlowBackend<DrmDeviceFd>, GbmGlowBackend<DrmDeviceFd>>;
pub enum RendererRef<'a> {
@ -414,7 +409,7 @@ pub fn cursor_elements<'a, 'frame, R>(
) -> Vec<CosmicElement<R>>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static,
R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
let scale = output.current_scale().fractional_scale();
@ -556,8 +551,8 @@ pub fn output_elements<R>(
) -> Result<Vec<CosmicElement<R>>, RenderError<R::Error>>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static,
<R as Renderer>::Error: FromGlesError,
R::TextureId: Send + Clone + 'static,
R::Error: FromGlesError,
CosmicMappedRenderElement<R>: RenderElement<R>,
WorkspaceRenderElement<R>: RenderElement<R>,
{
@ -647,11 +642,11 @@ pub fn workspace_elements<R>(
current: (WorkspaceHandle, usize),
cursor_mode: CursorMode,
element_filter: ElementFilter,
) -> Result<Vec<CosmicElement<R>>, RenderError<<R as Renderer>::Error>>
) -> Result<Vec<CosmicElement<R>>, RenderError<R::Error>>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static,
<R as Renderer>::Error: FromGlesError,
R::TextureId: Send + Clone + 'static,
R::Error: FromGlesError,
CosmicMappedRenderElement<R>: RenderElement<R>,
WorkspaceRenderElement<R>: RenderElement<R>,
{
@ -970,7 +965,7 @@ fn session_lock_elements<R>(
) -> Vec<WaylandSurfaceRenderElement<R>>
where
R: Renderer + ImportAll,
<R as Renderer>::TextureId: Clone + 'static,
R::TextureId: Clone + 'static,
{
if let Some(surface) = lock_surface {
let scale = Scale::from(output.current_scale().fractional_scale());
@ -988,33 +983,31 @@ where
}
#[profiling::function]
pub fn render_output<'d, R, Target, OffTarget>(
pub fn render_output<'d, R, OffTarget>(
gpu: Option<&DrmNode>,
renderer: &mut R,
target: Target,
target: &mut R::Framebuffer<'_>,
damage_tracker: &'d mut OutputDamageTracker,
age: usize,
shell: &Arc<RwLock<Shell>>,
now: Time<Monotonic>,
output: &Output,
cursor_mode: CursorMode,
) -> Result<RenderOutputResult<'d>, RenderError<<R as Renderer>::Error>>
) -> Result<RenderOutputResult<'d>, RenderError<R::Error>>
where
R: Renderer
+ ImportAll
+ ImportMem
+ ExportMem
+ Bind<Dmabuf>
+ Bind<Target>
+ Offscreen<OffTarget>
+ Blit<Target>
+ Blit
+ AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static,
<R as Renderer>::Error: FromGlesError,
R::TextureId: Send + Clone + 'static,
R::Error: FromGlesError,
CosmicElement<R>: RenderElement<R>,
CosmicMappedRenderElement<R>: RenderElement<R>,
WorkspaceRenderElement<R>: RenderElement<R>,
Target: Clone,
{
let shell_ref = shell.read().unwrap();
let (previous_workspace, workspace) = shell_ref
@ -1038,7 +1031,7 @@ where
let result = render_workspace(
gpu,
renderer,
target.clone(),
target,
damage_tracker,
age,
None,
@ -1055,12 +1048,12 @@ where
match result {
Ok((res, mut elements)) => {
for (session, frame) in output.take_pending_frames() {
if let Some((frame, damage)) = render_session(
if let Some((frame, damage)) = render_session::<_, _, OffTarget>(
renderer,
&session.user_data().get::<SessionData>().unwrap(),
frame,
output.current_transform(),
|buffer, renderer, dt, age, additional_damage| {
|buffer, renderer, offscreen, dt, age, additional_damage| {
let old_len = if !additional_damage.is_empty() {
let area = output
.current_mode()
@ -1104,30 +1097,24 @@ where
if let (Some(ref damage), _) = &res {
if let Ok(dmabuf) = get_dmabuf(buffer) {
renderer
.bind(dmabuf.clone())
let mut dmabuf_clone = dmabuf.clone();
let mut fb = renderer
.bind(&mut dmabuf_clone)
.map_err(RenderError::Rendering)?;
} else {
let size = buffer_dimensions(buffer).unwrap();
let format = with_buffer_contents(buffer, |_, _, data| {
shm_format_to_fourcc(data.format)
})
.map_err(|_| OutputNoMode)? // eh, we have to do some error
.expect(
"We should be able to convert all hardcoded shm screencopy formats",
);
let render_buffer = renderer
.create_buffer(format, size)
.map_err(RenderError::Rendering)?;
renderer
.bind(render_buffer)
.map_err(RenderError::Rendering)?;
}
for rect in damage.iter() {
renderer
.blit_from(target.clone(), *rect, *rect, TextureFilter::Nearest)
.blit(target, &mut fb, *rect, *rect, TextureFilter::Nearest)
.map_err(RenderError::Rendering)?;
}
} else {
let fb =
offscreen.expect("shm buffers should have offscreen target");
for rect in damage.iter() {
renderer
.blit(target, fb, *rect, *rect, TextureFilter::Nearest)
.map_err(RenderError::Rendering)?;
}
}
}
Ok(RenderOutputResult {
@ -1148,10 +1135,10 @@ where
}
#[profiling::function]
pub fn render_workspace<'d, R, Target, OffTarget>(
pub fn render_workspace<'d, R>(
gpu: Option<&DrmNode>,
renderer: &mut R,
target: Target,
target: &mut R::Framebuffer<'_>,
damage_tracker: &'d mut OutputDamageTracker,
age: usize,
additional_damage: Option<Vec<Rectangle<i32, Logical>>>,
@ -1163,18 +1150,11 @@ pub fn render_workspace<'d, R, Target, OffTarget>(
current: (WorkspaceHandle, usize),
cursor_mode: CursorMode,
element_filter: ElementFilter,
) -> Result<(RenderOutputResult<'d>, Vec<CosmicElement<R>>), RenderError<<R as Renderer>::Error>>
) -> Result<(RenderOutputResult<'d>, Vec<CosmicElement<R>>), RenderError<R::Error>>
where
R: Renderer
+ ImportAll
+ ImportMem
+ ExportMem
+ Bind<Dmabuf>
+ Bind<Target>
+ Offscreen<OffTarget>
+ AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static,
<R as Renderer>::Error: FromGlesError,
R: Renderer + ImportAll + ImportMem + ExportMem + Bind<Dmabuf> + AsGlowRenderer,
R::TextureId: Send + Clone + 'static,
R::Error: FromGlesError,
CosmicElement<R>: RenderElement<R>,
CosmicMappedRenderElement<R>: RenderElement<R>,
WorkspaceRenderElement<R>: RenderElement<R>,
@ -1203,9 +1183,9 @@ where
);
}
renderer.bind(target).map_err(RenderError::Rendering)?;
let res = damage_tracker.render_output(
renderer,
target,
age,
&elements,
CLEAR_COLOR, // TODO use a theme neutral color

17
src/backend/winit.rs
View file

@ -47,16 +47,15 @@ pub struct WinitState {
impl WinitState {
#[profiling::function]
pub fn render_output(&mut self, state: &mut Common) -> Result<()> {
self.backend
let age = self.backend.buffer_age().unwrap_or(0);
let (renderer, mut fb) = self
.backend
.bind()
.with_context(|| "Failed to bind buffer")?;
let age = self.backend.buffer_age().unwrap_or(0);
let surface = self.backend.egl_surface();
match render::render_output::<_, _, GlesRenderbuffer>(
match render::render_output::<_, GlesRenderbuffer>(
None,
self.backend.renderer(),
surface.clone(),
renderer,
&mut fb,
&mut self.damage_tracker,
age,
&state.shell,
@ -65,9 +64,7 @@ impl WinitState {
CursorMode::NotDefault,
) {
Ok(RenderOutputResult { damage, states, .. }) => {
self.backend
.bind()
.with_context(|| "Failed to bind display")?;
std::mem::drop(fb);
self.backend
.submit(damage.map(|x| x.as_slice()))
.with_context(|| "Failed to submit buffer for display")?;

9
src/backend/x11.rs
View file

@ -202,14 +202,17 @@ pub struct Surface {
impl Surface {
pub fn render_output(&mut self, renderer: &mut GlowRenderer, state: &mut Common) -> Result<()> {
let (buffer, age) = self
let (mut buffer, age) = self
.surface
.buffer()
.with_context(|| "Failed to allocate buffer")?;
match render::render_output::<_, _, GlesRenderbuffer>(
let mut fb = renderer
.bind(&mut buffer)
.with_context(|| "Failed to bind dmabuf")?;
match render::render_output::<_, GlesRenderbuffer>(
None,
renderer,
buffer.clone(),
&mut fb,
&mut self.damage_tracker,
age as usize,
&state.shell,

51
src/debug.rs
View file

@ -1,13 +1,11 @@
// SPDX-License-Identifier: GPL-3.0-only
use std::collections::HashMap;
use crate::{
backend::kms::Timings,
shell::focus::target::{KeyboardFocusTarget, PointerFocusTarget, PointerFocusToplevel},
State,
};
use egui::{load::SizedTexture, Color32, Vec2};
use egui::Color32;
use smithay::{
backend::{
drm::DrmNode,
@ -97,33 +95,6 @@ pub fn fps_ui<'a>(
})
.unzip();
let vendors = HashMap::from([
(
"0x10de",
state
.with_image(renderer, "nvidia", |image, ctx| {
(image.texture_id(ctx), image.size_vec2())
})
.expect("Logo images not loaded?"),
),
(
"0x1002",
state
.with_image(renderer, "amd", |image, ctx| {
(image.texture_id(ctx), image.size_vec2())
})
.expect("Logo images not loaded?"),
),
(
"0x8086",
state
.with_image(renderer, "intel", |image, ctx| {
(image.texture_id(ctx), image.size_vec2())
})
.expect("Logo images not loaded?"),
),
]);
state.render(
|ctx| {
egui::Area::new("main".into())
@ -152,11 +123,21 @@ pub fn fps_ui<'a>(
"/sys/class/drm/renderD{}/device/vendor",
gpu.minor()
)) {
if let Some((texture_id, mut size)) = vendors.get(vendor.trim())
{
let factor = resp.rect.height() / size.y;
size = Vec2::from([size.x * factor, resp.rect.height()]);
ui.image(SizedTexture::new(*texture_id, size));
if let Some(img) = match vendor.trim() {
"0x10de" => Some(egui::include_image!(
"../resources/icons/nvidia.svg"
)),
"0x1002" => {
Some(egui::include_image!("../resources/icons/amd.svg"))
}
"0x8086" => Some(egui::include_image!(
"../resources/icons/intel.svg"
)),
_ => None,
} {
ui.add(
egui::Image::new(img).max_height(resp.rect.height()),
);
}
}
});

24
src/shell/element/mod.rs
View file

@ -625,7 +625,7 @@ impl CosmicMapped {
) -> Vec<C>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static,
R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
C: From<CosmicMappedRenderElement<R>>,
{
@ -654,7 +654,7 @@ impl CosmicMapped {
) -> Vec<C>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static,
R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
C: From<CosmicMappedRenderElement<R>>,
{
@ -1046,7 +1046,7 @@ impl From<CosmicStack> for CosmicMapped {
pub enum CosmicMappedRenderElement<R>
where
R: Renderer + ImportAll + ImportMem,
<R as Renderer>::TextureId: 'static,
R::TextureId: 'static,
{
Stack(self::stack::CosmicStackRenderElement<R>),
Window(self::window::CosmicWindowRenderElement<R>),
@ -1081,7 +1081,7 @@ where
impl<R> Element for CosmicMappedRenderElement<R>
where
R: Renderer + ImportAll + ImportMem,
<R as Renderer>::TextureId: 'static,
R::TextureId: 'static,
{
fn id(&self) -> &smithay::backend::renderer::element::Id {
match self {
@ -1264,12 +1264,12 @@ where
impl<R> RenderElement<R> for CosmicMappedRenderElement<R>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
<R as Renderer>::Error: FromGlesError,
R::TextureId: 'static,
R::Error: FromGlesError,
{
fn draw(
&self,
frame: &mut R::Frame<'_>,
frame: &mut R::Frame<'_, '_>,
src: Rectangle<f64, BufferCoords>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>],
@ -1385,7 +1385,7 @@ where
impl<R> From<stack::CosmicStackRenderElement<R>> for CosmicMappedRenderElement<R>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: stack::CosmicStackRenderElement<R>) -> Self {
@ -1395,7 +1395,7 @@ where
impl<R> From<window::CosmicWindowRenderElement<R>> for CosmicMappedRenderElement<R>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: window::CosmicWindowRenderElement<R>) -> Self {
@ -1406,7 +1406,7 @@ where
impl<R> From<PixelShaderElement> for CosmicMappedRenderElement<R>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: PixelShaderElement) -> Self {
@ -1417,7 +1417,7 @@ where
impl<R> From<MemoryRenderBufferRenderElement<R>> for CosmicMappedRenderElement<R>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: MemoryRenderBufferRenderElement<R>) -> Self {
@ -1429,7 +1429,7 @@ where
impl<R> From<TextureRenderElement<GlesTexture>> for CosmicMappedRenderElement<R>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: TextureRenderElement<GlesTexture>) -> Self {

4
src/shell/element/stack.rs
View file

@ -618,7 +618,7 @@ impl CosmicStack {
) -> Vec<C>
where
R: Renderer + ImportAll + ImportMem,
<R as Renderer>::TextureId: Send + Clone + 'static,
R::TextureId: Send + Clone + 'static,
C: From<CosmicStackRenderElement<R>>,
{
let window_loc = location + Point::from((0, (TAB_HEIGHT as f64 * scale.y) as i32));
@ -645,7 +645,7 @@ impl CosmicStack {
) -> Vec<C>
where
R: Renderer + ImportAll + ImportMem,
<R as Renderer>::TextureId: Send + Clone + 'static,
R::TextureId: Send + Clone + 'static,
C: From<CosmicStackRenderElement<R>>,
{
let offset = self

6
src/shell/element/surface.rs
View file

@ -660,7 +660,7 @@ impl CosmicSurface {
) -> Vec<C>
where
R: Renderer + ImportAll,
<R as Renderer>::TextureId: Clone + 'static,
R::TextureId: Clone + 'static,
C: From<WaylandSurfaceRenderElement<R>>,
{
match self.0.underlying_surface() {
@ -695,7 +695,7 @@ impl CosmicSurface {
) -> Vec<C>
where
R: Renderer + ImportAll,
<R as Renderer>::TextureId: Clone + 'static,
R::TextureId: Clone + 'static,
C: From<WaylandSurfaceRenderElement<R>>,
{
match self.0.underlying_surface() {
@ -848,7 +848,7 @@ impl X11Relatable for CosmicSurface {
impl<R> AsRenderElements<R> for CosmicSurface
where
R: Renderer + ImportAll,
<R as Renderer>::TextureId: Clone + 'static,
R::TextureId: Clone + 'static,
{
type RenderElement = WaylandSurfaceRenderElement<R>;

4
src/shell/element/window.rs
View file

@ -312,7 +312,7 @@ impl CosmicWindow {
) -> Vec<C>
where
R: Renderer + ImportAll + ImportMem,
<R as Renderer>::TextureId: Send + Clone + 'static,
R::TextureId: Send + Clone + 'static,
C: From<CosmicWindowRenderElement<R>>,
{
let has_ssd = self.0.with_program(|p| p.has_ssd(false));
@ -343,7 +343,7 @@ impl CosmicWindow {
) -> Vec<C>
where
R: Renderer + ImportAll + ImportMem,
<R as Renderer>::TextureId: Send + Clone + 'static,
R::TextureId: Send + Clone + 'static,
C: From<CosmicWindowRenderElement<R>>,
{
let has_ssd = self.0.with_program(|p| p.has_ssd(false));

2
src/shell/grabs/menu/mod.rs
View file

@ -68,7 +68,7 @@ impl MenuGrabState {
pub fn render<I, R>(&self, renderer: &mut R, output: &Output) -> Vec<I>
where
R: Renderer + ImportMem,
<R as Renderer>::TextureId: Send + Clone + 'static,
R::TextureId: Send + Clone + 'static,
I: From<MemoryRenderBufferRenderElement<R>>,
{
let scale = output.current_scale().fractional_scale();

2
src/shell/grabs/moving.rs
View file

@ -71,7 +71,7 @@ impl MoveGrabState {
pub fn render<I, R>(&self, renderer: &mut R, output: &Output, theme: &CosmicTheme) -> Vec<I>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static,
R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
I: From<CosmicMappedRenderElement<R>>,
{

4
src/shell/layout/floating/mod.rs
View file

@ -1390,7 +1390,7 @@ impl FloatingLayout {
) -> Vec<CosmicMappedRenderElement<R>>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static,
R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>,
CosmicStackRenderElement<R>: RenderElement<R>,
@ -1441,7 +1441,7 @@ impl FloatingLayout {
) -> Vec<CosmicMappedRenderElement<R>>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static,
R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>,
CosmicStackRenderElement<R>: RenderElement<R>,

16
src/shell/layout/tiling/mod.rs
View file

@ -3565,7 +3565,7 @@ impl TilingLayout {
let third_width = (last_geometry.size.w as f64 / 3.0).round() as i32;
let third_height = (last_geometry.size.h as f64 / 3.0).round() as i32;
let stack_region = Rectangle::from_extemities(
let stack_region = Rectangle::from_extremities(
(
last_geometry.loc.x + third_width,
last_geometry.loc.y + third_height,
@ -3942,7 +3942,7 @@ impl TilingLayout {
) -> Result<Vec<CosmicMappedRenderElement<R>>, OutputNotMapped>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static,
R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>,
CosmicStackRenderElement<R>: RenderElement<R>,
@ -4102,7 +4102,7 @@ impl TilingLayout {
) -> Result<Vec<CosmicMappedRenderElement<R>>, OutputNotMapped>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static,
R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>,
CosmicStackRenderElement<R>: RenderElement<R>,
@ -4276,7 +4276,7 @@ fn geometries_for_groupview<'a, R>(
)
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer + 'a,
<R as Renderer>::TextureId: 'static,
R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>,
{
@ -4906,7 +4906,7 @@ fn render_old_tree_popups<R>(
) -> Vec<CosmicMappedRenderElement<R>>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static,
R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>,
CosmicStackRenderElement<R>: RenderElement<R>,
@ -4949,7 +4949,7 @@ fn render_old_tree_windows<R>(
) -> Vec<CosmicMappedRenderElement<R>>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static,
R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>,
CosmicStackRenderElement<R>: RenderElement<R>,
@ -5115,7 +5115,7 @@ fn render_new_tree_popups<R>(
) -> Vec<CosmicMappedRenderElement<R>>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static,
R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>,
CosmicStackRenderElement<R>: RenderElement<R>,
@ -5181,7 +5181,7 @@ fn render_new_tree_windows<R>(
) -> Vec<CosmicMappedRenderElement<R>>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static,
R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>,
CosmicStackRenderElement<R>: RenderElement<R>,

24
src/shell/workspace.rs
View file

@ -1160,7 +1160,7 @@ impl Workspace {
) -> Result<Vec<WorkspaceRenderElement<R>>, OutputNotMapped>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static,
R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>,
CosmicStackRenderElement<R>: RenderElement<R>,
@ -1363,7 +1363,7 @@ impl Workspace {
) -> Result<Vec<WorkspaceRenderElement<R>>, OutputNotMapped>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static,
R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>,
CosmicStackRenderElement<R>: RenderElement<R>,
@ -1521,7 +1521,7 @@ pub struct OutputNotMapped;
pub enum WorkspaceRenderElement<R>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
R::TextureId: 'static,
{
OverrideRedirect(WaylandSurfaceRenderElement<R>),
Fullscreen(RescaleRenderElement<CosmicWindowRenderElement<R>>),
@ -1533,7 +1533,7 @@ where
impl<R> Element for WorkspaceRenderElement<R>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
R::TextureId: 'static,
{
fn id(&self) -> &smithay::backend::renderer::element::Id {
match self {
@ -1633,12 +1633,12 @@ where
impl<R> RenderElement<R> for WorkspaceRenderElement<R>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
<R as Renderer>::Error: FromGlesError,
R::TextureId: 'static,
R::Error: FromGlesError,
{
fn draw(
&self,
frame: &mut R::Frame<'_>,
frame: &mut R::Frame<'_, '_>,
src: Rectangle<f64, BufferCoords>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, smithay::utils::Physical>],
@ -1688,7 +1688,7 @@ where
impl<R> From<RescaleRenderElement<CosmicWindowRenderElement<R>>> for WorkspaceRenderElement<R>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: RescaleRenderElement<CosmicWindowRenderElement<R>>) -> Self {
@ -1699,7 +1699,7 @@ where
impl<R> From<CosmicWindowRenderElement<R>> for WorkspaceRenderElement<R>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: CosmicWindowRenderElement<R>) -> Self {
@ -1710,7 +1710,7 @@ where
impl<R> From<WaylandSurfaceRenderElement<R>> for WorkspaceRenderElement<R>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: WaylandSurfaceRenderElement<R>) -> Self {
@ -1721,7 +1721,7 @@ where
impl<R> From<CosmicMappedRenderElement<R>> for WorkspaceRenderElement<R>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: CosmicMappedRenderElement<R>) -> Self {
@ -1732,7 +1732,7 @@ where
impl<R> From<TextureRenderElement<GlesTexture>> for WorkspaceRenderElement<R>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: TextureRenderElement<GlesTexture>) -> Self {

4
src/shell/zoom.rs
View file

@ -170,7 +170,7 @@ impl OutputZoomState {
where
C: From<<IcedElement<ZoomProgram> as AsRenderElements<R>>::RenderElement>,
R: Renderer + ImportMem,
<R as Renderer>::TextureId: Send + Clone + 'static,
R::TextureId: Send + Clone + 'static,
{
let size = self.element.current_size().to_f64();
let output_geo = output.geometry().to_f64();
@ -372,7 +372,7 @@ impl ZoomState {
where
C: From<<IcedElement<ZoomProgram> as AsRenderElements<R>>::RenderElement>,
R: Renderer + ImportMem,
<R as Renderer>::TextureId: Send + Clone + 'static,
R::TextureId: Send + Clone + 'static,
{
let output_state = output.user_data().get::<Mutex<OutputZoomState>>().unwrap();
output_state.lock().unwrap().render(renderer, output)

2
src/utils/iced.rs
View file

@ -903,7 +903,7 @@ impl<P, R> AsRenderElements<R> for IcedElement<P>
where
P: Program + Send + 'static,
R: Renderer + ImportMem,
<R as Renderer>::TextureId: Send + Clone + 'static,
R::TextureId: Send + Clone + 'static,
{
type RenderElement = MemoryRenderBufferRenderElement<R>;

17
src/utils/screenshot.rs
View file

@ -29,8 +29,8 @@ pub fn screenshot_window(state: &mut State, surface: &CosmicSurface) {
) -> anyhow::Result<()>
where
R: Renderer + ImportAll + Offscreen<GlesRenderbuffer> + ExportMem,
<R as Renderer>::TextureId: Clone + 'static,
<R as Renderer>::Error: Send + Sync + 'static,
R::TextureId: Clone + 'static,
R::Error: Send + Sync + 'static,
{
let bbox = bbox_from_surface_tree(&window.wl_surface().unwrap(), (0, 0));
let elements = AsRenderElements::<R>::render_elements::<WaylandSurfaceRenderElement<R>>(
@ -43,22 +43,25 @@ pub fn screenshot_window(state: &mut State, surface: &CosmicSurface) {
// TODO: 10-bit
let format = Fourcc::Abgr8888;
let render_buffer = Offscreen::<GlesRenderbuffer>::create_buffer(
let mut render_buffer = Offscreen::<GlesRenderbuffer>::create_buffer(
renderer,
format,
bbox.size.to_buffer(1, Transform::Normal),
)?;
renderer.bind(render_buffer)?;
let mut fb = renderer.bind(&mut render_buffer)?;
let mut output_damage_tracker =
OutputDamageTracker::new(bbox.size.to_physical(1), 1.0, Transform::Normal);
output_damage_tracker
.render_output(renderer, 0, &elements, [0.0, 0.0, 0.0, 0.0])
.render_output(renderer, &mut fb, 0, &elements, [0.0, 0.0, 0.0, 0.0])
.map_err(|err| match err {
smithay::backend::renderer::damage::Error::Rendering(err) => err,
smithay::backend::renderer::damage::Error::OutputNoMode(_) => unreachable!(),
})?;
let mapping =
renderer.copy_framebuffer(bbox.to_buffer(1, Transform::Normal, &bbox.size), format)?;
let mapping = renderer.copy_framebuffer(
&mut fb,
bbox.to_buffer(1, Transform::Normal, &bbox.size),
format,
)?;
let gl_data = renderer.map_texture(&mapping)?;
if let Ok(Some(path)) = xdg_user::pictures() {

219
src/wayland/handlers/screencopy/render.rs
View file

@ -57,13 +57,14 @@ use super::super::data_device::get_dnd_icon;
pub fn submit_buffer<R>(
frame: Frame,
renderer: &mut R,
offscreen: Option<&mut R::Framebuffer<'_>>,
transform: Transform,
damage: Option<&[Rectangle<i32, Physical>]>,
sync: SyncPoint,
) -> Result<Option<(Frame, Vec<Rectangle<i32, BufferCoords>>)>, <R as Renderer>::Error>
) -> Result<Option<(Frame, Vec<Rectangle<i32, BufferCoords>>)>, R::Error>
where
R: ExportMem,
<R as Renderer>::Error: FromGlesError,
R::Error: FromGlesError,
{
let Some(damage) = damage else {
frame.success(
@ -77,7 +78,8 @@ where
};
let buffer = frame.buffer();
if matches!(buffer_type(&buffer), Some(BufferType::Shm)) {
if let Some(fb) = offscreen {
assert!(matches!(buffer_type(&buffer), Some(BufferType::Shm)));
let buffer_size = buffer_dimensions(&buffer).unwrap();
if let Err(err) = with_buffer_contents_mut(&buffer, |ptr, len, data| {
let offset = data.offset;
@ -98,7 +100,8 @@ where
renderer.wait(&sync)?;
let format = get_transparent(format).unwrap_or(format);
let mapping = renderer.copy_framebuffer(Rectangle::from_size(buffer_size), format)?;
let mapping =
renderer.copy_framebuffer(fb, Rectangle::from_size(buffer_size), format)?;
let gl_data = renderer.map_texture(&mapping)?;
assert!((width * height * pixelsize) as usize <= gl_data.len());
@ -113,7 +116,7 @@ where
}
Ok(())
})
.map_err(|err| <R as Renderer>::Error::from_gles_error(GlesError::BufferAccessError(err)))
.map_err(|err| R::Error::from_gles_error(GlesError::BufferAccessError(err)))
.and_then(|x| x)
{
frame.fail(FailureReason::Unknown);
@ -133,31 +136,51 @@ where
)))
}
pub fn render_session<F, R>(
pub fn render_session<F, R, T>(
renderer: &mut R,
session: &SessionData,
frame: Frame,
transform: Transform,
render_fn: F,
) -> Result<Option<(Frame, Vec<Rectangle<i32, BufferCoords>>)>, DTError<<R as Renderer>::Error>>
) -> Result<Option<(Frame, Vec<Rectangle<i32, BufferCoords>>)>, DTError<R::Error>>
where
R: ExportMem,
<R as Renderer>::Error: FromGlesError,
F: for<'d> FnOnce(
R: ExportMem + Offscreen<T>,
R::Error: FromGlesError,
F: for<'d, 'f> FnOnce(
&WlBuffer,
&mut R,
Option<&mut R::Framebuffer<'f>>,
&'d mut OutputDamageTracker,
usize,
Vec<Rectangle<i32, BufferCoords>>,
) -> Result<RenderOutputResult<'d>, DTError<<R as Renderer>::Error>>,
) -> Result<RenderOutputResult<'d>, DTError<R::Error>>,
{
let mut session_damage_tracking = session.lock().unwrap();
let buffer = frame.buffer();
let mut offscreen = matches!(buffer_type(&buffer), Some(BufferType::Shm))
.then(|| {
let size = buffer_dimensions(&buffer).ok_or(DTError::OutputNoMode(OutputNoMode))?;
let format = with_buffer_contents(&buffer, |_, _, data| {
shm_format_to_fourcc(data.format)
.expect("We should be able to convert all hardcoded shm screencopy formats")
})
.map_err(|_| DTError::OutputNoMode(OutputNoMode))?;
renderer
.create_buffer(format, size)
.map_err(DTError::Rendering)
})
.transpose()?;
let age = session_damage_tracking.age_for_buffer(&buffer);
let mut fb = offscreen
.as_mut()
.map(|tex| renderer.bind(tex).map_err(DTError::Rendering))
.transpose()?;
let res = render_fn(
&frame.buffer(),
renderer,
fb.as_mut(),
&mut session_damage_tracking.dt,
age,
frame.damage(),
@ -167,6 +190,7 @@ where
Ok(result) => submit_buffer(
frame,
renderer,
fb.as_mut(),
transform,
result.damage.map(|x| x.as_slice()),
result.sync,
@ -217,6 +241,7 @@ pub fn render_workspace_to_buffer(
fn render_fn<'d, R>(
buffer: &WlBuffer,
renderer: &mut R,
offscreen: Option<&mut R::Framebuffer<'_>>,
dt: &'d mut OutputDamageTracker,
mut age: usize,
additional_damage: Vec<Rectangle<i32, BufferCoords>>,
@ -224,18 +249,11 @@ pub fn render_workspace_to_buffer(
common: &mut Common,
output: &Output,
handle: (WorkspaceHandle, usize),
) -> Result<RenderOutputResult<'d>, DTError<<R as Renderer>::Error>>
) -> Result<RenderOutputResult<'d>, DTError<R::Error>>
where
R: Renderer
+ ImportAll
+ ImportMem
+ ExportMem
+ Bind<Dmabuf>
+ Offscreen<GlesRenderbuffer>
+ Blit<Dmabuf>
+ AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static,
<R as Renderer>::Error: FromGlesError,
R: Renderer + ImportAll + ImportMem + ExportMem + Bind<Dmabuf> + Blit + AsGlowRenderer,
R::TextureId: Send + Clone + 'static,
R::Error: FromGlesError,
CosmicElement<R>: RenderElement<R>,
CosmicMappedRenderElement<R>: RenderElement<R>,
WorkspaceRenderElement<R>: RenderElement<R>,
@ -273,10 +291,12 @@ pub fn render_workspace_to_buffer(
});
if let Ok(dmabuf) = get_dmabuf(buffer) {
render_workspace::<_, _, GlesRenderbuffer>(
let mut dmabuf = dmabuf.clone();
let mut fb = renderer.bind(&mut dmabuf).map_err(DTError::Rendering)?;
render_workspace(
None,
renderer,
dmabuf.clone(),
&mut fb,
dt,
age,
additional_damage,
@ -291,23 +311,12 @@ pub fn render_workspace_to_buffer(
)
.map(|res| res.0)
} else {
let size = buffer_dimensions(buffer).unwrap();
let format =
with_buffer_contents(buffer, |_, _, data| shm_format_to_fourcc(data.format))
.map_err(|err| {
DTError::Rendering(<R as Renderer>::Error::from_gles_error(
GlesError::BufferAccessError(err),
))
})?
.expect("We should be able to convert all hardcoded shm screencopy formats");
let render_buffer =
Offscreen::<GlesRenderbuffer>::create_buffer(renderer, format, size)
.map_err(DTError::Rendering)?;
let target = offscreen.expect("shm buffers should have an offscreen target");
age = 0;
render_workspace::<_, _, GlesRenderbuffer>(
render_workspace(
None,
renderer,
render_buffer,
target,
dt,
age,
additional_damage,
@ -359,15 +368,16 @@ pub fn render_workspace_to_buffer(
};
let result = match renderer {
RendererRef::Glow(renderer) => {
match render_session::<_, _>(
match render_session::<_, _, GlesRenderbuffer>(
renderer,
session.user_data().get::<SessionData>().unwrap(),
frame,
transform,
|buffer, renderer, dt, age, additional_damage| {
|buffer, renderer, offscreen, dt, age, additional_damage| {
render_fn(
buffer,
renderer,
offscreen,
dt,
age,
additional_damage,
@ -386,15 +396,16 @@ pub fn render_workspace_to_buffer(
}
}
RendererRef::GlMulti(mut renderer) => {
match render_session::<_, _>(
match render_session::<_, _, GlesRenderbuffer>(
&mut renderer,
session.user_data().get::<SessionData>().unwrap(),
frame,
transform,
|buffer, renderer, dt, age, additional_damage| {
|buffer, renderer, offscreen, dt, age, additional_damage| {
render_fn(
buffer,
renderer,
offscreen,
dt,
age,
additional_damage,
@ -458,25 +469,19 @@ pub fn render_window_to_buffer(
fn render_fn<'d, R>(
buffer: &WlBuffer,
renderer: &mut R,
offscreen: Option<&mut R::Framebuffer<'_>>,
dt: &'d mut OutputDamageTracker,
mut age: usize,
age: usize,
additional_damage: Vec<Rectangle<i32, BufferCoords>>,
draw_cursor: bool,
common: &mut Common,
window: &CosmicSurface,
geometry: Rectangle<i32, Logical>,
) -> Result<RenderOutputResult<'d>, DTError<<R as Renderer>::Error>>
) -> Result<RenderOutputResult<'d>, DTError<R::Error>>
where
R: Renderer
+ ImportAll
+ ImportMem
+ ExportMem
+ Bind<Dmabuf>
+ Offscreen<GlesRenderbuffer>
+ Blit<Dmabuf>
+ AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static,
<R as Renderer>::Error: FromGlesError,
R: Renderer + ImportAll + ImportMem + ExportMem + Bind<Dmabuf> + Blit + AsGlowRenderer,
R::TextureId: Send + Clone + 'static,
R::Error: FromGlesError,
CosmicElement<R>: RenderElement<R>,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
@ -557,25 +562,15 @@ pub fn render_window_to_buffer(
}
if let Ok(dmabuf) = get_dmabuf(buffer) {
renderer.bind(dmabuf.clone()).map_err(DTError::Rendering)?;
} else {
let size = buffer_dimensions(buffer).unwrap();
let format =
with_buffer_contents(buffer, |_, _, data| shm_format_to_fourcc(data.format))
.map_err(|err| {
DTError::Rendering(<R as Renderer>::Error::from_gles_error(
GlesError::BufferAccessError(err),
))
})?
.expect("We should be able to convert all hardcoded shm screencopy formats");
let render_buffer =
Offscreen::<GlesRenderbuffer>::create_buffer(renderer, format, size)
let mut dmabuf_clone = dmabuf.clone();
let mut fb = renderer
.bind(&mut dmabuf_clone)
.map_err(DTError::Rendering)?;
age = 0;
renderer.bind(render_buffer).map_err(DTError::Rendering)?;
dt.render_output(renderer, &mut fb, age, &elements, Color32F::TRANSPARENT)
} else {
let fb = offscreen.expect("shm buffer should have an offscreen target");
dt.render_output(renderer, fb, 0, &elements, Color32F::TRANSPARENT)
}
dt.render_output(renderer, age, &elements, Color32F::TRANSPARENT)
}
let common = &mut state.common;
@ -607,15 +602,16 @@ pub fn render_window_to_buffer(
}
};
let result = match renderer {
RendererRef::Glow(renderer) => match render_session::<_, _>(
RendererRef::Glow(renderer) => match render_session::<_, _, GlesRenderbuffer>(
renderer,
session.user_data().get::<SessionData>().unwrap(),
frame,
Transform::Normal,
|buffer, renderer, dt, age, additional_damage| {
|buffer, renderer, offscreen, dt, age, additional_damage| {
render_fn(
buffer,
renderer,
offscreen,
dt,
age,
additional_damage,
@ -632,15 +628,16 @@ pub fn render_window_to_buffer(
None
}
},
RendererRef::GlMulti(mut renderer) => match render_session::<_, _>(
RendererRef::GlMulti(mut renderer) => match render_session::<_, _, GlesRenderbuffer>(
&mut renderer,
session.user_data().get::<SessionData>().unwrap(),
frame,
Transform::Normal,
|buffer, renderer, dt, age, additional_damage| {
|buffer, renderer, offscreen, dt, age, additional_damage| {
render_fn(
buffer,
renderer,
offscreen,
dt,
age,
additional_damage,
@ -697,23 +694,17 @@ pub fn render_cursor_to_buffer(
fn render_fn<'d, R>(
buffer: &WlBuffer,
renderer: &mut R,
offscreen: Option<&mut R::Framebuffer<'_>>,
dt: &'d mut OutputDamageTracker,
mut age: usize,
age: usize,
additional_damage: Vec<Rectangle<i32, BufferCoords>>,
common: &mut Common,
seat: &Seat<State>,
) -> Result<RenderOutputResult<'d>, DTError<<R as Renderer>::Error>>
) -> Result<RenderOutputResult<'d>, DTError<R::Error>>
where
R: Renderer
+ ImportAll
+ ImportMem
+ ExportMem
+ Bind<Dmabuf>
+ Offscreen<GlesRenderbuffer>
+ Blit<Dmabuf>
+ AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static,
<R as Renderer>::Error: FromGlesError,
R: Renderer + ImportAll + ImportMem + ExportMem + Bind<Dmabuf> + Blit + AsGlowRenderer,
R::TextureId: Send + Clone + 'static,
R::Error: FromGlesError,
CosmicElement<R>: RenderElement<R>,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
@ -743,25 +734,15 @@ pub fn render_cursor_to_buffer(
);
if let Ok(dmabuf) = get_dmabuf(buffer) {
renderer.bind(dmabuf.clone()).map_err(DTError::Rendering)?;
} else {
let size = buffer_dimensions(buffer).unwrap();
let format =
with_buffer_contents(buffer, |_, _, data| shm_format_to_fourcc(data.format))
.map_err(|err| {
DTError::Rendering(<R as Renderer>::Error::from_gles_error(
GlesError::BufferAccessError(err),
))
})?
.expect("We should be able to convert all hardcoded shm screencopy formats");
let render_buffer =
Offscreen::<GlesRenderbuffer>::create_buffer(renderer, format, size)
let mut dmabuf_clone = dmabuf.clone();
let mut fb = renderer
.bind(&mut dmabuf_clone)
.map_err(DTError::Rendering)?;
age = 0;
renderer.bind(render_buffer).map_err(DTError::Rendering)?;
dt.render_output(renderer, &mut fb, age, &elements, [0.0, 0.0, 0.0, 0.0])
} else {
let fb = offscreen.expect("shm buffers should have offscreen target");
dt.render_output(renderer, fb, 0, &elements, [0.0, 0.0, 0.0, 0.0])
}
dt.render_output(renderer, age, &elements, [0.0, 0.0, 0.0, 0.0])
}
let common = &mut state.common;
@ -775,13 +756,22 @@ pub fn render_cursor_to_buffer(
};
let result = match renderer {
RendererRef::Glow(renderer) => {
match render_session::<_, _>(
match render_session::<_, _, GlesRenderbuffer>(
renderer,
session.user_data().get::<SessionData>().unwrap(),
frame,
Transform::Normal,
|buffer, renderer, dt, age, additional_damage| {
render_fn(buffer, renderer, dt, age, additional_damage, common, seat)
|buffer, renderer, offscreen, dt, age, additional_damage| {
render_fn(
buffer,
renderer,
offscreen,
dt,
age,
additional_damage,
common,
seat,
)
},
) {
Ok(frame) => frame,
@ -792,13 +782,22 @@ pub fn render_cursor_to_buffer(
}
}
RendererRef::GlMulti(mut renderer) => {
match render_session::<_, _>(
match render_session::<_, _, GlesRenderbuffer>(
&mut renderer,
session.user_data().get::<SessionData>().unwrap(),
frame,
Transform::Normal,
|buffer, renderer, dt, age, additional_damage| {
render_fn(buffer, renderer, dt, age, additional_damage, common, seat)
|buffer, renderer, offscreen, dt, age, additional_damage| {
render_fn(
buffer,
renderer,
offscreen,
dt,
age,
additional_damage,
common,
seat,
)
},
) {
Ok(frame) => frame,