Update Smithay

Cargo.lock

@@ -3162,7 +3162,7 @@ checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
 [[package]]
 name = "smithay"
 version = "0.3.0"
-source = "git+https://github.com/Smithay/smithay.git#24e36e97a1844d575a1586d3cddcc94d96c2044d"
+source = "git+https://github.com/Smithay/smithay.git#6169b213fb663d85d2e139d3bbe44dfae1ec9328"
 dependencies = [
  "appendlist",
  "bitflags 2.5.0",
@@ -3234,7 +3234,7 @@ dependencies = [
 [[package]]
 name = "smithay-drm-extras"
 version = "0.1.0"
-source = "git+https://github.com/Smithay/smithay.git#24e36e97a1844d575a1586d3cddcc94d96c2044d"
+source = "git+https://github.com/Smithay/smithay.git#6169b213fb663d85d2e139d3bbe44dfae1ec9328"
 dependencies = [
  "drm",
  "edid-rs",

niri-visual-tests/src/smithay_view.rs

@@ -157,7 +157,7 @@ mod imp {
                 if let Some(mut damage) = rect.intersection(dst) {
                     damage.loc -= dst.loc;
                     element
-                        .draw(&mut frame, src, dst, &[damage])
+                        .draw(&mut frame, src, dst, &[damage], &[])
                         .context("error drawing element")?;
                 }
             }

src/render_helpers/border.rs

@@ -239,8 +239,9 @@ impl RenderElement<GlesRenderer> for BorderRenderElement {
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
+        opaque_regions: &[Rectangle<i32, Physical>],
     ) -> Result<(), GlesError> {
-        RenderElement::<GlesRenderer>::draw(&self.inner, frame, src, dst, damage)
+        RenderElement::<GlesRenderer>::draw(&self.inner, frame, src, dst, damage, opaque_regions)
     }
 
     fn underlying_storage(&self, renderer: &mut GlesRenderer) -> Option<UnderlyingStorage> {
@@ -255,8 +256,9 @@ impl<'render> RenderElement<TtyRenderer<'render>> for BorderRenderElement {
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
+        opaque_regions: &[Rectangle<i32, Physical>],
     ) -> Result<(), TtyRendererError<'render>> {
-        RenderElement::<TtyRenderer<'_>>::draw(&self.inner, frame, src, dst, damage)
+        RenderElement::<TtyRenderer<'_>>::draw(&self.inner, frame, src, dst, damage, opaque_regions)
     }
 
     fn underlying_storage(&self, renderer: &mut TtyRenderer<'render>) -> Option<UnderlyingStorage> {

src/render_helpers/clipped_surface.rs

@@ -215,6 +215,7 @@ impl RenderElement<GlesRenderer> for ClippedSurfaceRenderElement<GlesRenderer> {
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
+        opaque_regions: &[Rectangle<i32, Physical>],
     ) -> Result<(), GlesError> {
         frame.override_default_tex_program(
             self.program.clone(),
@@ -227,7 +228,7 @@ impl RenderElement<GlesRenderer> for ClippedSurfaceRenderElement<GlesRenderer> {
                 mat3_uniform("input_to_geo", self.input_to_geo),
             ],
         );
-        RenderElement::<GlesRenderer>::draw(&self.inner, frame, src, dst, damage)?;
+        RenderElement::<GlesRenderer>::draw(&self.inner, frame, src, dst, damage, opaque_regions)?;
         frame.clear_tex_program_override();
         Ok(())
     }
@@ -248,6 +249,7 @@ impl<'render> RenderElement<TtyRenderer<'render>>
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
+        opaque_regions: &[Rectangle<i32, Physical>],
     ) -> Result<(), TtyRendererError<'render>> {
         frame.as_gles_frame().override_default_tex_program(
             self.program.clone(),
@@ -260,7 +262,7 @@ impl<'render> RenderElement<TtyRenderer<'render>>
                 mat3_uniform("input_to_geo", self.input_to_geo),
             ],
         );
-        RenderElement::draw(&self.inner, frame, src, dst, damage)?;
+        RenderElement::draw(&self.inner, frame, src, dst, damage, opaque_regions)?;
         frame.as_gles_frame().clear_tex_program_override();
         Ok(())
     }

src/render_helpers/damage.rs

@@ -69,6 +69,7 @@ impl<R: Renderer> RenderElement<R> for ExtraDamage {
         _src: Rectangle<f64, Buffer>,
         _dst: Rectangle<i32, Physical>,
         _damage: &[Rectangle<i32, Physical>],
+        _opaque_regions: &[Rectangle<i32, Physical>],
     ) -> Result<(), R::Error> {
         Ok(())
     }

src/render_helpers/mod.rs

@@ -320,7 +320,7 @@ fn render_elements(
         if let Some(mut damage) = output_rect.intersection(dst) {
             damage.loc -= dst.loc;
             element
-                .draw(&mut frame, src, dst, &[damage])
+                .draw(&mut frame, src, dst, &[damage], &[])
                 .context("error drawing element")?;
         }
     }

src/render_helpers/offscreen.rs

@@ -175,12 +175,27 @@ impl RenderElement<GlesRenderer> for OffscreenRenderElement {
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
+        opaque_regions: &[Rectangle<i32, Physical>],
     ) -> Result<(), GlesError> {
         let gles_frame = frame.as_gles_frame();
         if let Some(texture) = &self.texture {
-            RenderElement::<GlesRenderer>::draw(texture, gles_frame, src, dst, damage)?;
+            RenderElement::<GlesRenderer>::draw(
+                texture,
+                gles_frame,
+                src,
+                dst,
+                damage,
+                opaque_regions,
+            )?;
         } else {
-            RenderElement::<GlesRenderer>::draw(&self.fallback, gles_frame, src, dst, damage)?;
+            RenderElement::<GlesRenderer>::draw(
+                &self.fallback,
+                gles_frame,
+                src,
+                dst,
+                damage,
+                opaque_regions,
+            )?;
         }
         Ok(())
     }
@@ -201,12 +216,27 @@ impl<'render> RenderElement<TtyRenderer<'render>> for OffscreenRenderElement {
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
+        opaque_regions: &[Rectangle<i32, Physical>],
     ) -> Result<(), TtyRendererError<'render>> {
         let gles_frame = frame.as_gles_frame();
         if let Some(texture) = &self.texture {
-            RenderElement::<GlesRenderer>::draw(texture, gles_frame, src, dst, damage)?;
+            RenderElement::<GlesRenderer>::draw(
+                texture,
+                gles_frame,
+                src,
+                dst,
+                damage,
+                opaque_regions,
+            )?;
         } else {
-            RenderElement::<GlesRenderer>::draw(&self.fallback, gles_frame, src, dst, damage)?;
+            RenderElement::<GlesRenderer>::draw(
+                &self.fallback,
+                gles_frame,
+                src,
+                dst,
+                damage,
+                opaque_regions,
+            )?;
         }
         Ok(())
     }

src/render_helpers/primary_gpu_texture.rs

@@ -60,9 +60,10 @@ impl RenderElement<GlesRenderer> for PrimaryGpuTextureRenderElement {
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
+        opaque_regions: &[Rectangle<i32, Physical>],
     ) -> Result<(), GlesError> {
         let gles_frame = frame.as_gles_frame();
-        RenderElement::<GlesRenderer>::draw(&self.0, gles_frame, src, dst, damage)?;
+        RenderElement::<GlesRenderer>::draw(&self.0, gles_frame, src, dst, damage, opaque_regions)?;
         Ok(())
     }
 
@@ -80,9 +81,10 @@ impl<'render> RenderElement<TtyRenderer<'render>> for PrimaryGpuTextureRenderEle
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
+        opaque_regions: &[Rectangle<i32, Physical>],
     ) -> Result<(), TtyRendererError<'render>> {
         let gles_frame = frame.as_gles_frame();
-        RenderElement::<GlesRenderer>::draw(&self.0, gles_frame, src, dst, damage)?;
+        RenderElement::<GlesRenderer>::draw(&self.0, gles_frame, src, dst, damage, opaque_regions)?;
         Ok(())
     }
 

src/render_helpers/render_elements.rs

@@ -103,10 +103,11 @@ macro_rules! niri_render_elements {
                 src: smithay::utils::Rectangle<f64, smithay::utils::Buffer>,
                 dst: smithay::utils::Rectangle<i32, smithay::utils::Physical>,
                 damage: &[smithay::utils::Rectangle<i32, smithay::utils::Physical>],
+                opaque_regions: &[smithay::utils::Rectangle<i32, smithay::utils::Physical>],
             ) -> Result<(), smithay::backend::renderer::gles::GlesError> {
                 match self {
                     $($name::$variant(elem) => {
-                        smithay::backend::renderer::element::RenderElement::<smithay::backend::renderer::gles::GlesRenderer>::draw(elem, frame, src, dst, damage)
+                        smithay::backend::renderer::element::RenderElement::<smithay::backend::renderer::gles::GlesRenderer>::draw(elem, frame, src, dst, damage, opaque_regions)
                     })+
                 }
             }
@@ -127,10 +128,11 @@ macro_rules! niri_render_elements {
                 src: smithay::utils::Rectangle<f64, smithay::utils::Buffer>,
                 dst: smithay::utils::Rectangle<i32, smithay::utils::Physical>,
                 damage: &[smithay::utils::Rectangle<i32, smithay::utils::Physical>],
+                opaque_regions: &[smithay::utils::Rectangle<i32, smithay::utils::Physical>],
             ) -> Result<(), $crate::backend::tty::TtyRendererError<'render>> {
                 match self {
                     $($name::$variant(elem) => {
-                        smithay::backend::renderer::element::RenderElement::<$crate::backend::tty::TtyRenderer<'render>>::draw(elem, frame, src, dst, damage)
+                        smithay::backend::renderer::element::RenderElement::<$crate::backend::tty::TtyRenderer<'render>>::draw(elem, frame, src, dst, damage, opaque_regions)
                     })+
                 }
             }

src/render_helpers/resize.rs

@@ -166,8 +166,9 @@ impl RenderElement<GlesRenderer> for ResizeRenderElement {
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
+        opaque_regions: &[Rectangle<i32, Physical>],
     ) -> Result<(), GlesError> {
-        RenderElement::<GlesRenderer>::draw(&self.0, frame, src, dst, damage)?;
+        RenderElement::<GlesRenderer>::draw(&self.0, frame, src, dst, damage, opaque_regions)?;
         Ok(())
     }
 
@@ -183,9 +184,10 @@ impl<'render> RenderElement<TtyRenderer<'render>> for ResizeRenderElement {
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
+        opaque_regions: &[Rectangle<i32, Physical>],
     ) -> Result<(), TtyRendererError<'render>> {
         let gles_frame = frame.as_gles_frame();
-        RenderElement::<GlesRenderer>::draw(&self.0, gles_frame, src, dst, damage)?;
+        RenderElement::<GlesRenderer>::draw(&self.0, gles_frame, src, dst, damage, opaque_regions)?;
         Ok(())
     }
 

src/render_helpers/shader_element.rs

@@ -297,6 +297,7 @@ impl RenderElement<GlesRenderer> for ShaderRenderElement {
         src: Rectangle<f64, Buffer>,
         dest: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
+        _opaque_regions: &[Rectangle<i32, Physical>],
     ) -> Result<(), GlesError> {
         let frame = frame.as_gles_frame();
 
@@ -526,10 +527,11 @@ impl<'render> RenderElement<TtyRenderer<'render>> for ShaderRenderElement {
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
+        opaque_regions: &[Rectangle<i32, Physical>],
     ) -> Result<(), TtyRendererError<'render>> {
         let frame = frame.as_gles_frame();
 
-        RenderElement::<GlesRenderer>::draw(self, frame, src, dst, damage)?;
+        RenderElement::<GlesRenderer>::draw(self, frame, src, dst, damage, opaque_regions)?;
 
         Ok(())
     }

src/render_helpers/solid_color.rs

@@ -157,6 +157,7 @@ impl<R: Renderer> RenderElement<R> for SolidColorRenderElement {
         _src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
+        _opaque_regions: &[Rectangle<i32, Physical>],
     ) -> Result<(), <R as Renderer>::Error> {
         frame.draw_solid(dst, damage, self.color)
     }

src/render_helpers/texture.rs

@@ -203,6 +203,7 @@ where
         src: Rectangle<f64, Buffer>,
         dest: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
+        opaque_regions: &[Rectangle<i32, Physical>],
     ) -> Result<(), <R as Renderer>::Error> {
         if frame.id() != self.buffer.renderer_id {
             warn!("trying to render texture from different renderer");
@@ -214,6 +215,7 @@ where
             src,
             dest,
             damage,
+            opaque_regions,
             self.buffer.transform,
             self.alpha,
         )