deps: Update smithay

- Use new GAT frame
- Bugfixes
- Finish window debug overlay

Cargo.lock

@@ -327,6 +327,7 @@ dependencies = [
  "libsystemd",
  "png",
  "regex",
+ "renderdoc",
  "ron",
  "sendfd",
  "serde",
@@ -666,12 +667,21 @@ dependencies = [
 
 [[package]]
 name = "flate2"
-version = "1.0.24"
+version = "1.0.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f82b0f4c27ad9f8bfd1f3208d882da2b09c301bc1c828fd3a00d0216d2fbbff6"
+checksum = "a8a2db397cb1c8772f31494cb8917e48cd1e64f0fa7efac59fbd741a0a8ce841"
 dependencies = [
  "crc32fast",
- "miniz_oxide 0.5.4",
+ "miniz_oxide 0.6.2",
+]
+
+[[package]]
+name = "float-cmp"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1267f4ac4f343772758f7b1bdcbe767c218bbab93bb432acbf5162bbf85a6c4"
+dependencies = [
+ "num-traits",
 ]
 
 [[package]]
@@ -1535,6 +1545,27 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "renderdoc"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b42e14087d51efd3b42eb341e37b6f320af2b0750519ea849cb68bb7289643ed"
+dependencies = [
+ "bitflags",
+ "float-cmp 0.8.0",
+ "libloading",
+ "once_cell",
+ "renderdoc-sys",
+ "winapi",
+ "wio",
+]
+
+[[package]]
+name = "renderdoc-sys"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1382d1f0a252c4bf97dc20d979a2fdd05b024acd7c2ed0f7595d7817666a157"
+
 [[package]]
 name = "resvg"
 version = "0.23.0"
@@ -1789,7 +1820,7 @@ checksum = "a507befe795404456341dfab10cef66ead4c041f62b8b11bbb92bffe5d0953e0"
 [[package]]
 name = "smithay"
 version = "0.3.0"
-source = "git+https://github.com/pop-os/smithay?rev=c8aaa059e8#c8aaa059e841886ed9e689e0cc0d0cb821b97b71"
+source = "git+https://github.com/pop-os/smithay?rev=8f6261bbf6#8f6261bbf6b2158e5cb451c6537378772eae7fe2"
 dependencies = [
  "appendlist",
  "bitflags",
@@ -1805,7 +1836,6 @@ dependencies = [
  "glow",
  "indexmap",
  "input",
- "io-lifetimes",
  "lazy_static",
  "libc",
  "libloading",
@@ -1854,7 +1884,7 @@ dependencies = [
 [[package]]
 name = "smithay-egui"
 version = "0.1.0"
-source = "git+https://github.com/Smithay/smithay-egui.git?rev=9fe1fa5e01#9fe1fa5e01dc39c145f036564e971a50f84864ff"
+source = "git+https://github.com/Smithay/smithay-egui.git?rev=13626ad3f4#13626ad3f41a6f877929802eb645a10e5bd1abae"
 dependencies = [
  "cgmath",
  "egui",
@@ -1890,7 +1920,7 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "639abcebc15fdc2df179f37d6f5463d660c1c79cd552c12343a4600827a04bce"
 dependencies = [
- "float-cmp",
+ "float-cmp 0.9.0",
  "rgb",
 ]
 
@@ -2126,7 +2156,7 @@ dependencies = [
  "base64",
  "data-url",
  "flate2",
- "float-cmp",
+ "float-cmp 0.9.0",
  "fontdb",
  "kurbo",
  "log",
@@ -2581,10 +2611,19 @@ dependencies = [
 ]
 
 [[package]]
-name = "x11-dl"
+name = "wio"
-version = "2.20.0"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c83627bc137605acc00bb399c7b908ef460b621fc37c953db2b09f88c449ea6"
+checksum = "5d129932f4644ac2396cb456385cbf9e63b5b30c6e8dc4820bdca4eb082037a5"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "x11-dl"
+version = "2.20.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1536d6965a5d4e573c7ef73a2c15ebcd0b2de3347bdf526c34c297c00ac40f0"
 dependencies = [
  "lazy_static",
  "libc",

Cargo.toml

@@ -17,6 +17,7 @@ serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 sendfd = "0.4.1"
 egui = { version = "0.19.0", optional = true }
+renderdoc = { version = "0.10.1", optional = true }
 edid-rs = { version = "0.1" }
 png = "0.17.5"
 lazy_static = "1.4.0"
@@ -36,19 +37,19 @@ cosmic-protocols = { git = "https://github.com/pop-os/cosmic-protocols", branch
 [dependencies.smithay]
 version = "0.3"
 git = "https://github.com/Smithay/smithay.git"
-rev = "b297c93edc"
+rev = "2de946cf9e"
 default-features = false
 features = ["backend_drm", "backend_gbm", "backend_egl", "backend_libinput", "backend_session_libseat", "backend_udev", "backend_winit", "backend_x11", "desktop", "use_system_lib", "renderer_glow", "renderer_multi", "wayland_frontend", "slog-stdlog"]
 
 [dependencies.smithay-egui]
 git = "https://github.com/Smithay/smithay-egui.git"
-rev = "9fe1fa5e01"
+rev = "13626ad3f4"
 features = ["svg"]
 optional = true
 
 [features]
 default = []
-debug = ["egui", "smithay-egui"]
+debug = ["egui", "smithay-egui", "renderdoc"]
 
 [profile.dev]
 lto = "thin"
@@ -61,4 +62,4 @@ debug = true
 lto = "fat"
 
 [patch."https://github.com/Smithay/smithay.git"]
-smithay = { git = "https://github.com/pop-os/smithay", rev = "c8aaa059e8" }
+smithay = { git = "https://github.com/pop-os/smithay", rev = "8f6261bbf6" }

src/backend/render/cursor.rs

@@ -129,15 +129,18 @@ fn load_icon(theme: &CursorTheme) -> Result<Vec<Image>, Error> {
 render_elements! {
     pub CursorRenderElement<R> where R: ImportAll;
     Static=TextureRenderElement<<R as Renderer>::TextureId>,
-    Surface=WaylandSurfaceRenderElement,
+    Surface=WaylandSurfaceRenderElement<R>,
 }
 
-pub fn draw_surface_cursor<R: Renderer + ImportAll>(
+pub fn draw_surface_cursor<R>(
+    renderer: &mut R,
     surface: &wl_surface::WlSurface,
     location: impl Into<Point<i32, Logical>>,
     scale: impl Into<Scale<f64>>,
 ) -> Vec<CursorRenderElement<R>>
 where
+    R: Renderer + ImportAll,
+    <R as Renderer>::TextureId: 'static,
 {
     let mut position = location.into();
     let scale = scale.into();
@@ -152,14 +155,25 @@ where
     });
     position -= h;
 
-    render_elements_from_surface_tree(surface, position.to_physical_precise_round(scale), scale)
+    render_elements_from_surface_tree(
+        renderer,
+        surface,
+        position.to_physical_precise_round(scale),
+        scale,
+        slog_scope::logger(),
+    )
 }
 
-pub fn draw_dnd_icon<R: Renderer + ImportAll>(
+pub fn draw_dnd_icon<R>(
+    renderer: &mut R,
     surface: &wl_surface::WlSurface,
     location: impl Into<Point<i32, Logical>>,
     scale: impl Into<Scale<f64>>,
-) -> Vec<CursorRenderElement<R>> {
+) -> Vec<CursorRenderElement<R>>
+where
+    R: Renderer + ImportAll,
+    <R as Renderer>::TextureId: 'static,
+{
     if get_role(&surface) != Some("dnd_icon") {
         slog_scope::warn!(
             "Trying to display as a dnd icon a surface that does not have the DndIcon role."
@@ -167,9 +181,11 @@ pub fn draw_dnd_icon<R: Renderer + ImportAll>(
     }
     let scale = scale.into();
     render_elements_from_surface_tree(
+        renderer,
         surface,
         location.into().to_physical_precise_round(scale),
         scale,
+        slog_scope::logger(),
     )
 }
 
@@ -218,7 +234,7 @@ where
         .unwrap_or(CursorImageStatus::Default);
 
     if let CursorImageStatus::Surface(ref wl_surface) = cursor_status {
-        return draw_surface_cursor(wl_surface, location.to_i32_round(), scale);
+        return draw_surface_cursor(renderer, wl_surface, location.to_i32_round(), scale);
     } else if draw_default && CursorImageStatus::Default == cursor_status {
         let integer_scale = scale.x.max(scale.y).ceil() as u32;
 

src/backend/render/element.rs

@@ -2,22 +2,24 @@ use crate::shell::{CosmicMappedRenderElement, WorkspaceRenderElement};
 
 use smithay::{
     backend::renderer::{
-        element::{texture::TextureRenderElement, Element, RenderElement, UnderlyingStorage},
+        element::{Element, RenderElement, UnderlyingStorage},
-        gles2::{Gles2Frame, Gles2Texture},
+        glow::{GlowFrame, GlowRenderer},
-        glow::GlowRenderer,
-        multigpu::Error as MultiError,
         Frame, ImportAll, Renderer,
     },
     utils::{Physical, Point, Rectangle, Scale},
 };
 
+#[cfg(feature = "debug")]
+use smithay::backend::renderer::{
+    element::texture::TextureRenderElement, gles2::Gles2Texture, multigpu::Error as MultiError,
+};
+
 use super::{cursor::CursorRenderElement, GlMultiFrame, GlMultiRenderer};
 
 pub enum CosmicElement<R>
 where
     R: AsGlowRenderer + Renderer + ImportAll,
     <R as Renderer>::TextureId: 'static,
-    <R as Renderer>::Frame: AsGles2Frame,
     CosmicMappedRenderElement<R>: RenderElement<R>,
 {
     Workspace(WorkspaceRenderElement<R>),
@@ -31,7 +33,6 @@ impl<R> Element for CosmicElement<R>
 where
     R: AsGlowRenderer + Renderer + ImportAll,
     <R as Renderer>::TextureId: 'static,
-    <R as Renderer>::Frame: AsGles2Frame,
     CosmicMappedRenderElement<R>: RenderElement<R>,
 {
     fn id(&self) -> &smithay::backend::renderer::element::Id {
@@ -120,25 +121,22 @@ where
 }
 
 impl RenderElement<GlowRenderer> for CosmicElement<GlowRenderer> {
-    fn draw(
+    fn draw<'frame>(
         &self,
-        renderer: &mut GlowRenderer,
+        frame: &mut <GlowRenderer as Renderer>::Frame<'frame>,
-        frame: &mut <GlowRenderer as Renderer>::Frame,
         location: Point<i32, Physical>,
         scale: Scale<f64>,
         damage: &[Rectangle<i32, Physical>],
         log: &slog::Logger,
     ) -> Result<(), <GlowRenderer as Renderer>::Error> {
         match self {
-            CosmicElement::Workspace(elem) => {
+            CosmicElement::Workspace(elem) => elem.draw(frame, location, scale, damage, log),
-                elem.draw(renderer, frame, location, scale, damage, log)
+            CosmicElement::Cursor(elem) => elem.draw(frame, location, scale, damage, log),
-            }
+            CosmicElement::MoveGrab(elem) => elem.draw(frame, location, scale, damage, log),
-            CosmicElement::Cursor(elem) => elem.draw(renderer, frame, location, scale, damage, log),
-            CosmicElement::MoveGrab(elem) => {
-                elem.draw(renderer, frame, location, scale, damage, log)
-            }
             #[cfg(feature = "debug")]
-            CosmicElement::Egui(elem) => elem.draw(renderer, frame, location, scale, damage, log),
+            CosmicElement::Egui(elem) => {
+                RenderElement::<GlowRenderer>::draw(elem, frame, location, scale, damage, log)
+            }
         }
     }
 
@@ -157,29 +155,28 @@ impl RenderElement<GlowRenderer> for CosmicElement<GlowRenderer> {
 }
 
 impl<'a> RenderElement<GlMultiRenderer<'a>> for CosmicElement<GlMultiRenderer<'a>> {
-    fn draw(
+    fn draw<'frame>(
         &self,
-        renderer: &mut GlMultiRenderer<'a>,
+        frame: &mut GlMultiFrame<'a, 'frame>,
-        frame: &mut <GlMultiRenderer<'a> as Renderer>::Frame,
         location: Point<i32, Physical>,
         scale: Scale<f64>,
         damage: &[Rectangle<i32, Physical>],
         log: &slog::Logger,
     ) -> Result<(), <GlMultiRenderer<'_> as Renderer>::Error> {
         match self {
-            CosmicElement::Workspace(elem) => {
+            CosmicElement::Workspace(elem) => elem.draw(frame, location, scale, damage, log),
-                elem.draw(renderer, frame, location, scale, damage, log)
+            CosmicElement::Cursor(elem) => elem.draw(frame, location, scale, damage, log),
-            }
+            CosmicElement::MoveGrab(elem) => elem.draw(frame, location, scale, damage, log),
-            CosmicElement::Cursor(elem) => elem.draw(renderer, frame, location, scale, damage, log),
-            CosmicElement::MoveGrab(elem) => {
-                elem.draw(renderer, frame, location, scale, damage, log)
-            }
             #[cfg(feature = "debug")]
             CosmicElement::Egui(elem) => {
-                let glow_renderer = renderer.glow_renderer_mut();
+                let elem = {
-                let gles2_frame = frame.gles2_frame_mut();
+                    let glow_frame = frame.glow_frame_mut();
-                elem.draw(glow_renderer, gles2_frame, location, scale, damage, log)
+                    RenderElement::<GlowRenderer>::draw(
+                        elem, glow_frame, location, scale, damage, log,
+                    )
                     .map_err(|err| MultiError::Render(err))
+                };
+                elem
             }
         }
     }
@@ -210,7 +207,6 @@ impl<R> From<WorkspaceRenderElement<R>> for CosmicElement<R>
 where
     R: Renderer + ImportAll + AsGlowRenderer,
     <R as Renderer>::TextureId: 'static,
-    <R as Renderer>::Frame: AsGles2Frame,
     CosmicMappedRenderElement<R>: RenderElement<R>,
 {
     fn from(elem: WorkspaceRenderElement<R>) -> Self {
@@ -222,7 +218,6 @@ impl<R> From<CursorRenderElement<R>> for CosmicElement<R>
 where
     R: Renderer + ImportAll + AsGlowRenderer,
     <R as Renderer>::TextureId: 'static,
-    <R as Renderer>::Frame: AsGles2Frame,
     CosmicMappedRenderElement<R>: RenderElement<R>,
 {
     fn from(elem: CursorRenderElement<R>) -> Self {
@@ -234,7 +229,6 @@ impl<R> From<CosmicMappedRenderElement<R>> for CosmicElement<R>
 where
     R: Renderer + ImportAll + AsGlowRenderer,
     <R as Renderer>::TextureId: 'static,
-    <R as Renderer>::Frame: AsGles2Frame,
     CosmicMappedRenderElement<R>: RenderElement<R>,
 {
     fn from(elem: CosmicMappedRenderElement<R>) -> Self {
@@ -247,7 +241,6 @@ impl<R> From<TextureRenderElement<Gles2Texture>> for CosmicElement<R>
 where
     R: Renderer + ImportAll + AsGlowRenderer,
     <R as Renderer>::TextureId: 'static,
-    <R as Renderer>::Frame: AsGles2Frame,
     CosmicMappedRenderElement<R>: RenderElement<R>,
 {
     fn from(elem: TextureRenderElement<Gles2Texture>) -> Self {
@@ -258,7 +251,6 @@ where
 pub trait AsGlowRenderer
 where
     Self: Renderer,
-    <Self as Renderer>::Frame: AsGles2Frame,
 {
     fn glow_renderer(&self) -> &GlowRenderer;
     fn glow_renderer_mut(&mut self) -> &mut GlowRenderer;
@@ -282,28 +274,28 @@ impl<'a> AsGlowRenderer for GlMultiRenderer<'a> {
     }
 }
 
-pub trait AsGles2Frame
+pub trait AsGlowFrame<'a>
 where
     Self: Frame,
 {
-    fn gles2_frame(&self) -> &Gles2Frame;
+    fn glow_frame(&self) -> &GlowFrame<'a>;
-    fn gles2_frame_mut(&mut self) -> &mut Gles2Frame;
+    fn glow_frame_mut(&mut self) -> &mut GlowFrame<'a>;
 }
 
-impl AsGles2Frame for Gles2Frame {
+impl<'frame> AsGlowFrame<'frame> for GlowFrame<'frame> {
-    fn gles2_frame(&self) -> &Gles2Frame {
+    fn glow_frame(&self) -> &GlowFrame<'frame> {
         self
     }
-    fn gles2_frame_mut(&mut self) -> &mut Gles2Frame {
+    fn glow_frame_mut(&mut self) -> &mut GlowFrame<'frame> {
         self
     }
 }
 
-impl AsGles2Frame for GlMultiFrame {
+impl<'renderer, 'frame> AsGlowFrame<'frame> for GlMultiFrame<'renderer, 'frame> {
-    fn gles2_frame(&self) -> &Gles2Frame {
+    fn glow_frame(&self) -> &GlowFrame<'frame> {
         self.as_ref()
     }
-    fn gles2_frame_mut(&mut self) -> &mut Gles2Frame {
+    fn glow_frame_mut(&mut self) -> &mut GlowFrame<'frame> {
         self.as_mut()
     }
 }

src/backend/render/mod.rs

@@ -41,7 +41,7 @@ use smithay::{
 pub mod cursor;
 use self::cursor::CursorRenderElement;
 pub mod element;
-use self::element::{AsGles2Frame, AsGlowRenderer, CosmicElement};
+use self::element::{AsGlowRenderer, CosmicElement};
 
 pub type GlMultiRenderer<'a> = MultiRenderer<
     'a,
@@ -50,7 +50,14 @@ pub type GlMultiRenderer<'a> = MultiRenderer<
     EglGlesBackend<GlowRenderer>,
     Gles2Renderbuffer,
 >;
-pub type GlMultiFrame = MultiFrame<EglGlesBackend<GlowRenderer>, EglGlesBackend<GlowRenderer>>;
+pub type GlMultiFrame<'a, 'frame> = MultiFrame<
+    'a,
+    'a,
+    'frame,
+    EglGlesBackend<GlowRenderer>,
+    EglGlesBackend<GlowRenderer>,
+    Gles2Renderbuffer,
+>;
 
 pub static CLEAR_COLOR: [f32; 4] = [0.153, 0.161, 0.165, 1.0];
 
@@ -61,7 +68,7 @@ pub enum CursorMode {
     All,
 }
 
-pub fn cursor_elements<E, R>(
+pub fn cursor_elements<'frame, E, R>(
     renderer: &mut R,
     state: &Common,
     output: &Output,
@@ -69,7 +76,6 @@ pub fn cursor_elements<E, R>(
 ) -> Vec<E>
 where
     R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
-    <R as Renderer>::Frame: AsGles2Frame,
     <R as Renderer>::TextureId: Clone + 'static,
     CosmicMappedRenderElement<R>: RenderElement<R>,
     E: From<CursorRenderElement<R>> + From<CosmicMappedRenderElement<R>>,
@@ -101,7 +107,7 @@ where
 
         if let Some(wl_surface) = get_dnd_icon(seat) {
             elements.extend(
-                cursor::draw_dnd_icon(&wl_surface, location.to_i32_round(), scale)
+                cursor::draw_dnd_icon(renderer, &wl_surface, location.to_i32_round(), scale)
                     .into_iter()
                     .map(E::from),
             );
@@ -113,7 +119,7 @@ where
             .unwrap()
             .borrow()
             .as_ref()
-            .map(|state| state.render::<E, R>(seat, output))
+            .map(|state| state.render::<E, R>(renderer, seat, output))
         {
             elements.extend(grab_elements);
         }
@@ -122,7 +128,7 @@ where
     elements
 }
 
-pub fn render_output<R, Target, OffTarget, Source>(
+pub fn render_output<'frame, R, Target, OffTarget, Source>(
     gpu: Option<&DrmNode>,
     renderer: &mut R,
     target: Target,
@@ -144,7 +150,6 @@ where
         + Offscreen<OffTarget>
         + Blit<Source>
         + AsGlowRenderer,
-    <R as Renderer>::Frame: AsGles2Frame,
     <R as Renderer>::TextureId: Clone + 'static,
     <R as Renderer>::Error: From<Gles2Error>,
     CosmicElement<R>: RenderElement<R>,
@@ -167,7 +172,7 @@ where
     )
 }
 
-pub fn render_workspace<R, Target, OffTarget, Source>(
+pub fn render_workspace<'frame, R, Target, OffTarget, Source>(
     gpu: Option<&DrmNode>,
     renderer: &mut R,
     target: Target,
@@ -190,7 +195,6 @@ where
         + Offscreen<OffTarget>
         + Blit<Source>
         + AsGlowRenderer,
-    <R as Renderer>::Frame: AsGles2Frame,
     <R as Renderer>::TextureId: Clone + 'static,
     <R as Renderer>::Error: From<Gles2Error>,
     CosmicElement<R>: RenderElement<R>,
@@ -199,6 +203,15 @@ where
 {
     if let Some(ref mut fps) = fps {
         fps.start();
+        #[cfg(feature = "debug")]
+        if screencopy.is_some() {
+            if let Some(rd) = fps.rd.as_mut() {
+                rd.start_frame_capture(
+                    renderer.glow_renderer().egl_context().get_context_handle(),
+                    std::ptr::null(),
+                );
+            }
+        }
     }
 
     let workspace = state.shell.space_for_handle(&handle).ok_or(OutputNoMode)?;
@@ -245,7 +258,7 @@ where
 
     elements.extend(
         workspace
-            .render_output::<R>(output)
+            .render_output::<R>(renderer, output)
             .map_err(|_| OutputNoMode)?
             .into_iter()
             .map(Into::into),
@@ -307,6 +320,13 @@ where
         }
         if let Some(fps) = fps.as_mut() {
             fps.screencopy();
+            #[cfg(feature = "debug")]
+            if let Some(rd) = fps.rd.as_mut() {
+                rd.end_frame_capture(
+                    renderer.glow_renderer().egl_context().get_context_handle(),
+                    std::ptr::null(),
+                );
+            }
         }
     }
 

src/backend/winit.rs

@@ -71,10 +71,13 @@ impl WinitState {
             Some(&mut self.fps),
         ) {
             Ok((damage, states)) => {
-                self.screencopy.clear();
+                self.backend
+                    .bind()
+                    .with_context(|| "Failed to bind display")?;
                 self.backend
                     .submit(damage.as_deref())
                     .with_context(|| "Failed to submit buffer for display")?;
+                self.screencopy.clear();
                 #[cfg(feature = "debug")]
                 self.fps.displayed();
                 state.send_frames(&self.output, &states);

src/debug.rs

@@ -185,6 +185,5 @@ pub fn fps_ui(
         area,
         scale,
         0.8,
-        state.clock.now().into(),
     )
 }

src/input/mod.rs

@@ -535,6 +535,15 @@ impl State {
             #[cfg(feature = "debug")]
             Action::Debug => {
                 self.common.egui.active = !self.common.egui.active;
+                for mapped in self
+                    .common
+                    .shell
+                    .workspaces
+                    .spaces()
+                    .flat_map(|w| w.mapped())
+                {
+                    mapped.set_debug(self.common.egui.active);
+                }
             }
             #[cfg(not(feature = "debug"))]
             Action::Debug => {

src/shell/element/mod.rs

@@ -1,8 +1,5 @@
 use crate::{
-    backend::render::{
+    backend::render::{element::AsGlowRenderer, GlMultiFrame, GlMultiRenderer},
-        element::{AsGles2Frame, AsGlowRenderer, CosmicElement},
-        GlMultiRenderer,
-    },
     state::State,
     utils::prelude::SeatExt,
 };
@@ -11,13 +8,8 @@ use smithay::{
     backend::{
         input::KeyState,
         renderer::{
-            element::{
+            element::{AsRenderElements, Element, RenderElement, UnderlyingStorage},
-                texture::TextureRenderElement, AsRenderElements, Element, RenderElement,
-                UnderlyingStorage,
-            },
-            gles2::Gles2Texture,
             glow::GlowRenderer,
-            multigpu::Error as MultiError,
             ImportAll, Renderer,
         },
     },
@@ -53,9 +45,16 @@ pub mod window;
 pub use self::window::CosmicWindow;
 
 #[cfg(feature = "debug")]
-use smithay::wayland::shell::xdg::XdgToplevelSurfaceData;
+use crate::backend::render::element::AsGlowFrame;
 #[cfg(feature = "debug")]
-use smithay_egui::EguiState;
+use egui::plot::{Corner, Legend, Plot, PlotPoints, Polygon};
+#[cfg(feature = "debug")]
+use smithay::{
+    backend::renderer::{
+        element::texture::TextureRenderElement, gles2::Gles2Texture, multigpu::Error as MultiError,
+    },
+    wayland::shell::xdg::XdgToplevelSurfaceData,
+};
 
 use super::{focus::FocusDirection, layout::floating::ResizeState};
 
@@ -80,7 +79,7 @@ pub struct CosmicMapped {
     pub(super) resize_state: Arc<Mutex<Option<ResizeState>>>,
 
     #[cfg(feature = "debug")]
-    debug: Arc<Mutex<smithay_egui::EguiState>>,
+    debug: Arc<Mutex<Option<smithay_egui::EguiState>>>,
 }
 
 impl fmt::Debug for CosmicMapped {
@@ -554,6 +553,19 @@ impl CosmicMapped {
             // Kind::X11?
         };
     }
+
+    #[cfg(feature = "debug")]
+    pub fn set_debug(&self, flag: bool) {
+        let mut debug = self.debug.lock().unwrap();
+        if flag {
+            *debug = Some(smithay_egui::EguiState::new(Rectangle::from_loc_and_size(
+                (10, 10),
+                (100, 100),
+            )));
+        } else {
+            debug.take();
+        }
+    }
 }
 
 impl IsAlive for CosmicMapped {
@@ -722,9 +734,7 @@ impl From<CosmicWindow> for CosmicMapped {
             last_geometry: Arc::new(Mutex::new(None)),
             resize_state: Arc::new(Mutex::new(None)),
             #[cfg(feature = "debug")]
-            debug: Arc::new(Mutex::new(smithay_egui::EguiState::new(
+            debug: Arc::new(Mutex::new(None)),
-                Rectangle::from_loc_and_size((10, 10), (100, 100)),
-            ))),
         }
     }
 }
@@ -738,9 +748,7 @@ impl From<CosmicStack> for CosmicMapped {
             last_geometry: Arc::new(Mutex::new(None)),
             resize_state: Arc::new(Mutex::new(None)),
             #[cfg(feature = "debug")]
-            debug: Arc::new(Mutex::new(smithay_egui::EguiState::new(
+            debug: Arc::new(Mutex::new(None)),
-                Rectangle::from_loc_and_size((10, 10), (100, 100)),
-            ))),
         }
     }
 }
@@ -749,7 +757,6 @@ pub enum CosmicMappedRenderElement<R>
 where
     R: AsGlowRenderer + Renderer + ImportAll,
     <R as Renderer>::TextureId: 'static,
-    <R as Renderer>::Frame: AsGles2Frame,
 {
     Stack(self::stack::CosmicStackRenderElement<R>),
     Window(self::window::CosmicWindowRenderElement<R>),
@@ -761,7 +768,6 @@ impl<R> Element for CosmicMappedRenderElement<R>
 where
     R: AsGlowRenderer + Renderer + ImportAll,
     <R as Renderer>::TextureId: 'static,
-    <R as Renderer>::Frame: AsGles2Frame,
 {
     fn id(&self) -> &smithay::backend::renderer::element::Id {
         match self {
@@ -841,10 +847,9 @@ where
 }
 
 impl RenderElement<GlowRenderer> for CosmicMappedRenderElement<GlowRenderer> {
-    fn draw(
+    fn draw<'frame>(
         &self,
-        renderer: &mut GlowRenderer,
+        frame: &mut <GlowRenderer as Renderer>::Frame<'frame>,
-        frame: &mut <GlowRenderer as Renderer>::Frame,
         location: Point<i32, Physical>,
         scale: Scale<f64>,
         damage: &[Rectangle<i32, Physical>],
@@ -852,14 +857,14 @@ impl RenderElement<GlowRenderer> for CosmicMappedRenderElement<GlowRenderer> {
     ) -> Result<(), <GlowRenderer as Renderer>::Error> {
         match self {
             CosmicMappedRenderElement::Stack(elem) => {
-                elem.draw(renderer, frame, location, scale, damage, log)
+                elem.draw(frame, location, scale, damage, log)
             }
             CosmicMappedRenderElement::Window(elem) => {
-                elem.draw(renderer, frame, location, scale, damage, log)
+                elem.draw(frame, location, scale, damage, log)
             }
             #[cfg(feature = "debug")]
             CosmicMappedRenderElement::Egui(elem) => {
-                elem.draw(renderer, frame, location, scale, damage, log)
+                RenderElement::<GlowRenderer>::draw(elem, frame, location, scale, damage, log)
             }
         }
     }
@@ -878,10 +883,9 @@ impl RenderElement<GlowRenderer> for CosmicMappedRenderElement<GlowRenderer> {
 }
 
 impl<'a> RenderElement<GlMultiRenderer<'a>> for CosmicMappedRenderElement<GlMultiRenderer<'a>> {
-    fn draw(
+    fn draw<'frame>(
         &self,
-        renderer: &mut GlMultiRenderer<'a>,
+        frame: &mut GlMultiFrame<'a, 'frame>,
-        frame: &mut <GlMultiRenderer<'a> as Renderer>::Frame,
         location: Point<i32, Physical>,
         scale: Scale<f64>,
         damage: &[Rectangle<i32, Physical>],
@@ -889,16 +893,15 @@ impl<'a> RenderElement<GlMultiRenderer<'a>> for CosmicMappedRenderElement<GlMult
     ) -> Result<(), <GlMultiRenderer<'_> as Renderer>::Error> {
         match self {
             CosmicMappedRenderElement::Stack(elem) => {
-                elem.draw(renderer, frame, location, scale, damage, log)
+                elem.draw(frame, location, scale, damage, log)
             }
             CosmicMappedRenderElement::Window(elem) => {
-                elem.draw(renderer, frame, location, scale, damage, log)
+                elem.draw(frame, location, scale, damage, log)
             }
             #[cfg(feature = "debug")]
             CosmicMappedRenderElement::Egui(elem) => {
-                let glow_renderer = renderer.glow_renderer_mut();
+                let glow_frame = frame.glow_frame_mut();
-                let gles2_frame = frame.gles2_frame_mut();
+                RenderElement::<GlowRenderer>::draw(elem, glow_frame, location, scale, damage, log)
-                elem.draw(glow_renderer, gles2_frame, location, scale, damage, log)
                     .map_err(|err| MultiError::Render(err))
             }
         }
@@ -929,7 +932,6 @@ impl<R> From<stack::CosmicStackRenderElement<R>> for CosmicMappedRenderElement<R
 where
     R: Renderer + ImportAll + AsGlowRenderer,
     <R as Renderer>::TextureId: 'static,
-    <R as Renderer>::Frame: AsGles2Frame,
     CosmicMappedRenderElement<R>: RenderElement<R>,
 {
     fn from(elem: stack::CosmicStackRenderElement<R>) -> Self {
@@ -940,7 +942,6 @@ impl<R> From<window::CosmicWindowRenderElement<R>> for CosmicMappedRenderElement
 where
     R: Renderer + ImportAll + AsGlowRenderer,
     <R as Renderer>::TextureId: 'static,
-    <R as Renderer>::Frame: AsGles2Frame,
     CosmicMappedRenderElement<R>: RenderElement<R>,
 {
     fn from(elem: window::CosmicWindowRenderElement<R>) -> Self {
@@ -952,7 +953,6 @@ impl<R> From<TextureRenderElement<Gles2Texture>> for CosmicMappedRenderElement<R
 where
     R: Renderer + ImportAll + AsGlowRenderer,
     <R as Renderer>::TextureId: 'static,
-    <R as Renderer>::Frame: AsGles2Frame,
     CosmicMappedRenderElement<R>: RenderElement<R>,
 {
     fn from(elem: TextureRenderElement<Gles2Texture>) -> Self {
@@ -964,137 +964,203 @@ impl<R> AsRenderElements<R> for CosmicMapped
 where
     R: Renderer + ImportAll + AsGlowRenderer,
     <R as Renderer>::TextureId: 'static,
-    <R as Renderer>::Frame: AsGles2Frame,
     CosmicMappedRenderElement<R>: RenderElement<R>,
 {
     type RenderElement = CosmicMappedRenderElement<R>;
     fn render_elements<C: From<Self::RenderElement>>(
         &self,
+        renderer: &mut R,
         location: Point<i32, Physical>,
         scale: Scale<f64>,
     ) -> Vec<C> {
-        let mut elements = match &self.element {
-            CosmicMappedInternal::Stack(s) => AsRenderElements::<R>::render_elements::<
-                CosmicMappedRenderElement<R>,
-            >(s, location, scale),
-            CosmicMappedInternal::Window(w) => AsRenderElements::<R>::render_elements::<
-                CosmicMappedRenderElement<R>,
-            >(w, location, scale),
-            _ => Vec::new(),
-        };
-
-        /*
         #[cfg(feature = "debug")]
-        if !elements.is_empty() {
+        let mut elements = if let Some(debug) = self.debug.lock().unwrap().as_mut() {
             let window = self.active_window();
-            let (app_id, title, min_size, max_size, size, states) = with_states(&window.kind().wl_surface(), |states| {
+            let window_geo = window.geometry();
-                let attributes = states
+            let (app_id, title, min_size, max_size, size, states) =
-                    .data_map
+                with_states(&window.toplevel().wl_surface(), |states| {
-                    .get::<XdgToplevelSurfaceData>()
+                    let attributes = states
-                    .unwrap()
+                        .data_map
-                    .lock()
+                        .get::<XdgToplevelSurfaceData>()
-                    .unwrap();
+                        .unwrap()
-                (attributes.app_id.clone(), attributes.title.clone(), attributes.min_size.clone(), attributes.max_size.clone(), attributes.current.size.clone(), attributes.current.states.clone())
+                        .lock()
-            });
+                        .unwrap();
+                    (
+                        attributes.app_id.clone(),
+                        attributes.title.clone(),
+                        attributes.min_size.clone(),
+                        attributes.max_size.clone(),
+                        attributes.current.size.clone(),
+                        attributes.current.states.clone(),
+                    )
+                });
 
-            let win_geo = self.geometry().size;
+            let area = Rectangle::<i32, Logical>::from_loc_and_size(
-            let area = {
+                location.to_f64().to_logical(scale).to_i32_round(),
-                let size = win_size.clamp((10, 10), (100, 100))};
+                self.bbox().size,
-                let offset = (win_size - (100, 100).into())
+            );
-                    .to_point()
-                    .constain(Rectangle::from_loc_and_size((0, 0), (10, 10)));
-                Rectangle::from_loc_and_size(offset, size)
-            };
 
-            match self.debug.lock().unwrap().render(
+            let glow_renderer = renderer.glow_renderer_mut();
-                |ui| {
+            match debug.render(
-                    egui::Frame::none()
+                |ctx| {
-                        .fill(Color32::DARK_GRAY)
+                    egui::Area::new("window")
-                        .rounding(0.25)
+                        .anchor(
-                        .show(ui, |ui| {
+                            egui::Align2::RIGHT_TOP,
-                            ui.heading(title.as_deref().unwrap_or("<None>"));
+                            [
-                            ui.label(app_id.as_deref().unwrap_or("<None>"));
+                                -window_geo.loc.x as f32 - 10.0,
-                            ui.horizontal(|ui| {
+                                window_geo.loc.y as f32 - 10.0,
-                                ui.label("States: ");
+                            ],
-                                if states.contains(XdgState::Maximized) {
+                        )
-                                    ui.label("🗖");
+                        .show(ctx, |ui| {
-                                }
+                            egui::Frame::none()
-                                if states.contains(XdgState::Fullscreen) {
+                                .fill(egui::Color32::BLACK)
-                                    ui.label("⬜")
+                                .rounding(5.0)
-                                }
+                                .inner_margin(10.0)
-                                if states.contains(XdgState::Activated) {
+                                .show(ui, |ui| {
-                                    ui.label("🖱")
+                                    ui.heading(title.as_deref().unwrap_or("<None>"));
-                                }
+                                    ui.horizontal(|ui| {
-                                if states.contains(XdgState::Resizing) {
+                                        ui.label("App ID: ");
-                                    ui.label("↔")
+                                        ui.label(app_id.as_deref().unwrap_or("<None>"));
-                                }
+                                    });
-                                if states.contains(XdgState::TiledLeft) {
+                                    ui.horizontal(|ui| {
-                                    ui.label("⏴")
+                                        ui.label("States: ");
-                                }
+                                        if states.contains(XdgState::Maximized) {
-                                if states.contains(XdgState::TiledRight) {
+                                            ui.label("🗖");
-                                    ui.label("⏵")
+                                        }
-                                }
+                                        if states.contains(XdgState::Fullscreen) {
-                                if states.contains(XdgState::TiledTop) {
+                                            ui.label("⬜");
-                                    ui.label("⏶")
+                                        }
-                                }
+                                        if states.contains(XdgState::Activated) {
-                                if states.contains(XdgState::TiledBottom) {
+                                            ui.label("🖱");
-                                    ui.label("⏷")
+                                        }
-                                }
+                                        if states.contains(XdgState::Resizing) {
-                            });
+                                            ui.label("↔");
+                                        }
+                                        if states.contains(XdgState::TiledLeft) {
+                                            ui.label("⏴");
+                                        }
+                                        if states.contains(XdgState::TiledRight) {
+                                            ui.label("⏵");
+                                        }
+                                        if states.contains(XdgState::TiledTop) {
+                                            ui.label("⏶");
+                                        }
+                                        if states.contains(XdgState::TiledBottom) {
+                                            ui.label("⏷");
+                                        }
+                                    });
 
-                            let plot = Plot::new("Sizes")
+                                    let plot = Plot::new("Sizes")
-                                .legend(Legend::default().position(Corner::RightBottom))
+                                        .legend(Legend::default().position(Corner::RightBottom))
-                                .show_x(false)
+                                        .data_aspect(1.0)
-                                .show_y(false)
+                                        .view_aspect(1.0)
-                                .data_aspect(0.1);
+                                        .show_x(false)
-                            plot.show(ui, |plot_ui| {
+                                        .show_y(false)
-                                let center = ((max_size.w + 20) / 2, (max_size.h + 20) / 2);
+                                        .width(200.0)
-                                let max_size_rect = Polygon::new(PlotPoints::new(vec![
+                                        .height(200.0);
-                                    (10, 10),
+                                    plot.show(ui, |plot_ui| {
-                                    (max_size.w + 10, 10),
+                                        let center = ((max_size.w + 20) / 2, (max_size.h + 20) / 2);
-                                    (max_size.w + 10, max_size.h + 10),
+                                        let max_size_rect = Polygon::new(PlotPoints::new(vec![
-                                    (10, max_size.h + 10),
+                                            [10.0, 10.0],
-                                    (10, 10),
+                                            [max_size.w as f64 + 10.0, 10.0],
-                                ]));
+                                            [max_size.w as f64 + 10.0, max_size.h as f64 + 10.0],
-                                plot_ui.polygon(max_size_rect.name(format!("{}", max_size)));
+                                            [10.0, max_size.h as f64 + 10.0],
+                                            [10.0, 10.0],
+                                        ]));
+                                        plot_ui.polygon(
+                                            max_size_rect
+                                                .name(format!("{}x{}", max_size.w, max_size.h)),
+                                        );
 
-                                if let Some(size) = size {
+                                        if let Some(size) = size {
-                                    let size_rect = Polygon::new(PlotPoints::new(vec![
+                                            let size_rect = Polygon::new(PlotPoints::new(vec![
-                                        (center.0 - size.w / 2, center.1 - size.h / 2),
+                                                [
-                                        (center.0 + size.w / 2, center.1 - size.w / 2),
+                                                    (center.0 - size.w / 2) as f64,
-                                        (center.0 + size.w / 2, center.1 + size.w / 2),
+                                                    (center.1 - size.h / 2) as f64,
-                                        (center.0 - size.w / 2, center.1 + size.w / 2),
+                                                ],
-                                        (center.0 - size.w / 2, center.1 - size.w / 2),
+                                                [
-                                    ]));
+                                                    (center.0 + size.w / 2) as f64,
-                                    plot_ui.polygon(size_rect.name(format!("{}", size)));
+                                                    (center.1 - size.h / 2) as f64,
-                                }
+                                                ],
+                                                [
+                                                    (center.0 + size.w / 2) as f64,
+                                                    (center.1 + size.h / 2) as f64,
+                                                ],
+                                                [
+                                                    (center.0 - size.w / 2) as f64,
+                                                    (center.1 + size.h / 2) as f64,
+                                                ],
+                                                [
+                                                    (center.0 - size.w / 2) as f64,
+                                                    (center.1 - size.h / 2) as f64,
+                                                ],
+                                            ]));
+                                            plot_ui.polygon(
+                                                size_rect.name(format!("{}x{}", size.w, size.h)),
+                                            );
+                                        }
 
-                                let min_size_rect = Polygon::new(PlotPoints::new(vec![
+                                        let min_size_rect = Polygon::new(PlotPoints::new(vec![
-                                    (center.0 - min_size.w / 2, center.1 - min_size.h / 2),
+                                            [
-                                    (center.0 + min_size.w / 2, center.1 - min_size.w / 2),
+                                                (center.0 - min_size.w / 2) as f64,
-                                    (center.0 + min_size.w / 2, center.1 + min_size.w / 2),
+                                                (center.1 - min_size.h / 2) as f64,
-                                    (center.0 - min_size.w / 2, center.1 + min_size.w / 2),
+                                            ],
-                                    (center.0 - min_size.w / 2, center.1 - min_size.w / 2),
+                                            [
-                                ]));
+                                                (center.0 + min_size.w / 2) as f64,
-                                plot_ui.polygon(min_size_rect.name(format!("{}", min_size)));
+                                                (center.1 - min_size.h / 2) as f64,
-                            })
+                                            ],
+                                            [
+                                                (center.0 + min_size.w / 2) as f64,
+                                                (center.1 + min_size.h / 2) as f64,
+                                            ],
+                                            [
+                                                (center.0 - min_size.w / 2) as f64,
+                                                (center.1 + min_size.h / 2) as f64,
+                                            ],
+                                            [
+                                                (center.0 - min_size.w / 2) as f64,
+                                                (center.1 - min_size.h / 2) as f64,
+                                            ],
+                                        ]));
+                                        plot_ui.polygon(
+                                            min_size_rect
+                                                .name(format!("{}x{}", min_size.w, min_size.h)),
+                                        );
+                                    })
+                                })
                         });
                 },
-                renderer,
+                glow_renderer,
                 area,
-                scale,
+                scale.x,
-                if self.last_cursor_position.lock().unwrap().values().any(|p| area.contains(p.to_i32_round())) {
+                0.8,
-                    0.4
-                } else {
-                    1.0
-                },
-                start_time,
             ) {
-                Ok(element) => elements.push(element),
+                Ok(element) => vec![element.into()],
-                Err(err) => slog_scope::debug!("Error rendering debug overlay: {}", err),
+                Err(err) => {
-            };
+                    slog_scope::debug!("Error rendering debug overlay: {}", err);
-        }
+                    Vec::new()
-        */
+                }
+            }
+        } else {
+            Vec::new()
+        };
+        #[cfg(not(feature = "debug"))]
+        let mut elements = Vec::new();
+
+        #[cfg_attr(not(feature = "debug"), allow(unused_mut))]
+        match &self.element {
+            CosmicMappedInternal::Stack(s) => {
+                elements.extend(AsRenderElements::<R>::render_elements::<
+                    CosmicMappedRenderElement<R>,
+                >(s, renderer, location, scale))
+            }
+            CosmicMappedInternal::Window(w) => {
+                elements.extend(AsRenderElements::<R>::render_elements::<
+                    CosmicMappedRenderElement<R>,
+                >(w, renderer, location, scale))
+            }
+            _ => {}
+        };
 
         elements.into_iter().map(C::from).collect()
     }

src/shell/element/stack.rs

@@ -363,7 +363,7 @@ impl PointerTarget<State> for CosmicStack {
 
 render_elements! {
     pub CosmicStackRenderElement<R> where R: ImportAll;
-    Window=WaylandSurfaceRenderElement,
+    Window=WaylandSurfaceRenderElement<R>,
 }
 
 impl<R> AsRenderElements<R> for CosmicStack
@@ -374,11 +374,13 @@ where
     type RenderElement = CosmicStackRenderElement<R>;
     fn render_elements<C: From<Self::RenderElement>>(
         &self,
+        renderer: &mut R,
         location: Point<i32, Physical>,
         scale: Scale<f64>,
     ) -> Vec<C> {
         AsRenderElements::<R>::render_elements::<CosmicStackRenderElement<R>>(
             &self.windows.lock().unwrap()[self.active.load(Ordering::SeqCst)],
+            renderer,
             location,
             scale,
         )

src/shell/element/window.rs

@@ -236,7 +236,7 @@ impl PointerTarget<State> for CosmicWindow {
 
 render_elements! {
     pub CosmicWindowRenderElement<R> where R: ImportAll;
-    Window=WaylandSurfaceRenderElement,
+    Window=WaylandSurfaceRenderElement<R>,
 }
 
 impl<R> AsRenderElements<R> for CosmicWindow
@@ -247,11 +247,13 @@ where
     type RenderElement = CosmicWindowRenderElement<R>;
     fn render_elements<C: From<Self::RenderElement>>(
         &self,
+        renderer: &mut R,
         location: Point<i32, Physical>,
         scale: Scale<f64>,
     ) -> Vec<C> {
         AsRenderElements::<R>::render_elements::<CosmicWindowRenderElement<R>>(
             &self.window,
+            renderer,
             location,
             scale,
         )

src/shell/layout/floating/grabs/moving.rs

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-only
 
 use crate::{
-    backend::render::element::{AsGles2Frame, AsGlowRenderer},
+    backend::render::element::AsGlowRenderer,
     shell::{
         element::{CosmicMapped, CosmicMappedRenderElement},
         focus::target::{KeyboardFocusTarget, PointerFocusTarget},
@@ -36,11 +36,10 @@ pub struct MoveGrabState {
 }
 
 impl MoveGrabState {
-    pub fn render<I, R>(&self, seat: &Seat<State>, output: &Output) -> Vec<I>
+    pub fn render<I, R>(&self, renderer: &mut R, seat: &Seat<State>, output: &Output) -> Vec<I>
     where
         R: Renderer + ImportAll + AsGlowRenderer,
         <R as Renderer>::TextureId: 'static,
-        <R as Renderer>::Frame: AsGles2Frame,
         CosmicMappedRenderElement<R>: RenderElement<R>,
         I: From<CosmicMappedRenderElement<R>>,
     {
@@ -57,6 +56,7 @@ impl MoveGrabState {
         let scale = output.current_scale().fractional_scale().into();
         AsRenderElements::<R>::render_elements::<I>(
             &self.window,
+            renderer,
             (location.to_i32_round() - output.geometry().loc - self.window.geometry().loc)
                 .to_physical_precise_round(scale),
             scale,

src/shell/layout/floating/mod.rs

@@ -10,7 +10,7 @@ use smithay::{
 use std::collections::HashMap;
 
 use crate::{
-    backend::render::element::{AsGles2Frame, AsGlowRenderer},
+    backend::render::element::AsGlowRenderer,
     shell::{
         element::{CosmicMapped, CosmicMappedRenderElement},
         grabs::ResizeEdge,
@@ -294,18 +294,18 @@ impl FloatingLayout {
 
     pub fn render_output<R>(
         &self,
+        renderer: &mut R,
         output: &Output,
     ) -> Result<Vec<CosmicMappedRenderElement<R>>, OutputNotMapped>
     where
         R: Renderer + ImportAll + AsGlowRenderer,
         <R as Renderer>::TextureId: 'static,
-        <R as Renderer>::Frame: AsGles2Frame,
         CosmicMappedRenderElement<R>: RenderElement<R>,
     {
         let output_scale = output.current_scale().fractional_scale();
         let output_geo = self.space.output_geometry(output).ok_or(OutputNotMapped)?;
         Ok(self
             .space
-            .render_elements_for_region::<R, _>(&output_geo, output_scale))
+            .render_elements_for_region(renderer, &output_geo, output_scale))
     }
 }

src/shell/layout/tiling/mod.rs

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-only
 
 use crate::{
-    backend::render::element::{AsGles2Frame, AsGlowRenderer},
+    backend::render::element::AsGlowRenderer,
     shell::{
         element::{CosmicMapped, CosmicMappedRenderElement},
         focus::{
@@ -1236,12 +1236,12 @@ impl TilingLayout {
 
     pub fn render_output<R>(
         &self,
+        renderer: &mut R,
         output: &Output,
     ) -> Result<Vec<CosmicMappedRenderElement<R>>, OutputNotMapped>
     where
         R: Renderer + ImportAll + AsGlowRenderer,
         <R as Renderer>::TextureId: 'static,
-        <R as Renderer>::Frame: AsGles2Frame,
         CosmicMappedRenderElement<R>: RenderElement<R>,
     {
         let output_scale = output.current_scale().fractional_scale();
@@ -1276,6 +1276,7 @@ impl TilingLayout {
             .flat_map(|(mapped, loc)| {
                 AsRenderElements::<R>::render_elements::<CosmicMappedRenderElement<R>>(
                     mapped,
+                    renderer,
                     loc.to_physical_precise_round(output_scale)
                         - mapped
                             .geometry()

src/shell/mod.rs

@@ -1,5 +1,5 @@
 use serde::{Deserialize, Serialize};
-use std::{collections::HashMap, cell::RefCell};
+use std::{cell::RefCell, collections::HashMap};
 
 use cosmic_protocols::workspace::v1::server::zcosmic_workspace_handle_v1::State as WState;
 use smithay::{
@@ -20,7 +20,7 @@ use smithay::{
 };
 
 use crate::{
-    config::{Config, WorkspaceMode as ConfigMode, OutputConfig},
+    config::{Config, OutputConfig, WorkspaceMode as ConfigMode},
     utils::prelude::*,
     wayland::protocols::{
         toplevel_info::ToplevelInfoState,
@@ -459,13 +459,16 @@ impl Shell {
                 // TODO: Restore any window positions from previous outputs ???
                 state.add_group_output(&set.group, output);
                 for workspace in &mut set.workspaces {
-                    workspace.map_output(output, output.user_data()
+                    workspace.map_output(
-                    .get::<RefCell<OutputConfig>>()
+                        output,
-                    .unwrap()
+                        output
-                    .borrow()
+                            .user_data()
-                    .position
+                            .get::<RefCell<OutputConfig>>()
-                    .into()
+                            .unwrap()
-                 );
+                            .borrow()
+                            .position
+                            .into(),
+                    );
                 }
             }
         }
@@ -538,12 +541,16 @@ impl Shell {
         if let WorkspaceMode::Global(set) = &mut self.workspaces {
             for workspace in &mut set.workspaces {
                 for output in self.outputs.iter() {
-                    workspace.map_output(output, output.user_data()
+                    workspace.map_output(
-                    .get::<RefCell<OutputConfig>>()
+                        output,
-                    .unwrap()
+                        output
-                    .borrow()
+                            .user_data()
-                    .position
+                            .get::<RefCell<OutputConfig>>()
-                    .into());
+                            .unwrap()
+                            .borrow()
+                            .position
+                            .into(),
+                    );
                 }
             }
         }
@@ -966,6 +973,10 @@ impl Shell {
             .toplevel_enter_workspace(&window, &workspace.handle);
 
         let mapped = CosmicMapped::from(CosmicWindow::from(window.clone()));
+        #[cfg(feature = "debug")]
+        {
+            mapped.set_debug(state.common.egui.active);
+        }
         if layout::should_be_floating(&window) || state.common.shell.floating_default {
             workspace.floating_layer.map(mapped.clone(), &seat, None);
         } else {

src/shell/workspace.rs

@@ -1,5 +1,5 @@
 use crate::{
-    backend::render::element::{AsGles2Frame, AsGlowRenderer},
+    backend::render::element::AsGlowRenderer,
     shell::layout::{
         floating::{FloatingLayout, MoveSurfaceGrab},
         tiling::TilingLayout,
@@ -418,12 +418,12 @@ impl Workspace {
 
     pub fn render_output<R>(
         &self,
+        renderer: &mut R,
         output: &Output,
     ) -> Result<Vec<WorkspaceRenderElement<R>>, OutputNotMapped>
     where
         R: Renderer + ImportAll + AsGlowRenderer,
         <R as Renderer>::TextureId: 'static,
-        <R as Renderer>::Frame: AsGles2Frame,
         CosmicMappedRenderElement<R>: RenderElement<R>,
     {
         let mut render_elements = Vec::new();
@@ -446,6 +446,7 @@ impl Workspace {
                     .flat_map(|(loc, surface)| {
                         AsRenderElements::<R>::render_elements::<WorkspaceRenderElement<R>>(
                             surface,
+                            renderer,
                             loc.to_physical_precise_round(output_scale),
                             Scale::from(output_scale),
                         )
@@ -455,7 +456,9 @@ impl Workspace {
             // fullscreen window
             render_elements.extend(AsRenderElements::<R>::render_elements::<
                 WorkspaceRenderElement<R>,
-            >(fullscreen, (0, 0).into(), output_scale.into()));
+            >(
+                fullscreen, renderer, (0, 0).into(), output_scale.into()
+            ));
         } else {
             // TODO: Handle modes like
             // - keyboard window swapping
@@ -479,6 +482,7 @@ impl Workspace {
                         .flat_map(|(loc, surface)| {
                             AsRenderElements::<R>::render_elements::<WorkspaceRenderElement<R>>(
                                 surface,
+                                renderer,
                                 loc.to_physical_precise_round(output_scale),
                                 Scale::from(output_scale),
                             )
@@ -491,7 +495,7 @@ impl Workspace {
             // floating surfaces
             render_elements.extend(
                 self.floating_layer
-                    .render_output::<R>(output)?
+                    .render_output::<R>(renderer, output)?
                     .into_iter()
                     .map(WorkspaceRenderElement::from),
             );
@@ -499,7 +503,7 @@ impl Workspace {
             //tiling surfaces
             render_elements.extend(
                 self.tiling_layer
-                    .render_output::<R>(output)?
+                    .render_output::<R>(renderer, output)?
                     .into_iter()
                     .map(WorkspaceRenderElement::from),
             );
@@ -517,6 +521,7 @@ impl Workspace {
                         .flat_map(|(loc, surface)| {
                             AsRenderElements::<R>::render_elements::<WorkspaceRenderElement<R>>(
                                 surface,
+                                renderer,
                                 loc.to_physical_precise_round(output_scale),
                                 Scale::from(output_scale),
                             )
@@ -545,9 +550,8 @@ pub enum WorkspaceRenderElement<R>
 where
     R: Renderer + ImportAll + AsGlowRenderer,
     <R as Renderer>::TextureId: 'static,
-    <R as Renderer>::Frame: AsGles2Frame,
 {
-    Wayland(WaylandSurfaceRenderElement),
+    Wayland(WaylandSurfaceRenderElement<R>),
     Window(CosmicMappedRenderElement<R>),
 }
 
@@ -555,7 +559,6 @@ impl<R> Element for WorkspaceRenderElement<R>
 where
     R: Renderer + ImportAll + AsGlowRenderer,
     <R as Renderer>::TextureId: 'static,
-    <R as Renderer>::Frame: AsGles2Frame,
 {
     fn id(&self) -> &smithay::backend::renderer::element::Id {
         match self {
@@ -622,25 +625,19 @@ impl<R> RenderElement<R> for WorkspaceRenderElement<R>
 where
     R: Renderer + ImportAll + AsGlowRenderer,
     <R as Renderer>::TextureId: 'static,
-    <R as Renderer>::Frame: AsGles2Frame,
     CosmicMappedRenderElement<R>: RenderElement<R>,
 {
-    fn draw(
+    fn draw<'frame>(
         &self,
-        renderer: &mut R,
+        frame: &mut <R as Renderer>::Frame<'frame>,
-        frame: &mut <R as Renderer>::Frame,
         location: Point<i32, smithay::utils::Physical>,
         scale: Scale<f64>,
         damage: &[Rectangle<i32, smithay::utils::Physical>],
         log: &slog::Logger,
     ) -> Result<(), <R as Renderer>::Error> {
         match self {
-            WorkspaceRenderElement::Wayland(elem) => {
+            WorkspaceRenderElement::Wayland(elem) => elem.draw(frame, location, scale, damage, log),
-                elem.draw(renderer, frame, location, scale, damage, log)
+            WorkspaceRenderElement::Window(elem) => elem.draw(frame, location, scale, damage, log),
-            }
-            WorkspaceRenderElement::Window(elem) => {
-                elem.draw(renderer, frame, location, scale, damage, log)
-            }
         }
     }
 
@@ -655,14 +652,13 @@ where
     }
 }
 
-impl<R> From<WaylandSurfaceRenderElement> for WorkspaceRenderElement<R>
+impl<R> From<WaylandSurfaceRenderElement<R>> for WorkspaceRenderElement<R>
 where
     R: Renderer + ImportAll + AsGlowRenderer,
     <R as Renderer>::TextureId: 'static,
-    <R as Renderer>::Frame: AsGles2Frame,
     CosmicMappedRenderElement<R>: RenderElement<R>,
 {
-    fn from(elem: WaylandSurfaceRenderElement) -> Self {
+    fn from(elem: WaylandSurfaceRenderElement<R>) -> Self {
         WorkspaceRenderElement::Wayland(elem)
     }
 }
@@ -671,7 +667,6 @@ impl<R> From<CosmicMappedRenderElement<R>> for WorkspaceRenderElement<R>
 where
     R: Renderer + ImportAll + AsGlowRenderer,
     <R as Renderer>::TextureId: 'static,
-    <R as Renderer>::Frame: AsGles2Frame,
     CosmicMappedRenderElement<R>: RenderElement<R>,
 {
     fn from(elem: CosmicMappedRenderElement<R>) -> Self {

src/state.rs

@@ -433,6 +433,8 @@ pub struct Egui {
 }
 
 pub struct Fps {
+    #[cfg(feature = "debug")]
+    pub rd: Option<renderdoc::RenderDoc<renderdoc::V110>>,
     #[cfg(feature = "debug")]
     pub state: smithay_egui::EguiState,
     pending_frame: Option<PendingFrame>,
@@ -638,6 +640,8 @@ impl Fps {
         Fps {
             #[cfg(feature = "debug")]
             state,
+            #[cfg(feature = "debug")]
+            rd: renderdoc::RenderDoc::new().ok(),
             pending_frame: None,
             frames: VecDeque::with_capacity(Fps::WINDOW_SIZE + 1),
         }

src/wayland/handlers/screencopy.rs

@@ -725,7 +725,7 @@ pub fn render_workspace_to_buffer(
 
 smithay::render_elements! {
     pub WindowCaptureElement<R> where R: ImportAll;
-    WaylandElement=WaylandSurfaceRenderElement,
+    WaylandElement=WaylandSurfaceRenderElement<R>,
     CursorElement=cursor::CursorRenderElement<R>,
 }
 
@@ -769,6 +769,7 @@ pub fn render_window_to_buffer(
                 WindowCaptureElement<GlowRenderer>,
             >(
                 window,
+                renderer,
                 (-geometry.loc.x, -geometry.loc.y).into(),
                 Scale::from(1.0),
             );
@@ -810,9 +811,14 @@ pub fn render_window_to_buffer(
 
                     if let Some(wl_surface) = get_dnd_icon(seat) {
                         elements.extend(
-                            cursor::draw_dnd_icon(&wl_surface, location.to_i32_round(), 1.0)
+                            cursor::draw_dnd_icon(
-                                .into_iter()
+                                renderer,
-                                .map(WindowCaptureElement::from),
+                                &wl_surface,
+                                location.to_i32_round(),
+                                1.0,
+                            )
+                            .into_iter()
+                            .map(WindowCaptureElement::from),
                         );
                     }
                 }