layout: Don't pass scale to render unnecessarily

These parts of the layout already know their scale.

5 files changed, 27 insertions, 48 deletions

diff --git a/src/layout/floating.rs b/src/layout/floating.rs
index a88e5bf4..7d7e7fc0 100644
--- a/src/layout/floating.rs
+++ b/src/layout/floating.rs
@@ -985,12 +985,13 @@ impl<W: LayoutElement> FloatingSpace<W> {
         &self,
         renderer: &mut R,
         view_rect: Rectangle<f64, Logical>,
-        scale: Scale<f64>,
         target: RenderTarget,
         focus_ring: bool,
     ) -> Vec<FloatingSpaceRenderElement<R>> {
         let mut rv = Vec::new();
 
+        let scale = Scale::from(self.scale);
+
         // Draw the closing windows on top of the other windows.
         //
         // FIXME: I guess this should rather preserve the stacking order when the window is closed.
@@ -1005,7 +1006,7 @@ impl<W: LayoutElement> FloatingSpace<W> {
             let focus_ring = focus_ring && Some(tile.window().id()) == active.as_ref();
 
             rv.extend(
-                tile.render(renderer, tile_pos, scale, focus_ring, target)
+                tile.render(renderer, tile_pos, focus_ring, target)
                     .map(Into::into),
             );
         }
diff --git a/src/layout/mod.rs b/src/layout/mod.rs
index 933c2a7b..f5d1de7b 100644
--- a/src/layout/mod.rs
+++ b/src/layout/mod.rs
@@ -4359,8 +4359,7 @@ impl<W: LayoutElement> Layout<W> {
 
         if let Some(InteractiveMoveState::Moving(move_)) = &mut self.interactive_move {
             if move_.tile.window().id() == window {
-                let scale = Scale::from(move_.output.current_scale().fractional_scale());
-                move_.tile.store_unmap_snapshot_if_empty(renderer, scale);
+                move_.tile.store_unmap_snapshot_if_empty(renderer);
                 return;
             }
         }
@@ -4490,9 +4489,8 @@ impl<W: LayoutElement> Layout<W> {
 
         if let Some(InteractiveMoveState::Moving(move_)) = &self.interactive_move {
             if &move_.output == output {
-                let scale = Scale::from(move_.output.current_scale().fractional_scale());
                 let location = move_.tile_render_location();
-                rv = Some(move_.tile.render(renderer, location, scale, true, target));
+                rv = Some(move_.tile.render(renderer, location, true, target));
             }
         }
 
diff --git a/src/layout/scrolling.rs b/src/layout/scrolling.rs
index 657c4162..931399dd 100644
--- a/src/layout/scrolling.rs
+++ b/src/layout/scrolling.rs
@@ -2724,12 +2724,13 @@ impl<W: LayoutElement> ScrollingSpace<W> {
     pub fn render_elements<R: NiriRenderer>(
         &self,
         renderer: &mut R,
-        scale: Scale<f64>,
         target: RenderTarget,
         focus_ring: bool,
     ) -> Vec<ScrollingSpaceRenderElement<R>> {
         let mut rv = vec![];
 
+        let scale = Scale::from(self.scale);
+
         // Draw the insert hint.
         if let Some(insert_hint) = &self.insert_hint {
             if let Some(area) = self.insert_hint_area(insert_hint) {
@@ -2790,7 +2791,7 @@ impl<W: LayoutElement> ScrollingSpace<W> {
                 }
 
                 rv.extend(
-                    tile.render(renderer, tile_pos, scale, focus_ring, target)
+                    tile.render(renderer, tile_pos, focus_ring, target)
                         .map(Into::into),
                 );
             }
diff --git a/src/layout/tile.rs b/src/layout/tile.rs
index 891ac3f6..1b423c07 100644
--- a/src/layout/tile.rs
+++ b/src/layout/tile.rs
@@ -820,12 +820,13 @@ impl<W: LayoutElement> Tile<W> {
         &'a self,
         renderer: &mut R,
         location: Point<f64, Logical>,
-        scale: Scale<f64>,
         focus_ring: bool,
         target: RenderTarget,
     ) -> impl Iterator<Item = TileRenderElement<R>> + 'a {
         let _span = tracy_client::span!("Tile::render_inner");
 
+        let scale = Scale::from(self.scale);
+
         let win_alpha = if self.is_fullscreen || self.window.is_ignoring_opacity_window_rule() {
             1.
         } else {
@@ -1051,12 +1052,13 @@ impl<W: LayoutElement> Tile<W> {
         &'a self,
         renderer: &mut R,
         location: Point<f64, Logical>,
-        scale: Scale<f64>,
         focus_ring: bool,
         target: RenderTarget,
     ) -> impl Iterator<Item = TileRenderElement<R>> + 'a {
         let _span = tracy_client::span!("Tile::render");
 
+        let scale = Scale::from(self.scale);
+
         let tile_alpha = self
             .alpha_animation
             .as_ref()
@@ -1070,8 +1072,7 @@ impl<W: LayoutElement> Tile<W> {
 
         if let Some(open) = &self.open_animation {
             let renderer = renderer.as_gles_renderer();
-            let elements =
-                self.render_inner(renderer, Point::from((0., 0.)), scale, focus_ring, target);
+            let elements = self.render_inner(renderer, Point::from((0., 0.)), focus_ring, target);
             let elements = elements.collect::<Vec<TileRenderElement<_>>>();
             match open.render(
                 renderer,
@@ -1091,8 +1092,7 @@ impl<W: LayoutElement> Tile<W> {
             }
         } else if let Some(alpha) = &self.alpha_animation {
             let renderer = renderer.as_gles_renderer();
-            let elements =
-                self.render_inner(renderer, Point::from((0., 0.)), scale, focus_ring, target);
+            let elements = self.render_inner(renderer, Point::from((0., 0.)), focus_ring, target);
             let elements = elements.collect::<Vec<TileRenderElement<_>>>();
             match alpha.offscreen.render(renderer, scale, &elements) {
                 Ok((elem, _sync, data)) => {
@@ -1109,7 +1109,7 @@ impl<W: LayoutElement> Tile<W> {
         }
 
         if open_anim_elem.is_none() && alpha_anim_elem.is_none() {
-            window_elems = Some(self.render_inner(renderer, location, scale, focus_ring, target));
+            window_elems = Some(self.render_inner(renderer, location, focus_ring, target));
         }
 
         open_anim_elem
@@ -1118,38 +1118,23 @@ impl<W: LayoutElement> Tile<W> {
             .chain(window_elems.into_iter().flatten())
     }
 
-    pub fn store_unmap_snapshot_if_empty(
-        &mut self,
-        renderer: &mut GlesRenderer,
-        scale: Scale<f64>,
-    ) {
+    pub fn store_unmap_snapshot_if_empty(&mut self, renderer: &mut GlesRenderer) {
         if self.unmap_snapshot.is_some() {
             return;
         }
 
-        self.unmap_snapshot = Some(self.render_snapshot(renderer, scale));
+        self.unmap_snapshot = Some(self.render_snapshot(renderer));
     }
 
-    fn render_snapshot(
-        &self,
-        renderer: &mut GlesRenderer,
-        scale: Scale<f64>,
-    ) -> TileRenderSnapshot {
+    fn render_snapshot(&self, renderer: &mut GlesRenderer) -> TileRenderSnapshot {
         let _span = tracy_client::span!("Tile::render_snapshot");
 
-        let contents = self.render(
-            renderer,
-            Point::from((0., 0.)),
-            scale,
-            false,
-            RenderTarget::Output,
-        );
+        let contents = self.render(renderer, Point::from((0., 0.)), false, RenderTarget::Output);
 
         // A bit of a hack to render blocked out as for screencast, but I think it's fine here.
         let blocked_out_contents = self.render(
             renderer,
             Point::from((0., 0.)),
-            scale,
             false,
             RenderTarget::Screencast,
         );
diff --git a/src/layout/workspace.rs b/src/layout/workspace.rs
index 873af715..33e594fe 100644
--- a/src/layout/workspace.rs
+++ b/src/layout/workspace.rs
@@ -9,7 +9,7 @@ use smithay::desktop::{layer_map_for_output, Window};
 use smithay::output::Output;
 use smithay::reexports::wayland_protocols::xdg::shell::server::xdg_toplevel;
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
-use smithay::utils::{Logical, Point, Rectangle, Scale, Serial, Size, Transform};
+use smithay::utils::{Logical, Point, Rectangle, Serial, Size, Transform};
 use smithay::wayland::compositor::with_states;
 use smithay::wayland::shell::xdg::SurfaceCachedState;
 
@@ -1410,23 +1410,18 @@ impl<W: LayoutElement> Workspace<W> {
         target: RenderTarget,
         focus_ring: bool,
     ) -> impl Iterator<Item = WorkspaceRenderElement<R>> {
-        let scale = Scale::from(self.scale.fractional_scale());
         let scrolling_focus_ring = focus_ring && !self.floating_is_active();
-        let scrolling =
-            self.scrolling
-                .render_elements(renderer, scale, target, scrolling_focus_ring);
+        let scrolling = self
+            .scrolling
+            .render_elements(renderer, target, scrolling_focus_ring);
         let scrolling = scrolling.into_iter().map(WorkspaceRenderElement::from);
 
         let floating_focus_ring = focus_ring && self.floating_is_active();
         let floating = self.is_floating_visible().then(|| {
             let view_rect = Rectangle::from_size(self.view_size);
-            let floating = self.floating.render_elements(
-                renderer,
-                view_rect,
-                scale,
-                target,
-                floating_focus_ring,
-            );
+            let floating =
+                self.floating
+                    .render_elements(renderer, view_rect, target, floating_focus_ring);
             floating.into_iter().map(WorkspaceRenderElement::from)
         });
 
@@ -1446,14 +1441,13 @@ impl<W: LayoutElement> Workspace<W> {
     }
 
     pub fn store_unmap_snapshot_if_empty(&mut self, renderer: &mut GlesRenderer, window: &W::Id) {
-        let output_scale = Scale::from(self.scale.fractional_scale());
         let view_size = self.view_size();
         for (tile, tile_pos) in self.tiles_with_render_positions_mut(false) {
             if tile.window().id() == window {
                 let view_pos = Point::from((-tile_pos.x, -tile_pos.y));
                 let view_rect = Rectangle::new(view_pos, view_size);
                 tile.update_render_elements(false, view_rect);
-                tile.store_unmap_snapshot_if_empty(renderer, output_scale);
+                tile.store_unmap_snapshot_if_empty(renderer);
                 return;
             }
         }