andrei/niri
1
0
Fork 0
mirror of https://github.com/niri-wm/niri.git synced 2026-06-21 02:01:55 +07:00
Code Issues Packages Projects Releases 10 Wiki Activity

layout: Don't pass scale to render unnecessarily

Browse Source 
These parts of the layout already know their scale.
This commit is contained in:
Ivan Molodetskikh
2025-04-15 09:10:50 +03:00
parent 15ba2ab300
commit 7e253d2687
6 changed files with 29 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files
niri-visual-tests/src/cases/tile.rs
+2 -8
View File
@@ -6,7 +6,7 @@ use niri::render_helpers::RenderTarget;
use niri_config::{Color, FloatOrInt};
use smithay::backend::renderer::element::RenderElement;
use smithay::backend::renderer::gles::GlesRenderer;
use smithay::utils::{Physical, Point, Rectangle, Scale, Size};
use smithay::utils::{Physical, Point, Rectangle, Size};
use super::{Args, TestCase};
use crate::test_window::TestWindow;
@@ -117,13 +117,7 @@ impl TestCase for Tile {
Rectangle::new(Point::from((-location.x, -location.y)), size.to_logical(1.)),
);
self.tile
.render(
renderer,
location,
Scale::from(1.),
true,
RenderTarget::Output,
)
.render(renderer, location, true, RenderTarget::Output)
.map(|elem| Box::new(elem) as _)
.collect()
}
src/layout/floating.rs
+3 -2
View File
@@ -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),
);
}
src/layout/mod.rs
+2 -4
View File
@@ -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));
}
}
src/layout/scrolling.rs
+3 -2
View File
@@ -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),
);
}
src/layout/tile.rs
+11 -26
View File
@@ -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,
);
src/layout/workspace.rs
+8 -14
View File
@@ -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;
}
}