From 5f23d344d5d20d238eea65cd9e7189a2baf499c8 Mon Sep 17 00:00:00 2001
From: Ivan Molodetskikh <yalterz@gmail.com>
Date: Sun, 24 Mar 2024 11:11:15 +0400
Subject: Make screenshot UI render target-aware

---
 src/niri.rs             | 48 +++++++++++++++++++++++++++---------------------
 src/ui/screenshot_ui.rs | 34 +++++++++++++++++++++-------------
 2 files changed, 48 insertions(+), 34 deletions(-)

(limited to 'src')

diff --git a/src/niri.rs b/src/niri.rs
index 88326119..02169a58 100644
--- a/src/niri.rs
+++ b/src/niri.rs
@@ -2307,7 +2307,7 @@ impl Niri {
         if self.screenshot_ui.is_open() {
             elements.extend(
                 self.screenshot_ui
-                    .render_output(output)
+                    .render_output(output, target)
                     .into_iter()
                     .map(OutputRenderElements::from),
             );
@@ -3104,31 +3104,37 @@ impl Niri {
                 let size = transform.transform_size(size);
 
                 let scale = Scale::from(output.current_scale().fractional_scale());
-                let elements = self.render::<GlesRenderer>(
-                    renderer,
-                    &output,
-                    true,
+                let targets = [
+                    RenderTarget::Output,
+                    RenderTarget::Screencast,
                     RenderTarget::ScreenCapture,
-                );
-                let elements = elements.iter().rev();
+                ];
+                let textures = targets.map(|target| {
+                    let elements = self.render::<GlesRenderer>(renderer, &output, true, target);
+                    let elements = elements.iter().rev();
 
-                let res = render_to_texture(
-                    renderer,
-                    size,
-                    scale,
-                    Transform::Normal,
-                    Fourcc::Abgr8888,
-                    elements,
-                );
-                let screenshot = match res {
-                    Ok((texture, _)) => texture,
-                    Err(err) => {
+                    let res = render_to_texture(
+                        renderer,
+                        size,
+                        scale,
+                        Transform::Normal,
+                        Fourcc::Abgr8888,
+                        elements,
+                    );
+
+                    if let Err(err) = &res {
                         warn!("error rendering output {}: {err:?}", output.name());
-                        return None;
                     }
-                };
 
-                Some((output, screenshot))
+                    res
+                });
+
+                if textures.iter().any(|res| res.is_err()) {
+                    return None;
+                }
+
+                let textures = textures.map(|res| res.unwrap().0);
+                Some((output, textures))
             })
             .collect();
 
diff --git a/src/ui/screenshot_ui.rs b/src/ui/screenshot_ui.rs
index 79245387..5892fde1 100644
--- a/src/ui/screenshot_ui.rs
+++ b/src/ui/screenshot_ui.rs
@@ -19,6 +19,7 @@ use smithay::utils::{Physical, Point, Rectangle, Size, Transform};
 
 use crate::niri_render_elements;
 use crate::render_helpers::primary_gpu_texture::PrimaryGpuTextureRenderElement;
+use crate::render_helpers::RenderTarget;
 
 const BORDER: i32 = 2;
 
@@ -42,8 +43,9 @@ pub struct OutputData {
     size: Size<i32, Physical>,
     scale: i32,
     transform: Transform,
-    texture: GlesTexture,
-    texture_buffer: TextureBuffer<GlesTexture>,
+    // Output, screencast, screen capture.
+    texture: [GlesTexture; 3],
+    texture_buffer: [TextureBuffer<GlesTexture>; 3],
     buffers: [SolidColorBuffer; 8],
     locations: [Point<i32, Physical>; 8],
 }
@@ -65,7 +67,8 @@ impl ScreenshotUi {
     pub fn open(
         &mut self,
         renderer: &GlesRenderer,
-        screenshots: HashMap<Output, GlesTexture>,
+        // Output, screencast, screen capture.
+        screenshots: HashMap<Output, [GlesTexture; 3]>,
         default_output: Output,
     ) -> bool {
         if screenshots.is_empty() {
@@ -110,13 +113,9 @@ impl ScreenshotUi {
                 let output_mode = output.current_mode().unwrap();
                 let size = transform.transform_size(output_mode.size);
                 let scale = output.current_scale().integer_scale();
-                let texture_buffer = TextureBuffer::from_texture(
-                    renderer,
-                    texture.clone(),
-                    scale,
-                    Transform::Normal,
-                    None,
-                );
+                let texture_buffer = texture.clone().map(|texture| {
+                    TextureBuffer::from_texture(renderer, texture, scale, Transform::Normal, None)
+                });
                 let buffers = [
                     SolidColorBuffer::new((0, 0), [1., 1., 1., 1.]),
                     SolidColorBuffer::new((0, 0), [1., 1., 1., 1.]),
@@ -243,7 +242,11 @@ impl ScreenshotUi {
         }
     }
 
-    pub fn render_output(&self, output: &Output) -> ArrayVec<ScreenshotUiRenderElement, 9> {
+    pub fn render_output(
+        &self,
+        output: &Output,
+        target: RenderTarget,
+    ) -> ArrayVec<ScreenshotUiRenderElement, 9> {
         let _span = tracy_client::span!("ScreenshotUi::render_output");
 
         let Self::Open { output_data, .. } = self else {
@@ -269,10 +272,15 @@ impl ScreenshotUi {
         }));
 
         // The screenshot itself goes last.
+        let index = match target {
+            RenderTarget::Output => 0,
+            RenderTarget::Screencast => 1,
+            RenderTarget::ScreenCapture => 2,
+        };
         elements.push(
             PrimaryGpuTextureRenderElement(TextureRenderElement::from_texture_buffer(
                 (0., 0.),
-                &output_data.texture_buffer,
+                &output_data.texture_buffer[index],
                 None,
                 None,
                 None,
@@ -307,7 +315,7 @@ impl ScreenshotUi {
             .to_buffer(1, Transform::Normal, &data.size.to_logical(1));
 
         let mapping = renderer
-            .copy_texture(&data.texture, buf_rect, Fourcc::Abgr8888)
+            .copy_texture(&data.texture[0], buf_rect, Fourcc::Abgr8888)
             .context("error copying texture")?;
         let copy = renderer
             .map_texture(&mapping)
-- 
cgit