Update Smithay and other deps

src/handlers/compositor.rs

@@ -54,7 +54,7 @@ impl CompositorHandler for State {
                     .buffer
                     .as_ref()
                     .and_then(|assignment| match assignment {
-                        BufferAssignment::NewBuffer(buffer) => get_dmabuf(buffer).ok(),
+                        BufferAssignment::NewBuffer(buffer) => get_dmabuf(buffer).cloned().ok(),
                         _ => None,
                     })
             });

src/niri.rs

@@ -491,6 +491,7 @@ impl State {
         self.niri.cursor_manager.check_cursor_image_surface_alive();
         self.niri.refresh_pointer_outputs();
         self.niri.popups.cleanup();
+        self.niri.global_space.refresh();
         self.niri.refresh_idle_inhibit();
         self.refresh_popup_grab();
         self.update_keyboard_focus();

src/pw_utils.rs

@@ -24,7 +24,7 @@ use pipewire::spa::utils::{
 };
 use pipewire::stream::{Stream, StreamFlags, StreamListener, StreamState};
 use smithay::backend::allocator::dmabuf::{AsDmabuf, Dmabuf};
-use smithay::backend::allocator::gbm::{GbmBufferFlags, GbmDevice};
+use smithay::backend::allocator::gbm::{GbmBuffer, GbmBufferFlags, GbmDevice};
 use smithay::backend::allocator::Fourcc;
 use smithay::backend::drm::DrmDeviceFd;
 use smithay::output::Output;
@@ -292,7 +292,8 @@ impl PipeWire {
                                 return;
                             }
                         };
-                        let dmabuf = match bo.export() {
+                        let buffer = GbmBuffer::from_bo(bo, true);
+                        let dmabuf = match buffer.export() {
                             Ok(dmabuf) => dmabuf,
                             Err(err) => {
                                 warn!("error exporting GBM buffer object as dmabuf: {err:?}");

src/render_helpers/border.rs

@@ -4,7 +4,7 @@ use glam::{Mat3, Vec2};
 use niri_config::CornerRadius;
 use smithay::backend::renderer::element::{Element, Id, Kind, RenderElement, UnderlyingStorage};
 use smithay::backend::renderer::gles::{GlesError, GlesFrame, GlesRenderer, Uniform};
-use smithay::backend::renderer::utils::{CommitCounter, DamageSet};
+use smithay::backend::renderer::utils::{CommitCounter, DamageSet, OpaqueRegions};
 use smithay::utils::{Buffer, Logical, Physical, Point, Rectangle, Scale, Size, Transform};
 
 use super::renderer::NiriRenderer;
@@ -219,7 +219,7 @@ impl Element for BorderRenderElement {
         self.inner.damage_since(scale, commit)
     }
 
-    fn opaque_regions(&self, scale: Scale<f64>) -> Vec<Rectangle<i32, Physical>> {
+    fn opaque_regions(&self, scale: Scale<f64>) -> OpaqueRegions<i32, Physical> {
         self.inner.opaque_regions(scale)
     }
 

src/render_helpers/clipped_surface.rs

@@ -5,7 +5,7 @@ use smithay::backend::renderer::element::{Element, Id, Kind, RenderElement, Unde
 use smithay::backend::renderer::gles::{
     GlesError, GlesFrame, GlesRenderer, GlesTexProgram, Uniform,
 };
-use smithay::backend::renderer::utils::{CommitCounter, DamageSet};
+use smithay::backend::renderer::utils::{CommitCounter, DamageSet, OpaqueRegions};
 use smithay::utils::{Buffer, Logical, Physical, Rectangle, Scale, Size, Transform};
 
 use super::damage::ExtraDamage;
@@ -45,10 +45,10 @@ impl<R: NiriRenderer> ClippedSurfaceRenderElement<R> {
         let geo_loc = Vec2::new(geo.loc.x, geo.loc.y);
         let geo_size = Vec2::new(geo.size.w, geo.size.h);
 
-        let buf_size = elem.buffer_size().unwrap();
+        let buf_size = elem.buffer_size();
         let buf_size = Vec2::new(buf_size.w as f32, buf_size.h as f32);
 
-        let view = elem.view().unwrap();
+        let view = elem.view();
         let src_loc = Vec2::new(view.src.loc.x as f32, view.src.loc.y as f32);
         let src_size = Vec2::new(view.src.size.w as f32, view.src.size.h as f32);
 
@@ -172,7 +172,7 @@ impl<R: NiriRenderer> Element for ClippedSurfaceRenderElement<R> {
             .collect()
     }
 
-    fn opaque_regions(&self, scale: Scale<f64>) -> Vec<Rectangle<i32, Physical>> {
+    fn opaque_regions(&self, scale: Scale<f64>) -> OpaqueRegions<i32, Physical> {
         let regions = self.inner.opaque_regions(scale);
 
         // Intersect with geometry, since we're clipping by it.
@@ -195,7 +195,7 @@ impl<R: NiriRenderer> Element for ClippedSurfaceRenderElement<R> {
                 rect
             });
 
-            Rectangle::subtract_rects_many(regions, corners)
+            OpaqueRegions::from_slice(&Rectangle::subtract_rects_many(regions, corners))
         }
     }
 

src/render_helpers/debug.rs

@@ -24,7 +24,7 @@ pub fn draw_opaque_regions<R: NiriRenderer>(
         }
 
         let geo = elem.geometry(scale);
-        let mut opaque = elem.opaque_regions(scale);
+        let mut opaque = elem.opaque_regions(scale).to_vec();
 
         for rect in &mut opaque {
             rect.loc += geo.loc;

src/render_helpers/offscreen.rs

@@ -4,7 +4,7 @@ use smithay::backend::renderer::element::texture::{TextureBuffer, TextureRenderE
 use smithay::backend::renderer::element::utils::{Relocate, RelocateRenderElement};
 use smithay::backend::renderer::element::{Element, Id, Kind, RenderElement, UnderlyingStorage};
 use smithay::backend::renderer::gles::{GlesError, GlesFrame, GlesRenderer};
-use smithay::backend::renderer::utils::{CommitCounter, DamageSet};
+use smithay::backend::renderer::utils::{CommitCounter, DamageSet, OpaqueRegions};
 use smithay::utils::{Buffer, Physical, Rectangle, Scale, Transform};
 
 use super::primary_gpu_texture::PrimaryGpuTextureRenderElement;
@@ -138,7 +138,7 @@ impl Element for OffscreenRenderElement {
         }
     }
 
-    fn opaque_regions(&self, scale: Scale<f64>) -> Vec<Rectangle<i32, Physical>> {
+    fn opaque_regions(&self, scale: Scale<f64>) -> OpaqueRegions<i32, Physical> {
         if let Some(texture) = &self.texture {
             texture.opaque_regions(scale)
         } else {

src/render_helpers/primary_gpu_texture.rs

@@ -1,7 +1,7 @@
 use smithay::backend::renderer::element::texture::TextureRenderElement;
 use smithay::backend::renderer::element::{Element, Id, Kind, RenderElement, UnderlyingStorage};
 use smithay::backend::renderer::gles::{GlesError, GlesFrame, GlesRenderer, GlesTexture};
-use smithay::backend::renderer::utils::{CommitCounter, DamageSet};
+use smithay::backend::renderer::utils::{CommitCounter, DamageSet, OpaqueRegions};
 use smithay::utils::{Buffer, Physical, Rectangle, Scale, Transform};
 
 use super::renderer::AsGlesFrame;
@@ -40,7 +40,7 @@ impl Element for PrimaryGpuTextureRenderElement {
         self.0.damage_since(scale, commit)
     }
 
-    fn opaque_regions(&self, scale: Scale<f64>) -> Vec<Rectangle<i32, Physical>> {
+    fn opaque_regions(&self, scale: Scale<f64>) -> OpaqueRegions<i32, Physical> {
         self.0.opaque_regions(scale)
     }
 

src/render_helpers/render_elements.rs

@@ -75,7 +75,7 @@ macro_rules! niri_render_elements {
                 }
             }
 
-            fn opaque_regions(&self, scale: smithay::utils::Scale<f64>) -> Vec<smithay::utils::Rectangle<i32, smithay::utils::Physical>> {
+            fn opaque_regions(&self, scale: smithay::utils::Scale<f64>) -> smithay::backend::renderer::utils::OpaqueRegions<i32, smithay::utils::Physical> {
                 match self {
                     $($name::$variant(elem) => elem.opaque_regions(scale)),+
                 }

src/render_helpers/resize.rs

@@ -4,7 +4,7 @@ use glam::{Mat3, Vec2};
 use niri_config::CornerRadius;
 use smithay::backend::renderer::element::{Element, Id, Kind, RenderElement, UnderlyingStorage};
 use smithay::backend::renderer::gles::{GlesError, GlesFrame, GlesRenderer, GlesTexture, Uniform};
-use smithay::backend::renderer::utils::{CommitCounter, DamageSet};
+use smithay::backend::renderer::utils::{CommitCounter, DamageSet, OpaqueRegions};
 use smithay::utils::{Buffer, Logical, Physical, Rectangle, Scale, Size, Transform};
 
 use super::renderer::{AsGlesFrame, NiriRenderer};
@@ -146,7 +146,7 @@ impl Element for ResizeRenderElement {
         self.0.damage_since(scale, commit)
     }
 
-    fn opaque_regions(&self, scale: Scale<f64>) -> Vec<Rectangle<i32, Physical>> {
+    fn opaque_regions(&self, scale: Scale<f64>) -> OpaqueRegions<i32, Physical> {
         self.0.opaque_regions(scale)
     }
 

src/render_helpers/shader_element.rs

@@ -8,7 +8,7 @@ use smithay::backend::renderer::gles::{
     ffi, link_program, Capability, GlesError, GlesFrame, GlesRenderer, GlesTexture, Uniform,
     UniformDesc, UniformName,
 };
-use smithay::backend::renderer::utils::CommitCounter;
+use smithay::backend::renderer::utils::{CommitCounter, OpaqueRegions};
 use smithay::backend::renderer::DebugFlags;
 use smithay::utils::{Buffer, Logical, Physical, Point, Rectangle, Scale, Size};
 
@@ -274,7 +274,7 @@ impl Element for ShaderRenderElement {
         self.area.to_physical_precise_round(scale)
     }
 
-    fn opaque_regions(&self, scale: Scale<f64>) -> Vec<Rectangle<i32, Physical>> {
+    fn opaque_regions(&self, scale: Scale<f64>) -> OpaqueRegions<i32, Physical> {
         self.opaque_regions
             .iter()
             .map(|region| region.to_physical_precise_round(scale))