eframe::App::post_rendering (#1591)

Cargo.lock

@@ -3151,6 +3151,15 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
 
+[[package]]
+name = "screenshot"
+version = "0.1.0"
+dependencies = [
+ "eframe",
+ "egui_extras",
+ "itertools",
+]
+
 [[package]]
 name = "sct"
 version = "0.7.0"

Cargo.toml

@@ -23,6 +23,7 @@ members = [
     "examples/hello_world",
     "examples/puffin_profiler",
     "examples/retained_image",
+    "examples/screenshot",
     "examples/svg",
 ]
 

eframe/src/epi.rs

@@ -141,6 +141,11 @@ pub trait App {
     fn warm_up_enabled(&self) -> bool {
         false
     }
+
+    /// Called each time after the rendering the UI.
+    ///
+    /// Can be used to access pixel data with `get_pixels`
+    fn post_rendering(&mut self, _window_size_px: [u32; 2], _frame: &Frame) {}
 }
 
 /// Options controlling the behavior of a native window.

eframe/src/native/epi_integration.rs

@@ -299,6 +299,13 @@ impl EpiIntegration {
         full_output
     }
 
+    pub fn post_rendering(&mut self, app: &mut dyn epi::App, window: &winit::window::Window) {
+        let inner_size = window.inner_size();
+        let window_size_px = [inner_size.width, inner_size.height];
+
+        app.post_rendering(window_size_px, &self.frame);
+    }
+
     pub fn handle_platform_output(
         &mut self,
         window: &winit::window::Window,

eframe/src/native/run.rs

@@ -126,6 +126,8 @@ pub fn run_glow(
                 &textures_delta,
             );
 
+            integration.post_rendering(app.as_mut(), window);
+
             {
                 crate::profile_scope!("swap_buffers");
                 gl_window.swap_buffers().unwrap();

examples/screenshot/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "screenshot"
+version = "0.1.0"
+authors = ["René Rössler <rene@freshx.de>"]
+license = "MIT OR Apache-2.0"
+edition = "2021"
+rust-version = "1.60"
+publish = false
+
+
+[dependencies]
+eframe = { path = "../../eframe" }
+egui_extras = { path = "../../egui_extras", features = ["image"] }
+itertools = "0.10.3"

examples/screenshot/README.md

@@ -0,0 +1,3 @@
+```sh
+cargo run -p screenshot
+```

examples/screenshot/src/main.rs

@@ -0,0 +1,102 @@
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
+
+use eframe::{
+    egui::{self, ColorImage},
+    glow::{self, HasContext},
+};
+use itertools::Itertools;
+
+fn main() {
+    let options = eframe::NativeOptions::default();
+    eframe::run_native(
+        "Take screenshots and display with eframe/egui",
+        options,
+        Box::new(|_cc| Box::new(MyApp::default())),
+    );
+}
+
+#[derive(Default)]
+struct MyApp {
+    continuously_take_screenshots: bool,
+    take_screenshot: bool,
+    texture: Option<egui::TextureHandle>,
+    screenshot: Option<ColorImage>,
+}
+
+impl eframe::App for MyApp {
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        egui::CentralPanel::default().show(ctx, |ui| {
+            if let Some(screenshot) = self.screenshot.take() {
+                self.texture = Some(ui.ctx().load_texture("screenshot", screenshot));
+            }
+
+            ui.horizontal(|ui| {
+                ui.checkbox(
+                    &mut self.continuously_take_screenshots,
+                    "continuously take screenshots",
+                );
+
+                ui.with_layout(egui::Layout::top_down(egui::Align::RIGHT), |ui| {
+                    if self.continuously_take_screenshots {
+                        if ui
+                            .add(egui::Label::new("hover me!").sense(egui::Sense::hover()))
+                            .hovered()
+                        {
+                            ctx.set_visuals(egui::Visuals::dark());
+                        } else {
+                            ctx.set_visuals(egui::Visuals::light());
+                        };
+                    } else if ui.button("take screenshot!").clicked() {
+                        self.take_screenshot = true;
+                    }
+                });
+            });
+
+            if let Some(texture) = self.texture.as_ref() {
+                ui.image(texture, ui.available_size());
+            } else {
+                ui.spinner();
+            }
+
+            ctx.request_repaint();
+        });
+    }
+
+    #[allow(unsafe_code)]
+    fn post_rendering(&mut self, screen_size_px: [u32; 2], frame: &eframe::Frame) {
+        if !self.take_screenshot && !self.continuously_take_screenshots {
+            return;
+        }
+
+        self.take_screenshot = false;
+        if let Some(gl) = frame.gl() {
+            let mut buf = vec![0u8; screen_size_px[0] as usize * screen_size_px[1] as usize * 4];
+            let pixels = glow::PixelPackData::Slice(&mut buf[..]);
+            unsafe {
+                gl.read_pixels(
+                    0,
+                    0,
+                    screen_size_px[0] as i32,
+                    screen_size_px[1] as i32,
+                    glow::RGBA,
+                    glow::UNSIGNED_BYTE,
+                    pixels,
+                );
+            }
+
+            let mut rows: Vec<Vec<u8>> = buf
+                .into_iter()
+                .chunks(screen_size_px[0] as usize * 4)
+                .into_iter()
+                .map(|chunk| chunk.collect())
+                .collect();
+            rows.reverse();
+            let buf: Vec<u8> = rows.into_iter().flatten().collect();
+
+            self.screenshot = Some(ColorImage::from_rgba_unmultiplied(
+                [screen_size_px[0] as usize, screen_size_px[1] as usize],
+                &buf[..],
+            ));
+        }
+    }
+}