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

8
Cargo.toml
View file

@ -84,13 +84,14 @@ features = [
"wayland_frontend", "wayland_frontend",
"xwayland", "xwayland",
] ]
version = "0.4" git = "https://github.com/smithay/smithay"
rev = "a503d98"
[dependencies.smithay-egui] [dependencies.smithay-egui]
features = ["svg"] features = ["svg"]
git = "https://github.com/Smithay/smithay-egui.git" git = "https://github.com/Smithay/smithay-egui.git"
optional = true optional = true
rev = "e9411da" rev = "e720136"
[features] [features]
debug = ["egui", "egui_plot", "smithay-egui", "anyhow/backtrace"] debug = ["egui", "egui_plot", "smithay-egui", "anyhow/backtrace"]
@ -114,9 +115,6 @@ inherits = "release"
[profile.release] [profile.release]
lto = "fat" lto = "fat"
[patch.crates-io]
smithay = { git = "https://github.com/smithay/smithay.git", rev = "f93476c" }
[patch."https://github.com/pop-os/cosmic-protocols"] [patch."https://github.com/pop-os/cosmic-protocols"]
cosmic-protocols = { git = "https://github.com/pop-os//cosmic-protocols", rev = "e706814" } 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" } 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, gles::GlesError,
glow::GlowRenderer, glow::GlowRenderer,
multigpu::{ApiDevice, Error as MultiError, GraphicsApi}, multigpu::{ApiDevice, Error as MultiError, GraphicsApi},
Renderer, RendererSuper,
}, },
SwapBuffersError, SwapBuffersError,
}; };
@ -182,7 +182,7 @@ impl ApiDevice for GbmGlowDevice {
impl<T: GraphicsApi, A: AsFd + Clone + 'static> FromGlesError for MultiError<GbmGlowBackend<A>, T> impl<T: GraphicsApi, A: AsFd + Clone + 'static> FromGlesError for MultiError<GbmGlowBackend<A>, T>
where where
T::Error: 'static, T::Error: 'static,
<<T::Device as ApiDevice>::Renderer as Renderer>::Error: 'static, <<T::Device as ApiDevice>::Renderer as RendererSuper>::Error: 'static,
{ {
#[inline] #[inline]
fn from_gles_error(err: GlesError) -> MultiError<GbmGlowBackend<A>, T> { fn from_gles_error(err: GlesError) -> MultiError<GbmGlowBackend<A>, T> {

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

@ -45,7 +45,7 @@ use smithay::{
multigpu::{Error as MultiError, GpuManager}, multigpu::{Error as MultiError, GpuManager},
sync::SyncPoint, sync::SyncPoint,
utils::with_renderer_surface_state, utils::with_renderer_surface_state,
Bind, ImportDma, Offscreen, Renderer, Texture, Bind, ImportDma, Offscreen, Renderer, RendererSuper, Texture,
}, },
}, },
desktop::utils::OutputPresentationFeedback, desktop::utils::OutputPresentationFeedback,
@ -93,13 +93,6 @@ use super::{drm_helpers, render::gles::GbmGlowBackend};
#[cfg(feature = "debug")] #[cfg(feature = "debug")]
use smithay_egui::EguiState; 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)] #[derive(Debug)]
pub struct Surface { pub struct Surface {
pub(crate) connector: connector::Handle, pub(crate) connector: connector::Handle,
@ -740,19 +733,6 @@ impl SurfaceThreadState {
unsafe { GlowRenderer::new(egl) }.context("Failed to create renderer")?; unsafe { GlowRenderer::new(egl) }.context("Failed to create renderer")?;
init_shaders(renderer.borrow_mut()).context("Failed to initialize shaders")?; 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); self.api.as_mut().add_node(node, gbm, renderer);
/* /*
} else { } else {
@ -1107,10 +1087,11 @@ impl SurfaceThreadState {
mirroring_state mirroring_state
.texture .texture
.render() .render()
.draw::<_, <GlMultiRenderer as Renderer>::Error>(|tex| { .draw::<_, <GlMultiRenderer as RendererSuper>::Error>(|tex| {
let res = match mirroring_state.damage_tracker.render_output_with( let mut fb = renderer.bind(tex)?;
let res = match mirroring_state.damage_tracker.render_output(
&mut renderer, &mut renderer,
tex.clone(), &mut fb,
1, 1,
&elements, &elements,
CLEAR_COLOR, CLEAR_COLOR,
@ -1119,8 +1100,8 @@ impl SurfaceThreadState {
Err(RenderError::Rendering(err)) => return Err(err), Err(RenderError::Rendering(err)) => return Err(err),
Err(RenderError::OutputNoMode(_)) => unreachable!(), Err(RenderError::OutputNoMode(_)) => unreachable!(),
}; };
renderer.wait(&res.sync)?; renderer.wait(&res.sync)?;
std::mem::drop(fb);
let transform = mirrored_output.current_transform(); let transform = mirrored_output.current_transform();
let area = tex.size().to_logical(1, transform); let area = tex.size().to_logical(1, transform);
@ -1235,34 +1216,39 @@ impl SurfaceThreadState {
let mut sync = SyncPoint::default(); let mut sync = SyncPoint::default();
if let Some(ref damage) = damage { let mut dmabuf_clone;
let buffer = frame.buffer(); let mut render_buffer;
if let Ok(dmabuf) = get_dmabuf(&buffer) { let buffer = frame.buffer();
renderer let mut shm_buffer = false;
.bind(dmabuf.clone()) let mut fb = if let Ok(dmabuf) = get_dmabuf(&buffer) {
.map_err(RenderError::<<GlMultiRenderer as Renderer>::Error>::Rendering)?; dmabuf_clone = dmabuf.clone();
} else { renderer
let size = buffer_dimensions(&buffer).ok_or(RenderError::< .bind(&mut dmabuf_clone)
<GlMultiRenderer as Renderer>::Error, .map_err(RenderError::<<GlMultiRenderer as RendererSuper>::Error>::Rendering)?
>::Rendering( } else {
MultiError::ImportFailed, shm_buffer = true;
))?; let size = buffer_dimensions(&buffer).ok_or(RenderError::<
let format = <GlMultiRenderer as RendererSuper>::Error,
with_buffer_contents(&buffer, |_, _, data| shm_format_to_fourcc(data.format)) >::Rendering(
.map_err(|_| OutputNoMode)? // eh, we have to do some error MultiError::ImportFailed,
.expect("We should be able to convert all hardcoded shm screencopy formats"); ))?;
let render_buffer = let format =
Offscreen::<GlesRenderbuffer>::create_buffer( with_buffer_contents(&buffer, |_, _, data| shm_format_to_fourcc(data.format))
&mut renderer, .map_err(|_| OutputNoMode)? // eh, we have to do some error
format, .expect("We should be able to convert all hardcoded shm screencopy formats");
size, render_buffer =
) Offscreen::<GlesRenderbuffer>::create_buffer(
.map_err(RenderError::<<GlMultiRenderer as Renderer>::Error>::Rendering)?; &mut renderer,
renderer format,
.bind(render_buffer) size,
.map_err(RenderError::<<GlMultiRenderer as Renderer>::Error>::Rendering)?; )
} .map_err(RenderError::<<GlMultiRenderer as RendererSuper>::Error>::Rendering)?;
renderer
.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) = ( let (output_size, output_scale, output_transform) = (
self.output.current_mode().ok_or(OutputNoMode)?.size, self.output.current_mode().ok_or(OutputNoMode)?.size,
self.output.current_scale().fractional_scale(), self.output.current_scale().fractional_scale(),
@ -1292,23 +1278,25 @@ impl SurfaceThreadState {
.to_physical(1); .to_physical(1);
d d
}); });
match frame_result match frame_result
.blit_frame_result( .blit_frame_result(
output_size, output_size,
output_transform, output_transform,
output_scale, output_scale,
&mut renderer, &mut renderer,
&mut fb,
adjusted, adjusted,
filter, filter,
) )
.map_err(|err| match err { .map_err(|err| match err {
BlitFrameResultError::Rendering(err) => RenderError::< BlitFrameResultError::Rendering(err) => RenderError::<
<GlMultiRenderer as Renderer>::Error, <GlMultiRenderer as RendererSuper>::Error,
>::Rendering( >::Rendering(
err err
), ),
BlitFrameResultError::Export(_) => RenderError::< BlitFrameResultError::Export(_) => RenderError::<
<GlMultiRenderer as Renderer>::Error, <GlMultiRenderer as RendererSuper>::Error,
>::Rendering( >::Rendering(
MultiError::DeviceMissing, MultiError::DeviceMissing,
), ),
@ -1329,13 +1317,14 @@ impl SurfaceThreadState {
continue; continue;
} }
}; };
} };
let transform = self.output.current_transform(); let transform = self.output.current_transform();
match submit_buffer( match submit_buffer(
frame, frame,
&mut renderer, &mut renderer,
shm_buffer.then_some(&mut fb),
transform, transform,
damage.as_deref(), damage.as_deref(),
sync, 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>)> ) -> Vec<(CursorRenderElement<R>, Point<i32, BufferCoords>)>
where where
R: Renderer + ImportAll, R: Renderer + ImportAll,
<R as Renderer>::TextureId: Clone + 'static, R::TextureId: Clone + 'static,
{ {
let position = location.into(); let position = location.into();
let scale = scale.into(); let scale = scale.into();
@ -172,7 +172,7 @@ pub fn draw_dnd_icon<R>(
) -> Vec<WaylandSurfaceRenderElement<R>> ) -> Vec<WaylandSurfaceRenderElement<R>>
where where
R: Renderer + ImportAll, R: Renderer + ImportAll,
<R as Renderer>::TextureId: Clone + 'static, R::TextureId: Clone + 'static,
{ {
if get_role(&surface) != Some("dnd_icon") { if get_role(&surface) != Some("dnd_icon") {
warn!( warn!(
@ -262,7 +262,7 @@ pub fn draw_cursor<R>(
) -> Vec<(CursorRenderElement<R>, Point<i32, BufferCoords>)> ) -> Vec<(CursorRenderElement<R>, Point<i32, BufferCoords>)>
where where
R: Renderer + ImportMem + ImportAll, R: Renderer + ImportMem + ImportAll,
<R as Renderer>::TextureId: Send + Clone + 'static, R::TextureId: Send + Clone + 'static,
{ {
// draw the cursor as relevant // draw the cursor as relevant
// reset the cursor if the surface is no longer alive // 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> pub enum CosmicElement<R>
where where
R: AsGlowRenderer + Renderer + ImportAll + ImportMem, R: AsGlowRenderer + Renderer + ImportAll + ImportMem,
<R as Renderer>::TextureId: 'static, R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
{ {
Workspace( Workspace(
@ -45,7 +45,7 @@ where
impl<R> Element for CosmicElement<R> impl<R> Element for CosmicElement<R>
where where
R: AsGlowRenderer + Renderer + ImportAll + ImportMem, R: AsGlowRenderer + Renderer + ImportAll + ImportMem,
<R as Renderer>::TextureId: 'static, R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
{ {
fn id(&self) -> &Id { fn id(&self) -> &Id {
@ -196,13 +196,13 @@ where
impl<R> RenderElement<R> for CosmicElement<R> impl<R> RenderElement<R> for CosmicElement<R>
where where
R: AsGlowRenderer + Renderer + ImportAll + ImportMem, R: AsGlowRenderer + Renderer + ImportAll + ImportMem,
<R as Renderer>::TextureId: 'static, R::TextureId: 'static,
<R as Renderer>::Error: FromGlesError, R::Error: FromGlesError,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
{ {
fn draw( fn draw(
&self, &self,
frame: &mut R::Frame<'_>, frame: &mut R::Frame<'_, '_>,
src: Rectangle<f64, BufferCoords>, src: Rectangle<f64, BufferCoords>,
dst: Rectangle<i32, Physical>, dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>], damage: &[Rectangle<i32, Physical>],
@ -286,7 +286,7 @@ impl<R> From<CropRenderElement<RescaleRenderElement<WorkspaceRenderElement<R>>>>
for CosmicElement<R> for CosmicElement<R>
where where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer, R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static, R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
{ {
fn from(elem: CropRenderElement<RescaleRenderElement<WorkspaceRenderElement<R>>>) -> Self { fn from(elem: CropRenderElement<RescaleRenderElement<WorkspaceRenderElement<R>>>) -> Self {
@ -301,7 +301,7 @@ where
impl<R> From<DamageElement> for CosmicElement<R> impl<R> From<DamageElement> for CosmicElement<R>
where where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer, R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static, R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
{ {
fn from(elem: DamageElement) -> Self { fn from(elem: DamageElement) -> Self {
@ -312,7 +312,7 @@ where
impl<R> From<MemoryRenderBufferRenderElement<R>> for CosmicElement<R> impl<R> From<MemoryRenderBufferRenderElement<R>> for CosmicElement<R>
where where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer, R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static, R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
{ {
fn from(value: MemoryRenderBufferRenderElement<R>) -> Self { fn from(value: MemoryRenderBufferRenderElement<R>) -> Self {
@ -324,7 +324,7 @@ where
impl<R> From<TextureRenderElement<GlesTexture>> for CosmicElement<R> impl<R> From<TextureRenderElement<GlesTexture>> for CosmicElement<R>
where where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer, R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static, R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
{ {
fn from(elem: TextureRenderElement<GlesTexture>) -> Self { fn from(elem: TextureRenderElement<GlesTexture>) -> Self {
@ -338,8 +338,12 @@ where
{ {
fn glow_renderer(&self) -> &GlowRenderer; fn glow_renderer(&self) -> &GlowRenderer;
fn glow_renderer_mut(&mut self) -> &mut 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<'a, 'frame, 'buffer>(
fn glow_frame_mut<'a, 'frame>(frame: &'a mut Self::Frame<'frame>) -> &'a mut GlowFrame<'frame>; 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 { impl AsGlowRenderer for GlowRenderer {
@ -349,10 +353,14 @@ impl AsGlowRenderer for GlowRenderer {
fn glow_renderer_mut(&mut self) -> &mut GlowRenderer { fn glow_renderer_mut(&mut self) -> &mut GlowRenderer {
self 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 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 frame
} }
} }
@ -364,10 +372,14 @@ impl<'a> AsGlowRenderer for GlMultiRenderer<'a> {
fn glow_renderer_mut(&mut self) -> &mut GlowRenderer { fn glow_renderer_mut(&mut self) -> &mut GlowRenderer {
self.as_mut() 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() 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() frame.as_mut()
} }
} }
@ -415,12 +427,12 @@ impl Element for DamageElement {
impl<R: Renderer> RenderElement<R> for DamageElement { impl<R: Renderer> RenderElement<R> for DamageElement {
fn draw( fn draw(
&self, &self,
_frame: &mut <R as Renderer>::Frame<'_>, _frame: &mut R::Frame<'_, '_>,
_src: Rectangle<f64, BufferCoords>, _src: Rectangle<f64, BufferCoords>,
_dst: Rectangle<i32, Physical>, _dst: Rectangle<i32, Physical>,
_damage: &[Rectangle<i32, Physical>], _damage: &[Rectangle<i32, Physical>],
_opaque_regions: &[Rectangle<i32, Physical>], _opaque_regions: &[Rectangle<i32, Physical>],
) -> Result<(), <R as Renderer>::Error> { ) -> Result<(), R::Error> {
Ok(()) Ok(())
} }
} }

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

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

17
src/backend/winit.rs
View file

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

9
src/backend/x11.rs
View file

@ -202,14 +202,17 @@ pub struct Surface {
impl Surface { impl Surface {
pub fn render_output(&mut self, renderer: &mut GlowRenderer, state: &mut Common) -> Result<()> { pub fn render_output(&mut self, renderer: &mut GlowRenderer, state: &mut Common) -> Result<()> {
let (buffer, age) = self let (mut buffer, age) = self
.surface .surface
.buffer() .buffer()
.with_context(|| "Failed to allocate 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, None,
renderer, renderer,
buffer.clone(), &mut fb,
&mut self.damage_tracker, &mut self.damage_tracker,
age as usize, age as usize,
&state.shell, &state.shell,

51
src/debug.rs
View file

@ -1,13 +1,11 @@
// SPDX-License-Identifier: GPL-3.0-only // SPDX-License-Identifier: GPL-3.0-only
use std::collections::HashMap;
use crate::{ use crate::{
backend::kms::Timings, backend::kms::Timings,
shell::focus::target::{KeyboardFocusTarget, PointerFocusTarget, PointerFocusToplevel}, shell::focus::target::{KeyboardFocusTarget, PointerFocusTarget, PointerFocusToplevel},
State, State,
}; };
use egui::{load::SizedTexture, Color32, Vec2}; use egui::Color32;
use smithay::{ use smithay::{
backend::{ backend::{
drm::DrmNode, drm::DrmNode,
@ -97,33 +95,6 @@ pub fn fps_ui<'a>(
}) })
.unzip(); .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( state.render(
|ctx| { |ctx| {
egui::Area::new("main".into()) egui::Area::new("main".into())
@ -152,11 +123,21 @@ pub fn fps_ui<'a>(
"/sys/class/drm/renderD{}/device/vendor", "/sys/class/drm/renderD{}/device/vendor",
gpu.minor() gpu.minor()
)) { )) {
if let Some((texture_id, mut size)) = vendors.get(vendor.trim()) if let Some(img) = match vendor.trim() {
{ "0x10de" => Some(egui::include_image!(
let factor = resp.rect.height() / size.y; "../resources/icons/nvidia.svg"
size = Vec2::from([size.x * factor, resp.rect.height()]); )),
ui.image(SizedTexture::new(*texture_id, size)); "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> ) -> Vec<C>
where where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer, R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static, R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
C: From<CosmicMappedRenderElement<R>>, C: From<CosmicMappedRenderElement<R>>,
{ {
@ -654,7 +654,7 @@ impl CosmicMapped {
) -> Vec<C> ) -> Vec<C>
where where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer, R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static, R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
C: From<CosmicMappedRenderElement<R>>, C: From<CosmicMappedRenderElement<R>>,
{ {
@ -1046,7 +1046,7 @@ impl From<CosmicStack> for CosmicMapped {
pub enum CosmicMappedRenderElement<R> pub enum CosmicMappedRenderElement<R>
where where
R: Renderer + ImportAll + ImportMem, R: Renderer + ImportAll + ImportMem,
<R as Renderer>::TextureId: 'static, R::TextureId: 'static,
{ {
Stack(self::stack::CosmicStackRenderElement<R>), Stack(self::stack::CosmicStackRenderElement<R>),
Window(self::window::CosmicWindowRenderElement<R>), Window(self::window::CosmicWindowRenderElement<R>),
@ -1081,7 +1081,7 @@ where
impl<R> Element for CosmicMappedRenderElement<R> impl<R> Element for CosmicMappedRenderElement<R>
where where
R: Renderer + ImportAll + ImportMem, R: Renderer + ImportAll + ImportMem,
<R as Renderer>::TextureId: 'static, R::TextureId: 'static,
{ {
fn id(&self) -> &smithay::backend::renderer::element::Id { fn id(&self) -> &smithay::backend::renderer::element::Id {
match self { match self {
@ -1264,12 +1264,12 @@ where
impl<R> RenderElement<R> for CosmicMappedRenderElement<R> impl<R> RenderElement<R> for CosmicMappedRenderElement<R>
where where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer, R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static, R::TextureId: 'static,
<R as Renderer>::Error: FromGlesError, R::Error: FromGlesError,
{ {
fn draw( fn draw(
&self, &self,
frame: &mut R::Frame<'_>, frame: &mut R::Frame<'_, '_>,
src: Rectangle<f64, BufferCoords>, src: Rectangle<f64, BufferCoords>,
dst: Rectangle<i32, Physical>, dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>], damage: &[Rectangle<i32, Physical>],
@ -1385,7 +1385,7 @@ where
impl<R> From<stack::CosmicStackRenderElement<R>> for CosmicMappedRenderElement<R> impl<R> From<stack::CosmicStackRenderElement<R>> for CosmicMappedRenderElement<R>
where where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer, R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static, R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
{ {
fn from(elem: stack::CosmicStackRenderElement<R>) -> Self { fn from(elem: stack::CosmicStackRenderElement<R>) -> Self {
@ -1395,7 +1395,7 @@ where
impl<R> From<window::CosmicWindowRenderElement<R>> for CosmicMappedRenderElement<R> impl<R> From<window::CosmicWindowRenderElement<R>> for CosmicMappedRenderElement<R>
where where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer, R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static, R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
{ {
fn from(elem: window::CosmicWindowRenderElement<R>) -> Self { fn from(elem: window::CosmicWindowRenderElement<R>) -> Self {
@ -1406,7 +1406,7 @@ where
impl<R> From<PixelShaderElement> for CosmicMappedRenderElement<R> impl<R> From<PixelShaderElement> for CosmicMappedRenderElement<R>
where where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer, R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static, R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
{ {
fn from(elem: PixelShaderElement) -> Self { fn from(elem: PixelShaderElement) -> Self {
@ -1417,7 +1417,7 @@ where
impl<R> From<MemoryRenderBufferRenderElement<R>> for CosmicMappedRenderElement<R> impl<R> From<MemoryRenderBufferRenderElement<R>> for CosmicMappedRenderElement<R>
where where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer, R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static, R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
{ {
fn from(elem: MemoryRenderBufferRenderElement<R>) -> Self { fn from(elem: MemoryRenderBufferRenderElement<R>) -> Self {
@ -1429,7 +1429,7 @@ where
impl<R> From<TextureRenderElement<GlesTexture>> for CosmicMappedRenderElement<R> impl<R> From<TextureRenderElement<GlesTexture>> for CosmicMappedRenderElement<R>
where where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer, R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static, R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
{ {
fn from(elem: TextureRenderElement<GlesTexture>) -> Self { fn from(elem: TextureRenderElement<GlesTexture>) -> Self {

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

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

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

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

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

@ -312,7 +312,7 @@ impl CosmicWindow {
) -> Vec<C> ) -> Vec<C>
where where
R: Renderer + ImportAll + ImportMem, R: Renderer + ImportAll + ImportMem,
<R as Renderer>::TextureId: Send + Clone + 'static, R::TextureId: Send + Clone + 'static,
C: From<CosmicWindowRenderElement<R>>, C: From<CosmicWindowRenderElement<R>>,
{ {
let has_ssd = self.0.with_program(|p| p.has_ssd(false)); let has_ssd = self.0.with_program(|p| p.has_ssd(false));
@ -343,7 +343,7 @@ impl CosmicWindow {
) -> Vec<C> ) -> Vec<C>
where where
R: Renderer + ImportAll + ImportMem, R: Renderer + ImportAll + ImportMem,
<R as Renderer>::TextureId: Send + Clone + 'static, R::TextureId: Send + Clone + 'static,
C: From<CosmicWindowRenderElement<R>>, C: From<CosmicWindowRenderElement<R>>,
{ {
let has_ssd = self.0.with_program(|p| p.has_ssd(false)); 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> pub fn render<I, R>(&self, renderer: &mut R, output: &Output) -> Vec<I>
where where
R: Renderer + ImportMem, R: Renderer + ImportMem,
<R as Renderer>::TextureId: Send + Clone + 'static, R::TextureId: Send + Clone + 'static,
I: From<MemoryRenderBufferRenderElement<R>>, I: From<MemoryRenderBufferRenderElement<R>>,
{ {
let scale = output.current_scale().fractional_scale(); 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> pub fn render<I, R>(&self, renderer: &mut R, output: &Output, theme: &CosmicTheme) -> Vec<I>
where where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer, R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static, R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
I: From<CosmicMappedRenderElement<R>>, I: From<CosmicMappedRenderElement<R>>,
{ {

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

@ -1390,7 +1390,7 @@ impl FloatingLayout {
) -> Vec<CosmicMappedRenderElement<R>> ) -> Vec<CosmicMappedRenderElement<R>>
where where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer, R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static, R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>, CosmicWindowRenderElement<R>: RenderElement<R>,
CosmicStackRenderElement<R>: RenderElement<R>, CosmicStackRenderElement<R>: RenderElement<R>,
@ -1441,7 +1441,7 @@ impl FloatingLayout {
) -> Vec<CosmicMappedRenderElement<R>> ) -> Vec<CosmicMappedRenderElement<R>>
where where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer, R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static, R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>, CosmicWindowRenderElement<R>: RenderElement<R>,
CosmicStackRenderElement<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_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 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.x + third_width,
last_geometry.loc.y + third_height, last_geometry.loc.y + third_height,
@ -3942,7 +3942,7 @@ impl TilingLayout {
) -> Result<Vec<CosmicMappedRenderElement<R>>, OutputNotMapped> ) -> Result<Vec<CosmicMappedRenderElement<R>>, OutputNotMapped>
where where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer, R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static, R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>, CosmicWindowRenderElement<R>: RenderElement<R>,
CosmicStackRenderElement<R>: RenderElement<R>, CosmicStackRenderElement<R>: RenderElement<R>,
@ -4102,7 +4102,7 @@ impl TilingLayout {
) -> Result<Vec<CosmicMappedRenderElement<R>>, OutputNotMapped> ) -> Result<Vec<CosmicMappedRenderElement<R>>, OutputNotMapped>
where where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer, R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static, R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>, CosmicWindowRenderElement<R>: RenderElement<R>,
CosmicStackRenderElement<R>: RenderElement<R>, CosmicStackRenderElement<R>: RenderElement<R>,
@ -4276,7 +4276,7 @@ fn geometries_for_groupview<'a, R>(
) )
where where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer + 'a, R: Renderer + ImportAll + ImportMem + AsGlowRenderer + 'a,
<R as Renderer>::TextureId: 'static, R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>, CosmicWindowRenderElement<R>: RenderElement<R>,
{ {
@ -4906,7 +4906,7 @@ fn render_old_tree_popups<R>(
) -> Vec<CosmicMappedRenderElement<R>> ) -> Vec<CosmicMappedRenderElement<R>>
where where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer, R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static, R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>, CosmicWindowRenderElement<R>: RenderElement<R>,
CosmicStackRenderElement<R>: RenderElement<R>, CosmicStackRenderElement<R>: RenderElement<R>,
@ -4949,7 +4949,7 @@ fn render_old_tree_windows<R>(
) -> Vec<CosmicMappedRenderElement<R>> ) -> Vec<CosmicMappedRenderElement<R>>
where where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer, R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static, R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>, CosmicWindowRenderElement<R>: RenderElement<R>,
CosmicStackRenderElement<R>: RenderElement<R>, CosmicStackRenderElement<R>: RenderElement<R>,
@ -5115,7 +5115,7 @@ fn render_new_tree_popups<R>(
) -> Vec<CosmicMappedRenderElement<R>> ) -> Vec<CosmicMappedRenderElement<R>>
where where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer, R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static, R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>, CosmicWindowRenderElement<R>: RenderElement<R>,
CosmicStackRenderElement<R>: RenderElement<R>, CosmicStackRenderElement<R>: RenderElement<R>,
@ -5181,7 +5181,7 @@ fn render_new_tree_windows<R>(
) -> Vec<CosmicMappedRenderElement<R>> ) -> Vec<CosmicMappedRenderElement<R>>
where where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer, R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static, R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>, CosmicWindowRenderElement<R>: RenderElement<R>,
CosmicStackRenderElement<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> ) -> Result<Vec<WorkspaceRenderElement<R>>, OutputNotMapped>
where where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer, R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static, R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>, CosmicWindowRenderElement<R>: RenderElement<R>,
CosmicStackRenderElement<R>: RenderElement<R>, CosmicStackRenderElement<R>: RenderElement<R>,
@ -1363,7 +1363,7 @@ impl Workspace {
) -> Result<Vec<WorkspaceRenderElement<R>>, OutputNotMapped> ) -> Result<Vec<WorkspaceRenderElement<R>>, OutputNotMapped>
where where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer, R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static, R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>, CosmicWindowRenderElement<R>: RenderElement<R>,
CosmicStackRenderElement<R>: RenderElement<R>, CosmicStackRenderElement<R>: RenderElement<R>,
@ -1521,7 +1521,7 @@ pub struct OutputNotMapped;
pub enum WorkspaceRenderElement<R> pub enum WorkspaceRenderElement<R>
where where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer, R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static, R::TextureId: 'static,
{ {
OverrideRedirect(WaylandSurfaceRenderElement<R>), OverrideRedirect(WaylandSurfaceRenderElement<R>),
Fullscreen(RescaleRenderElement<CosmicWindowRenderElement<R>>), Fullscreen(RescaleRenderElement<CosmicWindowRenderElement<R>>),
@ -1533,7 +1533,7 @@ where
impl<R> Element for WorkspaceRenderElement<R> impl<R> Element for WorkspaceRenderElement<R>
where where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer, R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static, R::TextureId: 'static,
{ {
fn id(&self) -> &smithay::backend::renderer::element::Id { fn id(&self) -> &smithay::backend::renderer::element::Id {
match self { match self {
@ -1633,12 +1633,12 @@ where
impl<R> RenderElement<R> for WorkspaceRenderElement<R> impl<R> RenderElement<R> for WorkspaceRenderElement<R>
where where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer, R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static, R::TextureId: 'static,
<R as Renderer>::Error: FromGlesError, R::Error: FromGlesError,
{ {
fn draw( fn draw(
&self, &self,
frame: &mut R::Frame<'_>, frame: &mut R::Frame<'_, '_>,
src: Rectangle<f64, BufferCoords>, src: Rectangle<f64, BufferCoords>,
dst: Rectangle<i32, Physical>, dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, smithay::utils::Physical>], damage: &[Rectangle<i32, smithay::utils::Physical>],
@ -1688,7 +1688,7 @@ where
impl<R> From<RescaleRenderElement<CosmicWindowRenderElement<R>>> for WorkspaceRenderElement<R> impl<R> From<RescaleRenderElement<CosmicWindowRenderElement<R>>> for WorkspaceRenderElement<R>
where where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer, R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static, R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
{ {
fn from(elem: RescaleRenderElement<CosmicWindowRenderElement<R>>) -> Self { fn from(elem: RescaleRenderElement<CosmicWindowRenderElement<R>>) -> Self {
@ -1699,7 +1699,7 @@ where
impl<R> From<CosmicWindowRenderElement<R>> for WorkspaceRenderElement<R> impl<R> From<CosmicWindowRenderElement<R>> for WorkspaceRenderElement<R>
where where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer, R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static, R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
{ {
fn from(elem: CosmicWindowRenderElement<R>) -> Self { fn from(elem: CosmicWindowRenderElement<R>) -> Self {
@ -1710,7 +1710,7 @@ where
impl<R> From<WaylandSurfaceRenderElement<R>> for WorkspaceRenderElement<R> impl<R> From<WaylandSurfaceRenderElement<R>> for WorkspaceRenderElement<R>
where where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer, R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static, R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
{ {
fn from(elem: WaylandSurfaceRenderElement<R>) -> Self { fn from(elem: WaylandSurfaceRenderElement<R>) -> Self {
@ -1721,7 +1721,7 @@ where
impl<R> From<CosmicMappedRenderElement<R>> for WorkspaceRenderElement<R> impl<R> From<CosmicMappedRenderElement<R>> for WorkspaceRenderElement<R>
where where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer, R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static, R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
{ {
fn from(elem: CosmicMappedRenderElement<R>) -> Self { fn from(elem: CosmicMappedRenderElement<R>) -> Self {
@ -1732,7 +1732,7 @@ where
impl<R> From<TextureRenderElement<GlesTexture>> for WorkspaceRenderElement<R> impl<R> From<TextureRenderElement<GlesTexture>> for WorkspaceRenderElement<R>
where where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer, R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static, R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
{ {
fn from(elem: TextureRenderElement<GlesTexture>) -> Self { fn from(elem: TextureRenderElement<GlesTexture>) -> Self {

4
src/shell/zoom.rs
View file

@ -170,7 +170,7 @@ impl OutputZoomState {
where where
C: From<<IcedElement<ZoomProgram> as AsRenderElements<R>>::RenderElement>, C: From<<IcedElement<ZoomProgram> as AsRenderElements<R>>::RenderElement>,
R: Renderer + ImportMem, R: Renderer + ImportMem,
<R as Renderer>::TextureId: Send + Clone + 'static, R::TextureId: Send + Clone + 'static,
{ {
let size = self.element.current_size().to_f64(); let size = self.element.current_size().to_f64();
let output_geo = output.geometry().to_f64(); let output_geo = output.geometry().to_f64();
@ -372,7 +372,7 @@ impl ZoomState {
where where
C: From<<IcedElement<ZoomProgram> as AsRenderElements<R>>::RenderElement>, C: From<<IcedElement<ZoomProgram> as AsRenderElements<R>>::RenderElement>,
R: Renderer + ImportMem, 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(); let output_state = output.user_data().get::<Mutex<OutputZoomState>>().unwrap();
output_state.lock().unwrap().render(renderer, output) 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 where
P: Program + Send + 'static, P: Program + Send + 'static,
R: Renderer + ImportMem, R: Renderer + ImportMem,
<R as Renderer>::TextureId: Send + Clone + 'static, R::TextureId: Send + Clone + 'static,
{ {
type RenderElement = MemoryRenderBufferRenderElement<R>; 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<()> ) -> anyhow::Result<()>
where where
R: Renderer + ImportAll + Offscreen<GlesRenderbuffer> + ExportMem, R: Renderer + ImportAll + Offscreen<GlesRenderbuffer> + ExportMem,
<R as Renderer>::TextureId: Clone + 'static, R::TextureId: Clone + 'static,
<R as Renderer>::Error: Send + Sync + 'static, R::Error: Send + Sync + 'static,
{ {
let bbox = bbox_from_surface_tree(&window.wl_surface().unwrap(), (0, 0)); let bbox = bbox_from_surface_tree(&window.wl_surface().unwrap(), (0, 0));
let elements = AsRenderElements::<R>::render_elements::<WaylandSurfaceRenderElement<R>>( let elements = AsRenderElements::<R>::render_elements::<WaylandSurfaceRenderElement<R>>(
@ -43,22 +43,25 @@ pub fn screenshot_window(state: &mut State, surface: &CosmicSurface) {
// TODO: 10-bit // TODO: 10-bit
let format = Fourcc::Abgr8888; let format = Fourcc::Abgr8888;
let render_buffer = Offscreen::<GlesRenderbuffer>::create_buffer( let mut render_buffer = Offscreen::<GlesRenderbuffer>::create_buffer(
renderer, renderer,
format, format,
bbox.size.to_buffer(1, Transform::Normal), bbox.size.to_buffer(1, Transform::Normal),
)?; )?;
renderer.bind(render_buffer)?; let mut fb = renderer.bind(&mut render_buffer)?;
let mut output_damage_tracker = let mut output_damage_tracker =
OutputDamageTracker::new(bbox.size.to_physical(1), 1.0, Transform::Normal); OutputDamageTracker::new(bbox.size.to_physical(1), 1.0, Transform::Normal);
output_damage_tracker 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 { .map_err(|err| match err {
smithay::backend::renderer::damage::Error::Rendering(err) => err, smithay::backend::renderer::damage::Error::Rendering(err) => err,
smithay::backend::renderer::damage::Error::OutputNoMode(_) => unreachable!(), smithay::backend::renderer::damage::Error::OutputNoMode(_) => unreachable!(),
})?; })?;
let mapping = let mapping = renderer.copy_framebuffer(
renderer.copy_framebuffer(bbox.to_buffer(1, Transform::Normal, &bbox.size), format)?; &mut fb,
bbox.to_buffer(1, Transform::Normal, &bbox.size),
format,
)?;
let gl_data = renderer.map_texture(&mapping)?; let gl_data = renderer.map_texture(&mapping)?;
if let Ok(Some(path)) = xdg_user::pictures() { 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>( pub fn submit_buffer<R>(
frame: Frame, frame: Frame,
renderer: &mut R, renderer: &mut R,
offscreen: Option<&mut R::Framebuffer<'_>>,
transform: Transform, transform: Transform,
damage: Option<&[Rectangle<i32, Physical>]>, damage: Option<&[Rectangle<i32, Physical>]>,
sync: SyncPoint, sync: SyncPoint,
) -> Result<Option<(Frame, Vec<Rectangle<i32, BufferCoords>>)>, <R as Renderer>::Error> ) -> Result<Option<(Frame, Vec<Rectangle<i32, BufferCoords>>)>, R::Error>
where where
R: ExportMem, R: ExportMem,
<R as Renderer>::Error: FromGlesError, R::Error: FromGlesError,
{ {
let Some(damage) = damage else { let Some(damage) = damage else {
frame.success( frame.success(
@ -77,7 +78,8 @@ where
}; };
let buffer = frame.buffer(); 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(); let buffer_size = buffer_dimensions(&buffer).unwrap();
if let Err(err) = with_buffer_contents_mut(&buffer, |ptr, len, data| { if let Err(err) = with_buffer_contents_mut(&buffer, |ptr, len, data| {
let offset = data.offset; let offset = data.offset;
@ -98,7 +100,8 @@ where
renderer.wait(&sync)?; renderer.wait(&sync)?;
let format = get_transparent(format).unwrap_or(format); 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)?; let gl_data = renderer.map_texture(&mapping)?;
assert!((width * height * pixelsize) as usize <= gl_data.len()); assert!((width * height * pixelsize) as usize <= gl_data.len());
@ -113,7 +116,7 @@ where
} }
Ok(()) 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) .and_then(|x| x)
{ {
frame.fail(FailureReason::Unknown); 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, renderer: &mut R,
session: &SessionData, session: &SessionData,
frame: Frame, frame: Frame,
transform: Transform, transform: Transform,
render_fn: F, 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 where
R: ExportMem, R: ExportMem + Offscreen<T>,
<R as Renderer>::Error: FromGlesError, R::Error: FromGlesError,
F: for<'d> FnOnce( F: for<'d, 'f> FnOnce(
&WlBuffer, &WlBuffer,
&mut R, &mut R,
Option<&mut R::Framebuffer<'f>>,
&'d mut OutputDamageTracker, &'d mut OutputDamageTracker,
usize, usize,
Vec<Rectangle<i32, BufferCoords>>, 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 mut session_damage_tracking = session.lock().unwrap();
let buffer = frame.buffer(); 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 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( let res = render_fn(
&frame.buffer(), &frame.buffer(),
renderer, renderer,
fb.as_mut(),
&mut session_damage_tracking.dt, &mut session_damage_tracking.dt,
age, age,
frame.damage(), frame.damage(),
@ -167,6 +190,7 @@ where
Ok(result) => submit_buffer( Ok(result) => submit_buffer(
frame, frame,
renderer, renderer,
fb.as_mut(),
transform, transform,
result.damage.map(|x| x.as_slice()), result.damage.map(|x| x.as_slice()),
result.sync, result.sync,
@ -217,6 +241,7 @@ pub fn render_workspace_to_buffer(
fn render_fn<'d, R>( fn render_fn<'d, R>(
buffer: &WlBuffer, buffer: &WlBuffer,
renderer: &mut R, renderer: &mut R,
offscreen: Option<&mut R::Framebuffer<'_>>,
dt: &'d mut OutputDamageTracker, dt: &'d mut OutputDamageTracker,
mut age: usize, mut age: usize,
additional_damage: Vec<Rectangle<i32, BufferCoords>>, additional_damage: Vec<Rectangle<i32, BufferCoords>>,
@ -224,18 +249,11 @@ pub fn render_workspace_to_buffer(
common: &mut Common, common: &mut Common,
output: &Output, output: &Output,
handle: (WorkspaceHandle, usize), handle: (WorkspaceHandle, usize),
) -> Result<RenderOutputResult<'d>, DTError<<R as Renderer>::Error>> ) -> Result<RenderOutputResult<'d>, DTError<R::Error>>
where where
R: Renderer R: Renderer + ImportAll + ImportMem + ExportMem + Bind<Dmabuf> + Blit + AsGlowRenderer,
+ ImportAll R::TextureId: Send + Clone + 'static,
+ ImportMem R::Error: FromGlesError,
+ ExportMem
+ Bind<Dmabuf>
+ Offscreen<GlesRenderbuffer>
+ Blit<Dmabuf>
+ AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static,
<R as Renderer>::Error: FromGlesError,
CosmicElement<R>: RenderElement<R>, CosmicElement<R>: RenderElement<R>,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
WorkspaceRenderElement<R>: RenderElement<R>, WorkspaceRenderElement<R>: RenderElement<R>,
@ -273,10 +291,12 @@ pub fn render_workspace_to_buffer(
}); });
if let Ok(dmabuf) = get_dmabuf(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, None,
renderer, renderer,
dmabuf.clone(), &mut fb,
dt, dt,
age, age,
additional_damage, additional_damage,
@ -291,23 +311,12 @@ pub fn render_workspace_to_buffer(
) )
.map(|res| res.0) .map(|res| res.0)
} else { } else {
let size = buffer_dimensions(buffer).unwrap(); let target = offscreen.expect("shm buffers should have an offscreen target");
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)?;
age = 0; age = 0;
render_workspace::<_, _, GlesRenderbuffer>( render_workspace(
None, None,
renderer, renderer,
render_buffer, target,
dt, dt,
age, age,
additional_damage, additional_damage,
@ -359,15 +368,16 @@ pub fn render_workspace_to_buffer(
}; };
let result = match renderer { let result = match renderer {
RendererRef::Glow(renderer) => { RendererRef::Glow(renderer) => {
match render_session::<_, _>( match render_session::<_, _, GlesRenderbuffer>(
renderer, renderer,
session.user_data().get::<SessionData>().unwrap(), session.user_data().get::<SessionData>().unwrap(),
frame, frame,
transform, transform,
|buffer, renderer, dt, age, additional_damage| { |buffer, renderer, offscreen, dt, age, additional_damage| {
render_fn( render_fn(
buffer, buffer,
renderer, renderer,
offscreen,
dt, dt,
age, age,
additional_damage, additional_damage,
@ -386,15 +396,16 @@ pub fn render_workspace_to_buffer(
} }
} }
RendererRef::GlMulti(mut renderer) => { RendererRef::GlMulti(mut renderer) => {
match render_session::<_, _>( match render_session::<_, _, GlesRenderbuffer>(
&mut renderer, &mut renderer,
session.user_data().get::<SessionData>().unwrap(), session.user_data().get::<SessionData>().unwrap(),
frame, frame,
transform, transform,
|buffer, renderer, dt, age, additional_damage| { |buffer, renderer, offscreen, dt, age, additional_damage| {
render_fn( render_fn(
buffer, buffer,
renderer, renderer,
offscreen,
dt, dt,
age, age,
additional_damage, additional_damage,
@ -458,25 +469,19 @@ pub fn render_window_to_buffer(
fn render_fn<'d, R>( fn render_fn<'d, R>(
buffer: &WlBuffer, buffer: &WlBuffer,
renderer: &mut R, renderer: &mut R,
offscreen: Option<&mut R::Framebuffer<'_>>,
dt: &'d mut OutputDamageTracker, dt: &'d mut OutputDamageTracker,
mut age: usize, age: usize,
additional_damage: Vec<Rectangle<i32, BufferCoords>>, additional_damage: Vec<Rectangle<i32, BufferCoords>>,
draw_cursor: bool, draw_cursor: bool,
common: &mut Common, common: &mut Common,
window: &CosmicSurface, window: &CosmicSurface,
geometry: Rectangle<i32, Logical>, geometry: Rectangle<i32, Logical>,
) -> Result<RenderOutputResult<'d>, DTError<<R as Renderer>::Error>> ) -> Result<RenderOutputResult<'d>, DTError<R::Error>>
where where
R: Renderer R: Renderer + ImportAll + ImportMem + ExportMem + Bind<Dmabuf> + Blit + AsGlowRenderer,
+ ImportAll R::TextureId: Send + Clone + 'static,
+ ImportMem R::Error: FromGlesError,
+ ExportMem
+ Bind<Dmabuf>
+ Offscreen<GlesRenderbuffer>
+ Blit<Dmabuf>
+ AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static,
<R as Renderer>::Error: FromGlesError,
CosmicElement<R>: RenderElement<R>, CosmicElement<R>: RenderElement<R>,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
{ {
@ -557,25 +562,15 @@ pub fn render_window_to_buffer(
} }
if let Ok(dmabuf) = get_dmabuf(buffer) { if let Ok(dmabuf) = get_dmabuf(buffer) {
renderer.bind(dmabuf.clone()).map_err(DTError::Rendering)?; let mut dmabuf_clone = dmabuf.clone();
let mut fb = renderer
.bind(&mut dmabuf_clone)
.map_err(DTError::Rendering)?;
dt.render_output(renderer, &mut fb, age, &elements, Color32F::TRANSPARENT)
} else { } else {
let size = buffer_dimensions(buffer).unwrap(); let fb = offscreen.expect("shm buffer should have an offscreen target");
let format = dt.render_output(renderer, fb, 0, &elements, Color32F::TRANSPARENT)
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)?;
age = 0;
renderer.bind(render_buffer).map_err(DTError::Rendering)?;
} }
dt.render_output(renderer, age, &elements, Color32F::TRANSPARENT)
} }
let common = &mut state.common; let common = &mut state.common;
@ -607,15 +602,16 @@ pub fn render_window_to_buffer(
} }
}; };
let result = match renderer { let result = match renderer {
RendererRef::Glow(renderer) => match render_session::<_, _>( RendererRef::Glow(renderer) => match render_session::<_, _, GlesRenderbuffer>(
renderer, renderer,
session.user_data().get::<SessionData>().unwrap(), session.user_data().get::<SessionData>().unwrap(),
frame, frame,
Transform::Normal, Transform::Normal,
|buffer, renderer, dt, age, additional_damage| { |buffer, renderer, offscreen, dt, age, additional_damage| {
render_fn( render_fn(
buffer, buffer,
renderer, renderer,
offscreen,
dt, dt,
age, age,
additional_damage, additional_damage,
@ -632,15 +628,16 @@ pub fn render_window_to_buffer(
None None
} }
}, },
RendererRef::GlMulti(mut renderer) => match render_session::<_, _>( RendererRef::GlMulti(mut renderer) => match render_session::<_, _, GlesRenderbuffer>(
&mut renderer, &mut renderer,
session.user_data().get::<SessionData>().unwrap(), session.user_data().get::<SessionData>().unwrap(),
frame, frame,
Transform::Normal, Transform::Normal,
|buffer, renderer, dt, age, additional_damage| { |buffer, renderer, offscreen, dt, age, additional_damage| {
render_fn( render_fn(
buffer, buffer,
renderer, renderer,
offscreen,
dt, dt,
age, age,
additional_damage, additional_damage,
@ -697,23 +694,17 @@ pub fn render_cursor_to_buffer(
fn render_fn<'d, R>( fn render_fn<'d, R>(
buffer: &WlBuffer, buffer: &WlBuffer,
renderer: &mut R, renderer: &mut R,
offscreen: Option<&mut R::Framebuffer<'_>>,
dt: &'d mut OutputDamageTracker, dt: &'d mut OutputDamageTracker,
mut age: usize, age: usize,
additional_damage: Vec<Rectangle<i32, BufferCoords>>, additional_damage: Vec<Rectangle<i32, BufferCoords>>,
common: &mut Common, common: &mut Common,
seat: &Seat<State>, seat: &Seat<State>,
) -> Result<RenderOutputResult<'d>, DTError<<R as Renderer>::Error>> ) -> Result<RenderOutputResult<'d>, DTError<R::Error>>
where where
R: Renderer R: Renderer + ImportAll + ImportMem + ExportMem + Bind<Dmabuf> + Blit + AsGlowRenderer,
+ ImportAll R::TextureId: Send + Clone + 'static,
+ ImportMem R::Error: FromGlesError,
+ ExportMem
+ Bind<Dmabuf>
+ Offscreen<GlesRenderbuffer>
+ Blit<Dmabuf>
+ AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static,
<R as Renderer>::Error: FromGlesError,
CosmicElement<R>: RenderElement<R>, CosmicElement<R>: RenderElement<R>,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
{ {
@ -743,25 +734,15 @@ pub fn render_cursor_to_buffer(
); );
if let Ok(dmabuf) = get_dmabuf(buffer) { if let Ok(dmabuf) = get_dmabuf(buffer) {
renderer.bind(dmabuf.clone()).map_err(DTError::Rendering)?; let mut dmabuf_clone = dmabuf.clone();
let mut fb = renderer
.bind(&mut dmabuf_clone)
.map_err(DTError::Rendering)?;
dt.render_output(renderer, &mut fb, age, &elements, [0.0, 0.0, 0.0, 0.0])
} else { } else {
let size = buffer_dimensions(buffer).unwrap(); let fb = offscreen.expect("shm buffers should have offscreen target");
let format = dt.render_output(renderer, fb, 0, &elements, [0.0, 0.0, 0.0, 0.0])
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)?;
age = 0;
renderer.bind(render_buffer).map_err(DTError::Rendering)?;
} }
dt.render_output(renderer, age, &elements, [0.0, 0.0, 0.0, 0.0])
} }
let common = &mut state.common; let common = &mut state.common;
@ -775,13 +756,22 @@ pub fn render_cursor_to_buffer(
}; };
let result = match renderer { let result = match renderer {
RendererRef::Glow(renderer) => { RendererRef::Glow(renderer) => {
match render_session::<_, _>( match render_session::<_, _, GlesRenderbuffer>(
renderer, renderer,
session.user_data().get::<SessionData>().unwrap(), session.user_data().get::<SessionData>().unwrap(),
frame, frame,
Transform::Normal, Transform::Normal,
|buffer, renderer, dt, age, additional_damage| { |buffer, renderer, offscreen, dt, age, additional_damage| {
render_fn(buffer, renderer, dt, age, additional_damage, common, seat) render_fn(
buffer,
renderer,
offscreen,
dt,
age,
additional_damage,
common,
seat,
)
}, },
) { ) {
Ok(frame) => frame, Ok(frame) => frame,
@ -792,13 +782,22 @@ pub fn render_cursor_to_buffer(
} }
} }
RendererRef::GlMulti(mut renderer) => { RendererRef::GlMulti(mut renderer) => {
match render_session::<_, _>( match render_session::<_, _, GlesRenderbuffer>(
&mut renderer, &mut renderer,
session.user_data().get::<SessionData>().unwrap(), session.user_data().get::<SessionData>().unwrap(),
frame, frame,
Transform::Normal, Transform::Normal,
|buffer, renderer, dt, age, additional_damage| { |buffer, renderer, offscreen, dt, age, additional_damage| {
render_fn(buffer, renderer, dt, age, additional_damage, common, seat) render_fn(
buffer,
renderer,
offscreen,
dt,
age,
additional_damage,
common,
seat,
)
}, },
) { ) {
Ok(frame) => frame, Ok(frame) => frame,