eframe::App::post_rendering

Cargo.toml

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

eframe/src/epi.rs

@@ -136,6 +136,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, _screen_size_px: [u32; 2], _frame: &Frame) {}
 }
 
 /// Options controlling the behavior of a native window.

eframe/src/native/epi_integration.rs

@@ -264,6 +264,14 @@ impl EpiIntegration {
         full_output
     }
 
+    pub fn post_rendering(&mut self, app: &mut dyn epi::App) {
+        let pixels_per_point = self.frame.info().native_pixels_per_point.unwrap_or(1.0);
+        let screen_size = self.egui_ctx.input().screen_rect.size() * pixels_per_point;
+        let screen_size_px = [screen_size.x as u32, screen_size.y as u32];
+
+        app.post_rendering(screen_size_px, &self.frame);
+    }
+
     pub fn handle_platform_output(
         &mut self,
         window: &winit::window::Window,

eframe/src/native/run.rs

@@ -120,6 +120,8 @@ pub fn run_glow(
                 &textures_delta,
             );
 
+            integration.post_rendering(app.as_mut());
+
             {
                 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 <[email protected]>"]
+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,81 @@
+#![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 {
+    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));
+            }
+
+            if ui
+                .add(egui::Label::new("Screenshot (hover me!):").sense(egui::Sense::hover()))
+                .hovered()
+            {
+                ctx.set_visuals(egui::Visuals::dark());
+            } else {
+                ctx.set_visuals(egui::Visuals::light());
+            };
+            if let Some(texture) = self.texture.as_ref() {
+                ui.image(texture, texture.size_vec2());
+            } else {
+                ui.spinner();
+            }
+
+            ctx.request_repaint();
+        });
+    }
+
+    #[allow(unsafe_code)]
+    fn post_rendering(&mut self, screen_size_px: [u32; 2], frame: &eframe::Frame) {
+        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[..],
+            ));
+        }
+    }
+}