Remove old rendering in favor of push rendering

Author: YaLTeR

niri-visual-tests/src/cases/gradient_area.rs

@@ -89,11 +89,8 @@ impl TestCase for GradientArea {
             1.,
             1.,
         );
-        rv.extend(
-            self.border
-                .render(renderer, g_loc)
-                .map(|elem| Box::new(elem) as _),
-        );
+        self.border
+            .render(renderer, g_loc, &mut |elem| rv.push(Box::new(elem) as _));
 
         rv.extend(
             [BorderRenderElement::new(

niri-visual-tests/src/cases/layout.rs

@@ -268,12 +268,14 @@ impl TestCase for Layout {
         _size: Size<i32, Physical>,
     ) -> Vec<Box<dyn RenderElement<GlesRenderer>>> {
         self.layout.update_render_elements(Some(&self.output));
+
+        let mut rv = Vec::new();
         self.layout
             .monitor_for_output(&self.output)
             .unwrap()
-            .render_elements(renderer, RenderTarget::Output, true)
-            .flat_map(|(_, _, iter)| iter)
-            .map(|elem| Box::new(elem) as _)
-            .collect()
+            .render_workspaces(renderer, RenderTarget::Output, true, &mut |elem| {
+                rv.push(Box::new(elem) as _)
+            });
+        rv
     }
 }

niri-visual-tests/src/cases/tile.rs

@@ -119,9 +119,15 @@ impl TestCase for Tile {
             true,
             Rectangle::new(Point::from((-location.x, -location.y)), size.to_logical(1.)),
         );
-        self.tile
-            .render(renderer, location, true, RenderTarget::Output)
-            .map(|elem| Box::new(elem) as _)
-            .collect()
+
+        let mut rv = Vec::new();
+        self.tile.render(
+            renderer,
+            location,
+            true,
+            RenderTarget::Output,
+            &mut |elem| rv.push(Box::new(elem) as _),
+        );
+        rv
     }
 }

niri-visual-tests/src/cases/window.rs

@@ -52,16 +52,15 @@ impl TestCase for Window {
             .to_f64()
             .downscale(2.);
 
-        self.window
-            .render(
-                renderer,
-                location,
-                Scale::from(1.),
-                1.,
-                RenderTarget::Output,
-            )
-            .into_iter()
-            .map(|elem| Box::new(elem) as _)
-            .collect()
+        let mut rv = Vec::new();
+        self.window.render_normal(
+            renderer,
+            location,
+            Scale::from(1.),
+            1.,
+            RenderTarget::Output,
+            &mut |elem| rv.push(Box::new(elem) as _),
+        );
+        rv
     }
 }

niri-visual-tests/src/test_window.rs

@@ -9,7 +9,7 @@ use niri::layout::{
 use niri::render_helpers::offscreen::OffscreenData;
 use niri::render_helpers::renderer::NiriRenderer;
 use niri::render_helpers::solid_color::{SolidColorBuffer, SolidColorRenderElement};
-use niri::render_helpers::{RenderTarget, SplitElements};
+use niri::render_helpers::RenderTarget;
 use niri::utils::transaction::Transaction;
 use niri::window::ResolvedWindowRules;
 use smithay::backend::renderer::element::Kind;
@@ -149,36 +149,30 @@ impl LayoutElement for TestWindow {
         false
     }
 
-    fn render<R: NiriRenderer>(
+    fn render_normal<R: NiriRenderer>(
         &self,
         _renderer: &mut R,
         location: Point<f64, Logical>,
         _scale: Scale<f64>,
         alpha: f32,
         _target: RenderTarget,
-    ) -> SplitElements<LayoutElementRenderElement<R>> {
+        push: &mut dyn FnMut(LayoutElementRenderElement<R>),
+    ) {
         let inner = self.inner.borrow();
 
-        SplitElements {
-            normal: vec![
-                SolidColorRenderElement::from_buffer(
-                    &inner.buffer,
-                    location,
-                    alpha,
-                    Kind::Unspecified,
-                )
-                .into(),
-                SolidColorRenderElement::from_buffer(
-                    &inner.csd_shadow_buffer,
-                    location
-                        - Point::from((inner.csd_shadow_width, inner.csd_shadow_width)).to_f64(),
-                    alpha,
-                    Kind::Unspecified,
-                )
+        push(
+            SolidColorRenderElement::from_buffer(&inner.buffer, location, alpha, Kind::Unspecified)
                 .into(),
-            ],
-            popups: vec![],
-        }
+        );
+        push(
+            SolidColorRenderElement::from_buffer(
+                &inner.csd_shadow_buffer,
+                location - Point::from((inner.csd_shadow_width, inner.csd_shadow_width)).to_f64(),
+                alpha,
+                Kind::Unspecified,
+            )
+            .into(),
+        );
     }
 
     fn request_size(

src/input/mod.rs

@@ -2,7 +2,7 @@ use std::any::Any;
 use std::cmp::min;
 use std::collections::hash_map::Entry;
 use std::collections::HashSet;
-use std::time::{Duration, Instant};
+use std::time::Duration;
 
 use calloop::timer::{TimeoutAction, Timer};
 use input::event::gesture::GestureEventCoordinates as _;
@@ -1636,56 +1636,6 @@ impl State {
                 self.niri.layout.center_visible_columns();
                 // FIXME: granular
                 self.niri.queue_redraw_all();
-
-                let output = self.niri.layout.active_output().unwrap();
-                let output = output.clone();
-                self.niri.update_render_elements(Some(&output));
-
-                self.backend.with_primary_renderer(|renderer| {
-                    // let mon = self.niri.layout.monitor_for_output(output).unwrap();
-
-                    let N = 5000;
-                    let mut total = 0;
-                    let mut total_len = 0;
-                    let start = Instant::now();
-                    for _ in 0..N {
-                        let _span = tracy_client::span!("prev render");
-                        let elements = self.niri.render_prev(
-                            renderer,
-                            &output,
-                            true,
-                            crate::render_helpers::RenderTarget::Output,
-                        );
-                        total += elements.capacity();
-                        total_len += elements.len();
-                    }
-                    let elapsed = start.elapsed();
-                    warn!(
-                        "prev capacity: {total}, len: {total_len}, mean time: {:.3} ms",
-                        elapsed.as_secs_f64() / N as f64 * 1000.
-                    );
-
-                    total = 0;
-                    total_len = 0;
-                    let start = Instant::now();
-                    for _ in 0..N {
-                        let _span = tracy_client::span!("new render");
-                        let elements = self.niri.render(
-                            renderer,
-                            &output,
-                            true,
-                            crate::render_helpers::RenderTarget::Output,
-                        );
-                        total += elements.capacity();
-                        total_len += elements.len();
-                    }
-                    let elapsed = start.elapsed();
-
-                    warn!(
-                        " new capacity: {total}, len: {total_len}, mean time: {:.3} ms",
-                        elapsed.as_secs_f64() / N as f64 * 1000.
-                    );
-                });
             }
             Action::MaximizeColumn => {
                 self.niri.layout.toggle_full_width();

src/layer/mapped.rs

@@ -1,8 +1,6 @@
 use niri_config::utils::MergeWith as _;
 use niri_config::{Config, LayerRule};
-use smithay::backend::renderer::element::surface::{
-    render_elements_from_surface_tree, WaylandSurfaceRenderElement,
-};
+use smithay::backend::renderer::element::surface::WaylandSurfaceRenderElement;
 use smithay::backend::renderer::element::Kind;
 use smithay::desktop::{LayerSurface, PopupManager};
 use smithay::utils::{Logical, Point, Scale, Size};
@@ -16,7 +14,7 @@ use crate::render_helpers::renderer::NiriRenderer;
 use crate::render_helpers::shadow::ShadowRenderElement;
 use crate::render_helpers::solid_color::{SolidColorBuffer, SolidColorRenderElement};
 use crate::render_helpers::surface::push_elements_from_surface_tree;
-use crate::render_helpers::{RenderTarget, SplitElements};
+use crate::render_helpers::RenderTarget;
 use crate::utils::{baba_is_float_offset, round_logical_in_physical};
 
 #[derive(Debug)]
@@ -157,67 +155,7 @@ impl MappedLayer {
         Point::from((0., y))
     }
 
-    pub fn render<R: NiriRenderer>(
-        &self,
-        renderer: &mut R,
-        location: Point<f64, Logical>,
-        target: RenderTarget,
-    ) -> SplitElements<LayerSurfaceRenderElement<R>> {
-        let mut rv = SplitElements::default();
-
-        let scale = Scale::from(self.scale);
-        let alpha = self.rules.opacity.unwrap_or(1.).clamp(0., 1.);
-        let location = location + self.bob_offset();
-
-        if target.should_block_out(self.rules.block_out_from) {
-            // Round to physical pixels.
-            let location = location.to_physical_precise_round(scale).to_logical(scale);
-
-            // FIXME: take geometry-corner-radius into account.
-            let elem = SolidColorRenderElement::from_buffer(
-                &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 = location;
-
-            let surface = self.surface.wl_surface();
-            for (popup, popup_offset) in PopupManager::popups_for_surface(surface) {
-                // Layer surfaces don't have extra geometry like windows.
-                let offset = popup_offset - popup.geometry().loc;
-
-                rv.popups.extend(render_elements_from_surface_tree(
-                    renderer,
-                    popup.wl_surface(),
-                    (buf_pos + offset.to_f64()).to_physical_precise_round(scale),
-                    scale,
-                    alpha,
-                    Kind::ScanoutCandidate,
-                ));
-            }
-
-            rv.normal = render_elements_from_surface_tree(
-                renderer,
-                surface,
-                buf_pos.to_physical_precise_round(scale),
-                scale,
-                alpha,
-                Kind::ScanoutCandidate,
-            );
-        }
-
-        let location = location.to_physical_precise_round(scale).to_logical(scale);
-        rv.normal
-            .extend(self.shadow.render(renderer, location).map(Into::into));
-
-        rv
-    }
-
-    pub fn render_push_normal<R: NiriRenderer>(
+    pub fn render_normal<R: NiriRenderer>(
         &self,
         renderer: &mut R,
         location: Point<f64, Logical>,
@@ -258,10 +196,10 @@ impl MappedLayer {
 
         let location = location.to_physical_precise_round(scale).to_logical(scale);
         self.shadow
-            .render_push(renderer, location, &mut |elem| push(elem.into()));
+            .render(renderer, location, &mut |elem| push(elem.into()));
     }
 
-    pub fn render_push_popups<R: NiriRenderer>(
+    pub fn render_popups<R: NiriRenderer>(
         &self,
         renderer: &mut R,
         location: Point<f64, Logical>,

src/layout/floating.rs

@@ -1053,40 +1053,7 @@ impl<W: LayoutElement> FloatingSpace<W> {
         true
     }
 
-    pub fn render_elements<R: NiriRenderer>(
-        &self,
-        renderer: &mut R,
-        view_rect: Rectangle<f64, Logical>,
-        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.
-        for closing in self.closing_windows.iter().rev() {
-            let elem = closing.render(renderer.as_gles_renderer(), view_rect, scale, target);
-            rv.push(elem.into());
-        }
-
-        let active = self.active_window_id.clone();
-        for (tile, tile_pos) in self.tiles_with_render_positions() {
-            // For the active tile, draw the focus ring.
-            let focus_ring = focus_ring && Some(tile.window().id()) == active.as_ref();
-
-            rv.extend(
-                tile.render(renderer, tile_pos, focus_ring, target)
-                    .map(Into::into),
-            );
-        }
-
-        rv
-    }
-
-    pub fn render_push<R: NiriRenderer>(
+    pub fn render<R: NiriRenderer>(
         &self,
         renderer: &mut R,
         view_rect: Rectangle<f64, Logical>,
@@ -1109,7 +1076,7 @@ impl<W: LayoutElement> FloatingSpace<W> {
             // For the active tile, draw the focus ring.
             let focus_ring = focus_ring && Some(tile.window().id()) == active.as_ref();
 
-            tile.render_push(renderer, tile_pos, focus_ring, target, &mut |elem| {
+            tile.render(renderer, tile_pos, focus_ring, target, &mut |elem| {
                 push(elem.into())
             });
         }