Add update_render_elements() to MappedLayer

2 files changed, 29 insertions, 17 deletions

diff --git a/src/layer/mapped.rs b/src/layer/mapped.rs
index a70503d7..dfc09fe3 100644
--- a/src/layer/mapped.rs
+++ b/src/layer/mapped.rs
@@ -1,12 +1,10 @@
-use std::cell::RefCell;
-
 use niri_config::layer_rule::LayerRule;
 use smithay::backend::renderer::element::surface::{
     render_elements_from_surface_tree, WaylandSurfaceRenderElement,
 };
 use smithay::backend::renderer::element::Kind;
 use smithay::desktop::{LayerSurface, PopupManager};
-use smithay::utils::{Logical, Rectangle, Scale};
+use smithay::utils::{Logical, Point, Scale, Size};
 
 use super::ResolvedLayerRules;
 use crate::niri_render_elements;
@@ -23,7 +21,7 @@ pub struct MappedLayer {
     rules: ResolvedLayerRules,
 
     /// Buffer to draw instead of the surface when it should be blocked out.
-    block_out_buffer: RefCell<SolidColorBuffer>,
+    block_out_buffer: SolidColorBuffer,
 }
 
 niri_render_elements! {
@@ -38,10 +36,17 @@ impl MappedLayer {
         Self {
             surface,
             rules,
-            block_out_buffer: RefCell::new(SolidColorBuffer::new((0., 0.), [0., 0., 0., 1.])),
+            block_out_buffer: SolidColorBuffer::new((0., 0.), [0., 0., 0., 1.]),
         }
     }
 
+    pub fn update_render_elements(&mut self, size: Size<f64, Logical>, scale: Scale<f64>) {
+        // Round to physical pixels.
+        let size = size.to_physical_precise_round(scale).to_logical(scale);
+
+        self.block_out_buffer.resize(size);
+    }
+
     pub fn surface(&self) -> &LayerSurface {
         &self.surface
     }
@@ -64,7 +69,7 @@ impl MappedLayer {
     pub fn render<R: NiriRenderer>(
         &self,
         renderer: &mut R,
-        geometry: Rectangle<i32, Logical>,
+        location: Point<f64, Logical>,
         scale: Scale<f64>,
         target: RenderTarget,
     ) -> SplitElements<LayerSurfaceRenderElement<R>> {
@@ -74,23 +79,18 @@ impl MappedLayer {
 
         if target.should_block_out(self.rules.block_out_from) {
             // Round to physical pixels.
-            let geometry = geometry
-                .to_f64()
-                .to_physical_precise_round(scale)
-                .to_logical(scale);
+            let location = location.to_physical_precise_round(scale).to_logical(scale);
 
-            let mut buffer = self.block_out_buffer.borrow_mut();
-            buffer.resize(geometry.size.to_f64());
             let elem = SolidColorRenderElement::from_buffer(
-                &buffer,
-                geometry.loc,
+                &self.block_out_buffer,
+                location,
                 alpha,
                 Kind::Unspecified,
             );
             rv.normal.push(elem.into());
         } else {
             // Layer surfaces don't have extra geometry like windows.
-            let buf_pos = geometry.loc;
+            let buf_pos = location;
 
             let surface = self.surface.wl_surface();
             for (popup, popup_offset) in PopupManager::popups_for_surface(surface) {
@@ -100,7 +100,7 @@ impl MappedLayer {
                 rv.popups.extend(render_elements_from_surface_tree(
                     renderer,
                     popup.wl_surface(),
-                    (buf_pos + offset).to_physical_precise_round(scale),
+                    (buf_pos + offset.to_f64()).to_physical_precise_round(scale),
                     scale,
                     alpha,
                     Kind::Unspecified,
diff --git a/src/niri.rs b/src/niri.rs
index c232ab88..728d0f75 100644
--- a/src/niri.rs
+++ b/src/niri.rs
@@ -3248,6 +3248,18 @@ impl Niri {
                 if let Some(transition) = &mut state.screen_transition {
                     transition.update_render_elements(scale, transform);
                 }
+
+                let layer_map = layer_map_for_output(out);
+                for surface in layer_map.layers() {
+                    let Some(mapped) = self.mapped_layer_surfaces.get_mut(surface) else {
+                        continue;
+                    };
+                    let Some(geo) = layer_map.layer_geometry(surface) else {
+                        continue;
+                    };
+
+                    mapped.update_render_elements(geo.size.to_f64(), scale);
+                }
             }
         }
     }
@@ -3440,7 +3452,7 @@ impl Niri {
             Some((mapped, geo))
         });
         for (mapped, geo) in iter {
-            elements.extend(mapped.render(renderer, geo, scale, target));
+            elements.extend(mapped.render(renderer, geo.loc.to_f64(), scale, target));
         }
     }