Update Smithay (Framebuffer type)

Cargo.lock

@@ -30,6 +30,12 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "aliasable"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "250f629c0161ad8107cf89319e990051fae62832fd343083bea452d93e2205fd"
+
 [[package]]
 name = "allocator-api2"
 version = "0.2.21"
@@ -3360,8 +3366,9 @@ checksum = "b7c388c1b5e93756d0c740965c41e8822f866621d41acbdf6336a6a168f8840c"
 [[package]]
 name = "smithay"
 version = "0.5.0"
-source = "git+https://github.com/Smithay/smithay.git#25cf3cf41c5027ffeb55f90c683736726a81d71f"
+source = "git+https://github.com/Smithay/smithay.git#3219a0f02a30de359f460ab165682a51cb13b7a5"
 dependencies = [
+ "aliasable",
  "appendlist",
  "bitflags 2.9.0",
  "calloop 0.14.2",
@@ -3431,7 +3438,7 @@ dependencies = [
 [[package]]
 name = "smithay-drm-extras"
 version = "0.1.0"
-source = "git+https://github.com/Smithay/smithay.git#25cf3cf41c5027ffeb55f90c683736726a81d71f"
+source = "git+https://github.com/Smithay/smithay.git#3219a0f02a30de359f460ab165682a51cb13b7a5"
 dependencies = [
  "drm",
  "libdisplay-info",

niri-visual-tests/src/smithay_view.rs

@@ -17,19 +17,25 @@ mod imp {
     use niri::render_helpers::{resources, shaders};
     use smithay::backend::egl::ffi::egl;
     use smithay::backend::egl::EGLContext;
-    use smithay::backend::renderer::gles::GlesRenderer;
+    use smithay::backend::renderer::gles::{GlesRenderer, GlesTexture};
-    use smithay::backend::renderer::{Color32F, Frame, Renderer, Unbind};
+    use smithay::backend::renderer::{Bind, Color32F, Frame, Offscreen, Renderer};
+    use smithay::reexports::gbm::Format as Fourcc;
     use smithay::utils::{Physical, Rectangle, Scale, Transform};
 
     use super::*;
 
     type DynMakeTestCase = Box<dyn Fn(Args) -> Box<dyn TestCase>>;
 
+    struct RendererData {
+        renderer: GlesRenderer,
+        dummy_texture: GlesTexture,
+    }
+
     #[derive(Default)]
     pub struct SmithayView {
         gl_area: gtk::GLArea,
         size: Cell<(i32, i32)>,
-        renderer: RefCell<Option<Result<GlesRenderer, ()>>>,
+        renderer: RefCell<Option<Result<RendererData, ()>>>,
         pub make_test_case: OnceCell<DynMakeTestCase>,
         test_case: RefCell<Option<Box<dyn TestCase>>>,
         pub clock: RefCell<Clock>,
@@ -125,6 +131,10 @@ mod imp {
             let Ok(renderer) = renderer else {
                 return Ok(());
             };
+            let RendererData {
+                renderer,
+                dummy_texture,
+            } = renderer;
 
             let size = self.size.get();
 
@@ -147,16 +157,45 @@ mod imp {
 
             let rect: Rectangle<i32, Physical> = Rectangle::from_size(Size::from(size));
 
-            let elements = unsafe {
+            // Fetch GtkGLArea's framebuffer binding.
-                with_framebuffer_save_restore(renderer, |renderer| {
+            let mut framebuffer = 0;
-                    case.render(renderer, Size::from(size))
+            renderer
+                .with_context(|gl| unsafe {
+                    gl.GetIntegerv(
+                        smithay::backend::renderer::gles::ffi::FRAMEBUFFER_BINDING,
+                        &mut framebuffer,
+                    );
                 })
-            }?;
+                .context("error running closure in GL context")?;
+            ensure!(framebuffer != 0, "error getting the framebuffer");
+
+            // This call will already change the framebuffer binding (offscreen elements will bind
+            // intermediate textures during rendering).
+            let elements = case.render(renderer, Size::from(size));
+
+            // HACK: there's currently no way to "just" render into an externally bound framebuffer
+            // (like we have in this case). The render() call requires a valid target. So what
+            // we'll do is use a dummy texture as a target, then swap the framebuffer binding right
+            // before rendering.
+            let mut dummy_target = renderer
+                .bind(dummy_texture)
+                .context("error binding dummy texture")?;
 
             let mut frame = renderer
-                .render(rect.size, Transform::Normal)
+                .render(&mut dummy_target, rect.size, Transform::Normal)
                 .context("error creating frame")?;
 
+            // Now that render() bound the dummy texture, change the binding underneath it back to
+            // GtkGLArea's framebuffer, to render there instead.
+            frame
+                .with_context(|gl| unsafe {
+                    gl.BindFramebuffer(
+                        smithay::backend::renderer::gles::ffi::FRAMEBUFFER,
+                        framebuffer as u32,
+                    );
+                })
+                .context("error running closure in GL context")?;
+
             frame
                 .clear(Color32F::from([0.3, 0.3, 0.3, 1.]), &[rect])
                 .context("error clearing")?;
@@ -177,7 +216,7 @@ mod imp {
         }
     }
 
-    unsafe fn create_renderer() -> anyhow::Result<GlesRenderer> {
+    unsafe fn create_renderer() -> anyhow::Result<RendererData> {
         smithay::backend::egl::ffi::make_sure_egl_is_loaded()
             .context("error loading EGL symbols in Smithay")?;
 
@@ -200,40 +239,17 @@ mod imp {
 
         let mut renderer = GlesRenderer::new(egl_context).context("error creating GlesRenderer")?;
 
+        let dummy_texture = renderer
+            .create_buffer(Fourcc::Abgr8888, Size::from((1, 1)))
+            .context("error creating dummy texture")?;
+
         resources::init(&mut renderer);
         shaders::init(&mut renderer);
 
-        Ok(renderer)
+        Ok(RendererData {
-    }
+            renderer,
-
+            dummy_texture,
-    unsafe fn with_framebuffer_save_restore<T>(
+        })
-        renderer: &mut GlesRenderer,
-        f: impl FnOnce(&mut GlesRenderer) -> T,
-    ) -> anyhow::Result<T> {
-        let mut framebuffer = 0;
-        renderer
-            .with_context(|gl| unsafe {
-                gl.GetIntegerv(
-                    smithay::backend::renderer::gles::ffi::FRAMEBUFFER_BINDING,
-                    &mut framebuffer,
-                );
-            })
-            .context("error running closure in GL context")?;
-        ensure!(framebuffer != 0, "error getting the framebuffer");
-
-        let rv = f(renderer);
-
-        renderer.unbind().context("error unbinding")?;
-        renderer
-            .with_context(|gl| unsafe {
-                gl.BindFramebuffer(
-                    smithay::backend::renderer::gles::ffi::FRAMEBUFFER,
-                    framebuffer as u32,
-                );
-            })
-            .context("error running closure in GL context")?;
-
-        Ok(rv)
     }
 }
 

niri-visual-tests/src/test_window.rs

@@ -11,7 +11,7 @@ use niri::render_helpers::solid_color::{SolidColorBuffer, SolidColorRenderElemen
 use niri::render_helpers::{RenderTarget, SplitElements};
 use niri::utils::transaction::Transaction;
 use niri::window::ResolvedWindowRules;
-use smithay::backend::renderer::element::{Id, Kind};
+use smithay::backend::renderer::element::Kind;
 use smithay::output::{self, Output};
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
 use smithay::utils::{Logical, Point, Scale, Serial, Size, Transform};

src/backend/tty.rs

@@ -28,7 +28,7 @@ use smithay::backend::libinput::{LibinputInputBackend, LibinputSessionInterface}
 use smithay::backend::renderer::gles::GlesRenderer;
 use smithay::backend::renderer::multigpu::gbm::GbmGlesBackend;
 use smithay::backend::renderer::multigpu::{GpuManager, MultiFrame, MultiRenderer};
-use smithay::backend::renderer::{DebugFlags, ImportDma, ImportEgl, Renderer};
+use smithay::backend::renderer::{DebugFlags, ImportDma, ImportEgl, RendererSuper};
 use smithay::backend::session::libseat::LibSeatSession;
 use smithay::backend::session::{Event as SessionEvent, Session};
 use smithay::backend::udev::{self, UdevBackend, UdevEvent};
@@ -101,15 +101,16 @@ pub type TtyRenderer<'render> = MultiRenderer<
     GbmGlesBackend<GlesRenderer, DrmDeviceFd>,
 >;
 
-pub type TtyFrame<'render, 'frame> = MultiFrame<
+pub type TtyFrame<'render, 'frame, 'buffer> = MultiFrame<
     'render,
     'render,
     'frame,
+    'buffer,
     GbmGlesBackend<GlesRenderer, DrmDeviceFd>,
     GbmGlesBackend<GlesRenderer, DrmDeviceFd>,
 >;
 
-pub type TtyRendererError<'render> = <TtyRenderer<'render> as Renderer>::Error;
+pub type TtyRendererError<'render> = <TtyRenderer<'render> as RendererSuper>::Error;
 
 type GbmDrmCompositor = DrmCompositor<
     GbmAllocator<DrmDeviceFd>,

src/backend/winit.rs

@@ -190,12 +190,16 @@ impl Winit {
         }
 
         // Hand them over to winit.
-        self.backend.bind().unwrap();
+        let res = {
-        let age = self.backend.buffer_age().unwrap();
+            let (renderer, mut framebuffer) = self.backend.bind().unwrap();
-        let res = self
+            // FIXME: currently impossible to call due to a mutable borrow.
-            .damage_tracker
+            //
-            .render_output(self.backend.renderer(), age, &elements, [0.; 4])
+            // let age = self.backend.buffer_age().unwrap();
-            .unwrap();
+            let age = 0;
+            self.damage_tracker
+                .render_output(renderer, &mut framebuffer, age, &elements, [0.; 4])
+                .unwrap()
+        };
 
         niri.update_primary_scanout_output(output, &res.states);
 

src/niri.rs

@@ -33,7 +33,7 @@ use smithay::backend::renderer::element::{
 };
 use smithay::backend::renderer::gles::GlesRenderer;
 use smithay::backend::renderer::sync::SyncPoint;
-use smithay::backend::renderer::{Color32F, Unbind};
+use smithay::backend::renderer::Color32F;
 use smithay::desktop::utils::{
     bbox_from_surface_tree, output_update, send_dmabuf_feedback_surface_tree,
     send_frames_surface_tree, surface_presentation_feedback_flags_from_states,
@@ -4536,10 +4536,6 @@ impl Niri {
             }
         };
 
-        if let Err(err) = renderer.unbind() {
-            warn!("error unbinding after rendering for screencopy: {err:?}");
-        }
-
         Ok((sync, damages))
     }
 

src/render_helpers/border.rs

@@ -277,7 +277,7 @@ impl Element for BorderRenderElement {
 impl RenderElement<GlesRenderer> for BorderRenderElement {
     fn draw(
         &self,
-        frame: &mut GlesFrame<'_>,
+        frame: &mut GlesFrame<'_, '_>,
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
@@ -294,7 +294,7 @@ impl RenderElement<GlesRenderer> for BorderRenderElement {
 impl<'render> RenderElement<TtyRenderer<'render>> for BorderRenderElement {
     fn draw(
         &self,
-        frame: &mut TtyFrame<'_, '_>,
+        frame: &mut TtyFrame<'_, '_, '_>,
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],

src/render_helpers/clipped_surface.rs

@@ -218,7 +218,7 @@ impl<R: NiriRenderer> Element for ClippedSurfaceRenderElement<R> {
 impl RenderElement<GlesRenderer> for ClippedSurfaceRenderElement<GlesRenderer> {
     fn draw(
         &self,
-        frame: &mut GlesFrame<'_>,
+        frame: &mut GlesFrame<'_, '_>,
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
@@ -242,7 +242,7 @@ impl<'render> RenderElement<TtyRenderer<'render>>
 {
     fn draw(
         &self,
-        frame: &mut TtyFrame<'render, '_>,
+        frame: &mut TtyFrame<'render, '_, '_>,
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],

src/render_helpers/damage.rs

@@ -65,7 +65,7 @@ impl Element for ExtraDamage {
 impl<R: Renderer> RenderElement<R> for ExtraDamage {
     fn draw(
         &self,
-        _frame: &mut <R as Renderer>::Frame<'_>,
+        _frame: &mut R::Frame<'_, '_>,
         _src: Rectangle<f64, Buffer>,
         _dst: Rectangle<i32, Physical>,
         _damage: &[Rectangle<i32, Physical>],

src/render_helpers/mod.rs

@@ -6,7 +6,7 @@ use smithay::backend::allocator::dmabuf::Dmabuf;
 use smithay::backend::allocator::{Buffer, Fourcc};
 use smithay::backend::renderer::element::utils::{Relocate, RelocateRenderElement};
 use smithay::backend::renderer::element::{Kind, RenderElement};
-use smithay::backend::renderer::gles::{GlesMapping, GlesRenderer, GlesTexture};
+use smithay::backend::renderer::gles::{GlesMapping, GlesRenderer, GlesTarget, GlesTexture};
 use smithay::backend::renderer::sync::SyncPoint;
 use smithay::backend::renderer::{Bind, Color32F, ExportMem, Frame, Offscreen, Renderer};
 use smithay::reexports::wayland_server::protocol::wl_buffer::WlBuffer;
@@ -197,15 +197,18 @@ pub fn render_to_texture(
 
     let buffer_size = size.to_logical(1).to_buffer(1, Transform::Normal);
 
-    let texture: GlesTexture = renderer
+    let mut texture: GlesTexture = renderer
         .create_buffer(fourcc, buffer_size)
         .context("error creating texture")?;
 
-    renderer
+    let sync_point = {
-        .bind(texture.clone())
+        let mut target = renderer
-        .context("error binding texture")?;
+            .bind(&mut texture)
+            .context("error binding texture")?;
+
+        render_elements(renderer, &mut target, size, scale, transform, elements)?
+    };
 
-    let sync_point = render_elements(renderer, size, scale, transform, elements)?;
     Ok((texture, sync_point))
 }
 
@@ -219,11 +222,16 @@ pub fn render_and_download(
 ) -> anyhow::Result<GlesMapping> {
     let _span = tracy_client::span!();
 
-    let (_, _) = render_to_texture(renderer, size, scale, transform, fourcc, elements)?;
+    let (mut texture, _) = render_to_texture(renderer, size, scale, transform, fourcc, elements)?;
 
     let buffer_size = size.to_logical(1).to_buffer(1, Transform::Normal);
+    // FIXME: would be nice to avoid binding the second time here (after render_to_texture()), but
+    // borrowing makes this invonvenient.
+    let target = renderer
+        .bind(&mut texture)
+        .context("error binding texture")?;
     let mapping = renderer
-        .copy_framebuffer(Rectangle::from_size(buffer_size), fourcc)
+        .copy_framebuffer(&target, Rectangle::from_size(buffer_size), fourcc)
         .context("error copying framebuffer")?;
     Ok(mapping)
 }
@@ -248,7 +256,7 @@ pub fn render_to_vec(
 
 pub fn render_to_dmabuf(
     renderer: &mut GlesRenderer,
-    dmabuf: Dmabuf,
+    mut dmabuf: Dmabuf,
     size: Size<i32, Physical>,
     scale: Scale<f64>,
     transform: Transform,
@@ -259,8 +267,10 @@ pub fn render_to_dmabuf(
         dmabuf.width() == size.w as u32 && dmabuf.height() == size.h as u32,
         "invalid buffer size"
     );
-    renderer.bind(dmabuf).context("error binding texture")?;
+    let mut target = renderer
-    render_elements(renderer, size, scale, transform, elements)
+        .bind(&mut dmabuf)
+        .context("error binding texture")?;
+    render_elements(renderer, &mut target, size, scale, transform, elements)
 }
 
 pub fn render_to_shm(
@@ -301,6 +311,7 @@ pub fn render_to_shm(
 
 fn render_elements(
     renderer: &mut GlesRenderer,
+    target: &mut GlesTarget,
     size: Size<i32, Physical>,
     scale: Scale<f64>,
     transform: Transform,
@@ -310,7 +321,7 @@ fn render_elements(
     let output_rect = Rectangle::from_size(transform.transform_size(size));
 
     let mut frame = renderer
-        .render(size, transform)
+        .render(target, size, transform)
         .context("error starting frame")?;
 
     frame

src/render_helpers/offscreen.rs

@@ -171,7 +171,7 @@ impl Element for OffscreenRenderElement {
 impl RenderElement<GlesRenderer> for OffscreenRenderElement {
     fn draw(
         &self,
-        frame: &mut GlesFrame<'_>,
+        frame: &mut GlesFrame<'_, '_>,
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
@@ -212,7 +212,7 @@ impl RenderElement<GlesRenderer> for OffscreenRenderElement {
 impl<'render> RenderElement<TtyRenderer<'render>> for OffscreenRenderElement {
     fn draw(
         &self,
-        frame: &mut TtyFrame<'_, '_>,
+        frame: &mut TtyFrame<'_, '_, '_>,
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],

src/render_helpers/primary_gpu_texture.rs

@@ -56,7 +56,7 @@ impl Element for PrimaryGpuTextureRenderElement {
 impl RenderElement<GlesRenderer> for PrimaryGpuTextureRenderElement {
     fn draw(
         &self,
-        frame: &mut GlesFrame<'_>,
+        frame: &mut GlesFrame<'_, '_>,
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
@@ -77,7 +77,7 @@ impl RenderElement<GlesRenderer> for PrimaryGpuTextureRenderElement {
 impl<'render> RenderElement<TtyRenderer<'render>> for PrimaryGpuTextureRenderElement {
     fn draw(
         &self,
-        frame: &mut TtyFrame<'_, '_>,
+        frame: &mut TtyFrame<'_, '_, '_>,
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],

src/render_helpers/render_elements.rs

@@ -99,7 +99,7 @@ macro_rules! niri_render_elements {
         {
             fn draw(
                 &self,
-                frame: &mut smithay::backend::renderer::gles::GlesFrame<'_>,
+                frame: &mut smithay::backend::renderer::gles::GlesFrame<'_, '_>,
                 src: smithay::utils::Rectangle<f64, smithay::utils::Buffer>,
                 dst: smithay::utils::Rectangle<i32, smithay::utils::Physical>,
                 damage: &[smithay::utils::Rectangle<i32, smithay::utils::Physical>],
@@ -124,7 +124,7 @@ macro_rules! niri_render_elements {
         {
             fn draw(
                 &self,
-                frame: &mut $crate::backend::tty::TtyFrame<'render, '_>,
+                frame: &mut $crate::backend::tty::TtyFrame<'render, '_, '_>,
                 src: smithay::utils::Rectangle<f64, smithay::utils::Buffer>,
                 dst: smithay::utils::Rectangle<i32, smithay::utils::Physical>,
                 damage: &[smithay::utils::Rectangle<i32, smithay::utils::Physical>],

src/render_helpers/renderer.rs

@@ -1,7 +1,7 @@
 use smithay::backend::allocator::dmabuf::Dmabuf;
 use smithay::backend::renderer::gles::{GlesFrame, GlesRenderer, GlesTexture};
 use smithay::backend::renderer::{
-    Bind, ExportMem, ImportAll, ImportMem, Offscreen, Renderer, Texture,
+    Bind, ExportMem, ImportAll, ImportMem, Offscreen, Renderer, RendererSuper, Texture,
 };
 
 use crate::backend::tty::{TtyFrame, TtyRenderer};
@@ -21,7 +21,7 @@ pub trait NiriRenderer:
     type NiriError: std::error::Error
         + Send
         + Sync
-        + From<<GlesRenderer as Renderer>::Error>
+        + From<<GlesRenderer as RendererSuper>::Error>
         + 'static;
 }
 
@@ -29,7 +29,8 @@ impl<R> NiriRenderer for R
 where
     R: ImportAll + ImportMem + ExportMem + Bind<Dmabuf> + Offscreen<GlesTexture> + AsGlesRenderer,
     R::TextureId: Texture + Clone + Send + 'static,
-    R::Error: std::error::Error + Send + Sync + From<<GlesRenderer as Renderer>::Error> + 'static,
+    R::Error:
+        std::error::Error + Send + Sync + From<<GlesRenderer as RendererSuper>::Error> + 'static,
 {
     type NiriTextureId = R::TextureId;
     type NiriError = R::Error;
@@ -53,21 +54,21 @@ impl AsGlesRenderer for TtyRenderer<'_> {
 }
 
 /// Trait for getting the underlying `GlesFrame`.
-pub trait AsGlesFrame<'frame>
+pub trait AsGlesFrame<'frame, 'buffer>
 where
     Self: 'frame,
 {
-    fn as_gles_frame(&mut self) -> &mut GlesFrame<'frame>;
+    fn as_gles_frame(&mut self) -> &mut GlesFrame<'frame, 'buffer>;
 }
 
-impl<'frame> AsGlesFrame<'frame> for GlesFrame<'frame> {
+impl<'frame, 'buffer> AsGlesFrame<'frame, 'buffer> for GlesFrame<'frame, 'buffer> {
-    fn as_gles_frame(&mut self) -> &mut GlesFrame<'frame> {
+    fn as_gles_frame(&mut self) -> &mut GlesFrame<'frame, 'buffer> {
         self
     }
 }
 
-impl<'frame> AsGlesFrame<'frame> for TtyFrame<'_, 'frame> {
+impl<'frame, 'buffer> AsGlesFrame<'frame, 'buffer> for TtyFrame<'_, 'frame, 'buffer> {
-    fn as_gles_frame(&mut self) -> &mut GlesFrame<'frame> {
+    fn as_gles_frame(&mut self) -> &mut GlesFrame<'frame, 'buffer> {
         self.as_mut()
     }
 }

src/render_helpers/resize.rs

@@ -163,7 +163,7 @@ impl Element for ResizeRenderElement {
 impl RenderElement<GlesRenderer> for ResizeRenderElement {
     fn draw(
         &self,
-        frame: &mut GlesFrame<'_>,
+        frame: &mut GlesFrame<'_, '_>,
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
@@ -181,7 +181,7 @@ impl RenderElement<GlesRenderer> for ResizeRenderElement {
 impl<'render> RenderElement<TtyRenderer<'render>> for ResizeRenderElement {
     fn draw(
         &self,
-        frame: &mut TtyFrame<'_, '_>,
+        frame: &mut TtyFrame<'_, '_, '_>,
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],

src/render_helpers/shader_element.rs

@@ -283,7 +283,7 @@ impl Element for ShaderRenderElement {
 impl RenderElement<GlesRenderer> for ShaderRenderElement {
     fn draw(
         &self,
-        frame: &mut GlesFrame<'_>,
+        frame: &mut GlesFrame<'_, '_>,
         src: Rectangle<f64, Buffer>,
         dest: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
@@ -514,7 +514,7 @@ impl RenderElement<GlesRenderer> for ShaderRenderElement {
 impl<'render> RenderElement<TtyRenderer<'render>> for ShaderRenderElement {
     fn draw(
         &self,
-        frame: &mut TtyFrame<'_, '_>,
+        frame: &mut TtyFrame<'_, '_, '_>,
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],

src/render_helpers/shaders/mod.rs

@@ -107,7 +107,7 @@ impl Shaders {
         }
     }
 
-    pub fn get_from_frame<'a>(frame: &'a mut GlesFrame<'_>) -> &'a Self {
+    pub fn get_from_frame<'a>(frame: &'a mut GlesFrame<'_, '_>) -> &'a Self {
         let data = frame.egl_context().user_data();
         data.get()
             .expect("shaders::init() must be called when creating the renderer")

src/render_helpers/shadow.rs

@@ -233,7 +233,7 @@ impl Element for ShadowRenderElement {
 impl RenderElement<GlesRenderer> for ShadowRenderElement {
     fn draw(
         &self,
-        frame: &mut GlesFrame<'_>,
+        frame: &mut GlesFrame<'_, '_>,
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
@@ -250,7 +250,7 @@ impl RenderElement<GlesRenderer> for ShadowRenderElement {
 impl<'render> RenderElement<TtyRenderer<'render>> for ShadowRenderElement {
     fn draw(
         &self,
-        frame: &mut TtyFrame<'_, '_>,
+        frame: &mut TtyFrame<'_, '_, '_>,
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],

src/render_helpers/solid_color.rs

@@ -153,12 +153,12 @@ impl Element for SolidColorRenderElement {
 impl<R: Renderer> RenderElement<R> for SolidColorRenderElement {
     fn draw(
         &self,
-        frame: &mut <R as Renderer>::Frame<'_>,
+        frame: &mut R::Frame<'_, '_>,
         _src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
         _opaque_regions: &[Rectangle<i32, Physical>],
-    ) -> Result<(), <R as Renderer>::Error> {
+    ) -> Result<(), R::Error> {
         frame.draw_solid(dst, damage, self.color)
     }
 

src/render_helpers/texture.rs

@@ -58,7 +58,7 @@ impl<T> TextureBuffer<T> {
         scale: impl Into<Scale<f64>>,
         transform: Transform,
         opaque_regions: Vec<Rectangle<i32, Buffer>>,
-    ) -> Result<Self, <R as Renderer>::Error> {
+    ) -> Result<Self, R::Error> {
         let texture = renderer.import_memory(data, format, size.into(), flipped)?;
         Ok(TextureBuffer::from_texture(
             renderer,
@@ -72,7 +72,7 @@ impl<T> TextureBuffer<T> {
     pub fn from_memory_buffer<R: Renderer<TextureId = T> + ImportMem>(
         renderer: &mut R,
         buffer: &MemoryBuffer,
-    ) -> Result<Self, <R as Renderer>::Error> {
+    ) -> Result<Self, R::Error> {
         Self::from_memory(
             renderer,
             buffer.data(),
@@ -213,12 +213,12 @@ where
 {
     fn draw(
         &self,
-        frame: &mut <R as Renderer>::Frame<'_>,
+        frame: &mut R::Frame<'_, '_>,
         src: Rectangle<f64, Buffer>,
         dest: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
         opaque_regions: &[Rectangle<i32, Physical>],
-    ) -> Result<(), <R as Renderer>::Error> {
+    ) -> Result<(), R::Error> {
         if frame.id() != self.buffer.renderer_id {
             warn!("trying to render texture from different renderer");
             return Ok(());