Add render_to_encompassing_texture()

2 files changed, 28 insertions, 19 deletions

diff --git a/src/layout/closing_window.rs b/src/layout/closing_window.rs
index f863a5d3..47e039aa 100644
--- a/src/layout/closing_window.rs
+++ b/src/layout/closing_window.rs
@@ -14,7 +14,7 @@ use smithay::utils::{Logical, Point, Scale, Transform};
 use crate::animation::Animation;
 use crate::niri_render_elements;
 use crate::render_helpers::primary_gpu_texture::PrimaryGpuTextureRenderElement;
-use crate::render_helpers::{render_to_texture, RenderSnapshot, RenderTarget};
+use crate::render_helpers::{render_to_encompassing_texture, RenderSnapshot, RenderTarget};
 
 #[derive(Debug)]
 pub struct ClosingWindow {
@@ -70,33 +70,19 @@ impl ClosingWindow {
         let _span = tracy_client::span!("ClosingWindow::new");
 
         let mut render_to_buffer = |elements: Vec<E>| -> anyhow::Result<_> {
-            let geo = elements
-                .iter()
-                .map(|ele| ele.geometry(Scale::from(f64::from(scale))))
-                .reduce(|a, b| a.merge(b))
-                .unwrap_or_default();
-
-            let elements = elements.iter().rev().map(|ele| {
-                RelocateRenderElement::from_element(
-                    ele,
-                    (-geo.loc.x, -geo.loc.y),
-                    Relocate::Relative,
-                )
-            });
-            let offset = geo.loc.to_logical(scale);
-
-            let (texture, _sync_point) = render_to_texture(
+            let (texture, _sync_point, geo) = render_to_encompassing_texture(
                 renderer,
-                geo.size,
                 Scale::from(scale as f64),
                 Transform::Normal,
                 Fourcc::Abgr8888,
-                elements,
+                &elements,
             )
             .context("error rendering to texture")?;
 
             let buffer =
                 TextureBuffer::from_texture(renderer, texture, scale, Transform::Normal, None);
+            let offset = geo.loc.to_logical(scale);
+
             Ok((buffer, offset))
         };
 
diff --git a/src/render_helpers/mod.rs b/src/render_helpers/mod.rs
index e780de4e..c445240d 100644
--- a/src/render_helpers/mod.rs
+++ b/src/render_helpers/mod.rs
@@ -5,6 +5,7 @@ use niri_config::BlockOutFrom;
 use smithay::backend::allocator::Fourcc;
 use smithay::backend::renderer::element::solid::{SolidColorBuffer, SolidColorRenderElement};
 use smithay::backend::renderer::element::texture::{TextureBuffer, TextureRenderElement};
+use smithay::backend::renderer::element::utils::{Relocate, RelocateRenderElement};
 use smithay::backend::renderer::element::{Kind, RenderElement};
 use smithay::backend::renderer::gles::{GlesMapping, GlesRenderer, GlesTexture};
 use smithay::backend::renderer::sync::SyncPoint;
@@ -124,6 +125,28 @@ impl<C, B> Default for RenderSnapshot<C, B> {
     }
 }
 
+pub fn render_to_encompassing_texture(
+    renderer: &mut GlesRenderer,
+    scale: Scale<f64>,
+    transform: Transform,
+    fourcc: Fourcc,
+    elements: &[impl RenderElement<GlesRenderer>],
+) -> anyhow::Result<(GlesTexture, SyncPoint, Rectangle<i32, Physical>)> {
+    let geo = elements
+        .iter()
+        .map(|ele| ele.geometry(scale))
+        .reduce(|a, b| a.merge(b))
+        .unwrap_or_default();
+    let elements = elements.iter().rev().map(|ele| {
+        RelocateRenderElement::from_element(ele, (-geo.loc.x, -geo.loc.y), Relocate::Relative)
+    });
+
+    let (texture, sync_point) =
+        render_to_texture(renderer, geo.size, scale, transform, fourcc, elements)?;
+
+    Ok((texture, sync_point, geo))
+}
+
 pub fn render_to_texture(
     renderer: &mut GlesRenderer,
     size: Size<i32, Physical>,