Move all crates into a crates directory (#1940)

crates/eframe/src/native/epi_integration.rs

@@ -0,0 +1,377 @@
+use crate::{epi, Theme, WindowInfo};
+use egui_winit::{native_pixels_per_point, WindowSettings};
+use winit::event_loop::EventLoopWindowTarget;
+
+pub fn points_to_size(points: egui::Vec2) -> winit::dpi::LogicalSize<f64> {
+    winit::dpi::LogicalSize {
+        width: points.x as f64,
+        height: points.y as f64,
+    }
+}
+
+pub fn read_window_info(window: &winit::window::Window, pixels_per_point: f32) -> WindowInfo {
+    let position = window
+        .outer_position()
+        .ok()
+        .map(|pos| pos.to_logical::<f32>(pixels_per_point.into()))
+        .map(|pos| egui::Pos2 { x: pos.x, y: pos.y });
+
+    let size = window
+        .inner_size()
+        .to_logical::<f32>(pixels_per_point.into());
+
+    WindowInfo {
+        position,
+        fullscreen: window.fullscreen().is_some(),
+        size: egui::Vec2 {
+            x: size.width,
+            y: size.height,
+        },
+    }
+}
+
+pub fn window_builder(
+    native_options: &epi::NativeOptions,
+    window_settings: &Option<WindowSettings>,
+) -> winit::window::WindowBuilder {
+    let epi::NativeOptions {
+        always_on_top,
+        maximized,
+        decorated,
+        fullscreen,
+        drag_and_drop_support,
+        icon_data,
+        initial_window_pos,
+        initial_window_size,
+        min_window_size,
+        max_window_size,
+        resizable,
+        transparent,
+        ..
+    } = native_options;
+
+    let window_icon = icon_data.clone().and_then(load_icon);
+
+    let mut window_builder = winit::window::WindowBuilder::new()
+        .with_always_on_top(*always_on_top)
+        .with_decorations(*decorated)
+        .with_fullscreen(fullscreen.then(|| winit::window::Fullscreen::Borderless(None)))
+        .with_maximized(*maximized)
+        .with_resizable(*resizable)
+        .with_transparent(*transparent)
+        .with_window_icon(window_icon);
+
+    if let Some(min_size) = *min_window_size {
+        window_builder = window_builder.with_min_inner_size(points_to_size(min_size));
+    }
+    if let Some(max_size) = *max_window_size {
+        window_builder = window_builder.with_max_inner_size(points_to_size(max_size));
+    }
+
+    window_builder = window_builder_drag_and_drop(window_builder, *drag_and_drop_support);
+
+    if let Some(window_settings) = window_settings {
+        window_builder = window_settings.initialize_window(window_builder);
+    } else {
+        if let Some(pos) = *initial_window_pos {
+            window_builder = window_builder.with_position(winit::dpi::PhysicalPosition {
+                x: pos.x as f64,
+                y: pos.y as f64,
+            });
+        }
+        if let Some(initial_window_size) = *initial_window_size {
+            window_builder = window_builder.with_inner_size(points_to_size(initial_window_size));
+        }
+    }
+
+    window_builder
+}
+
+fn load_icon(icon_data: epi::IconData) -> Option<winit::window::Icon> {
+    winit::window::Icon::from_rgba(icon_data.rgba, icon_data.width, icon_data.height).ok()
+}
+
+#[cfg(target_os = "windows")]
+fn window_builder_drag_and_drop(
+    window_builder: winit::window::WindowBuilder,
+    enable: bool,
+) -> winit::window::WindowBuilder {
+    use winit::platform::windows::WindowBuilderExtWindows as _;
+    window_builder.with_drag_and_drop(enable)
+}
+
+#[cfg(not(target_os = "windows"))]
+fn window_builder_drag_and_drop(
+    window_builder: winit::window::WindowBuilder,
+    _enable: bool,
+) -> winit::window::WindowBuilder {
+    // drag and drop can only be disabled on windows
+    window_builder
+}
+
+pub fn handle_app_output(
+    window: &winit::window::Window,
+    current_pixels_per_point: f32,
+    app_output: epi::backend::AppOutput,
+) {
+    let epi::backend::AppOutput {
+        quit: _,
+        window_size,
+        window_title,
+        decorated,
+        fullscreen,
+        drag_window,
+        window_pos,
+        visible,
+    } = app_output;
+
+    if let Some(decorated) = decorated {
+        window.set_decorations(decorated);
+    }
+
+    if let Some(window_size) = window_size {
+        window.set_inner_size(
+            winit::dpi::PhysicalSize {
+                width: (current_pixels_per_point * window_size.x).round(),
+                height: (current_pixels_per_point * window_size.y).round(),
+            }
+            .to_logical::<f32>(native_pixels_per_point(window) as f64),
+        );
+    }
+
+    if let Some(fullscreen) = fullscreen {
+        window.set_fullscreen(fullscreen.then(|| winit::window::Fullscreen::Borderless(None)));
+    }
+
+    if let Some(window_title) = window_title {
+        window.set_title(&window_title);
+    }
+
+    if let Some(window_pos) = window_pos {
+        window.set_outer_position(winit::dpi::PhysicalPosition {
+            x: window_pos.x as f64,
+            y: window_pos.y as f64,
+        });
+    }
+
+    if drag_window {
+        let _ = window.drag_window();
+    }
+
+    if let Some(visible) = visible {
+        window.set_visible(visible);
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// For loading/saving app state and/or egui memory to disk.
+pub fn create_storage(_app_name: &str) -> Option<Box<dyn epi::Storage>> {
+    #[cfg(feature = "persistence")]
+    if let Some(storage) = super::file_storage::FileStorage::from_app_name(_app_name) {
+        return Some(Box::new(storage));
+    }
+    None
+}
+
+// ----------------------------------------------------------------------------
+
+/// Everything needed to make a winit-based integration for [`epi`].
+pub struct EpiIntegration {
+    pub frame: epi::Frame,
+    last_auto_save: std::time::Instant,
+    pub egui_ctx: egui::Context,
+    pending_full_output: egui::FullOutput,
+    egui_winit: egui_winit::State,
+    /// When set, it is time to quit
+    quit: bool,
+    can_drag_window: bool,
+}
+
+impl EpiIntegration {
+    pub fn new<E>(
+        event_loop: &EventLoopWindowTarget<E>,
+        max_texture_side: usize,
+        window: &winit::window::Window,
+        system_theme: Option<Theme>,
+        storage: Option<Box<dyn epi::Storage>>,
+        #[cfg(feature = "glow")] gl: Option<std::sync::Arc<glow::Context>>,
+        #[cfg(feature = "wgpu")] wgpu_render_state: Option<egui_wgpu::RenderState>,
+    ) -> Self {
+        let egui_ctx = egui::Context::default();
+
+        *egui_ctx.memory() = load_egui_memory(storage.as_deref()).unwrap_or_default();
+
+        let frame = epi::Frame {
+            info: epi::IntegrationInfo {
+                system_theme,
+                cpu_usage: None,
+                native_pixels_per_point: Some(native_pixels_per_point(window)),
+                window_info: read_window_info(window, egui_ctx.pixels_per_point()),
+            },
+            output: Default::default(),
+            storage,
+            #[cfg(feature = "glow")]
+            gl,
+            #[cfg(feature = "wgpu")]
+            wgpu_render_state,
+        };
+
+        let mut egui_winit = egui_winit::State::new(event_loop);
+        egui_winit.set_max_texture_side(max_texture_side);
+        let pixels_per_point = window.scale_factor() as f32;
+        egui_winit.set_pixels_per_point(pixels_per_point);
+
+        Self {
+            frame,
+            last_auto_save: std::time::Instant::now(),
+            egui_ctx,
+            egui_winit,
+            pending_full_output: Default::default(),
+            quit: false,
+            can_drag_window: false,
+        }
+    }
+
+    pub fn warm_up(&mut self, app: &mut dyn epi::App, window: &winit::window::Window) {
+        crate::profile_function!();
+        let saved_memory: egui::Memory = self.egui_ctx.memory().clone();
+        self.egui_ctx.memory().set_everything_is_visible(true);
+        let full_output = self.update(app, window);
+        self.pending_full_output.append(full_output); // Handle it next frame
+        *self.egui_ctx.memory() = saved_memory; // We don't want to remember that windows were huge.
+        self.egui_ctx.clear_animations();
+    }
+
+    /// If `true`, it is time to shut down.
+    pub fn should_quit(&self) -> bool {
+        self.quit
+    }
+
+    pub fn on_event(&mut self, app: &mut dyn epi::App, event: &winit::event::WindowEvent<'_>) {
+        use winit::event::{ElementState, MouseButton, WindowEvent};
+
+        match event {
+            WindowEvent::CloseRequested => self.quit = app.on_exit_event(),
+            WindowEvent::Destroyed => self.quit = true,
+            WindowEvent::MouseInput {
+                button: MouseButton::Left,
+                state: ElementState::Pressed,
+                ..
+            } => self.can_drag_window = true,
+            _ => {}
+        }
+
+        self.egui_winit.on_event(&self.egui_ctx, event);
+    }
+
+    pub fn update(
+        &mut self,
+        app: &mut dyn epi::App,
+        window: &winit::window::Window,
+    ) -> egui::FullOutput {
+        let frame_start = std::time::Instant::now();
+
+        self.frame.info.window_info = read_window_info(window, self.egui_ctx.pixels_per_point());
+        let raw_input = self.egui_winit.take_egui_input(window);
+        let full_output = self.egui_ctx.run(raw_input, |egui_ctx| {
+            crate::profile_scope!("App::update");
+            app.update(egui_ctx, &mut self.frame);
+        });
+        self.pending_full_output.append(full_output);
+        let full_output = std::mem::take(&mut self.pending_full_output);
+
+        {
+            let mut app_output = self.frame.take_app_output();
+            app_output.drag_window &= self.can_drag_window; // Necessary on Windows; see https://github.com/emilk/egui/pull/1108
+            self.can_drag_window = false;
+            if app_output.quit {
+                self.quit = app.on_exit_event();
+            }
+            handle_app_output(window, self.egui_ctx.pixels_per_point(), app_output);
+        }
+
+        let frame_time = (std::time::Instant::now() - frame_start).as_secs_f64() as f32;
+        self.frame.info.cpu_usage = Some(frame_time);
+
+        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,
+        platform_output: egui::PlatformOutput,
+    ) {
+        self.egui_winit
+            .handle_platform_output(window, &self.egui_ctx, platform_output);
+    }
+
+    // ------------------------------------------------------------------------
+    // Persistance stuff:
+
+    pub fn maybe_autosave(&mut self, app: &mut dyn epi::App, window: &winit::window::Window) {
+        let now = std::time::Instant::now();
+        if now - self.last_auto_save > app.auto_save_interval() {
+            self.save(app, window);
+            self.last_auto_save = now;
+        }
+    }
+
+    pub fn save(&mut self, _app: &mut dyn epi::App, _window: &winit::window::Window) {
+        #[cfg(feature = "persistence")]
+        if let Some(storage) = self.frame.storage_mut() {
+            crate::profile_function!();
+
+            if _app.persist_native_window() {
+                crate::profile_scope!("native_window");
+                epi::set_value(
+                    storage,
+                    STORAGE_WINDOW_KEY,
+                    &WindowSettings::from_display(_window),
+                );
+            }
+            if _app.persist_egui_memory() {
+                crate::profile_scope!("egui_memory");
+                epi::set_value(storage, STORAGE_EGUI_MEMORY_KEY, &*self.egui_ctx.memory());
+            }
+            {
+                crate::profile_scope!("App::save");
+                _app.save(storage);
+            }
+
+            crate::profile_scope!("Storage::flush");
+            storage.flush();
+        }
+    }
+}
+
+#[cfg(feature = "persistence")]
+const STORAGE_EGUI_MEMORY_KEY: &str = "egui";
+
+#[cfg(feature = "persistence")]
+const STORAGE_WINDOW_KEY: &str = "window";
+
+pub fn load_window_settings(_storage: Option<&dyn epi::Storage>) -> Option<WindowSettings> {
+    #[cfg(feature = "persistence")]
+    {
+        epi::get_value(_storage?, STORAGE_WINDOW_KEY)
+    }
+    #[cfg(not(feature = "persistence"))]
+    None
+}
+
+pub fn load_egui_memory(_storage: Option<&dyn epi::Storage>) -> Option<egui::Memory> {
+    #[cfg(feature = "persistence")]
+    {
+        epi::get_value(_storage?, STORAGE_EGUI_MEMORY_KEY)
+    }
+    #[cfg(not(feature = "persistence"))]
+    None
+}

crates/eframe/src/native/file_storage.rs

@@ -0,0 +1,116 @@
+use std::{
+    collections::HashMap,
+    path::{Path, PathBuf},
+};
+
+// ----------------------------------------------------------------------------
+
+/// A key-value store backed by a [RON](https://github.com/ron-rs/ron) file on disk.
+/// Used to restore egui state, glium window position/size and app state.
+pub struct FileStorage {
+    ron_filepath: PathBuf,
+    kv: HashMap<String, String>,
+    dirty: bool,
+    last_save_join_handle: Option<std::thread::JoinHandle<()>>,
+}
+
+impl Drop for FileStorage {
+    fn drop(&mut self) {
+        if let Some(join_handle) = self.last_save_join_handle.take() {
+            join_handle.join().ok();
+        }
+    }
+}
+
+impl FileStorage {
+    /// Store the state in this .ron file.
+    pub fn from_ron_filepath(ron_filepath: impl Into<PathBuf>) -> Self {
+        let ron_filepath: PathBuf = ron_filepath.into();
+        Self {
+            kv: read_ron(&ron_filepath).unwrap_or_default(),
+            ron_filepath,
+            dirty: false,
+            last_save_join_handle: None,
+        }
+    }
+
+    /// Find a good place to put the files that the OS likes.
+    pub fn from_app_name(app_name: &str) -> Option<Self> {
+        if let Some(proj_dirs) = directories_next::ProjectDirs::from("", "", app_name) {
+            let data_dir = proj_dirs.data_dir().to_path_buf();
+            if let Err(err) = std::fs::create_dir_all(&data_dir) {
+                tracing::warn!(
+                    "Saving disabled: Failed to create app path at {:?}: {}",
+                    data_dir,
+                    err
+                );
+                None
+            } else {
+                Some(Self::from_ron_filepath(data_dir.join("app.ron")))
+            }
+        } else {
+            tracing::warn!("Saving disabled: Failed to find path to data_dir.");
+            None
+        }
+    }
+}
+
+impl crate::Storage for FileStorage {
+    fn get_string(&self, key: &str) -> Option<String> {
+        self.kv.get(key).cloned()
+    }
+
+    fn set_string(&mut self, key: &str, value: String) {
+        if self.kv.get(key) != Some(&value) {
+            self.kv.insert(key.to_owned(), value);
+            self.dirty = true;
+        }
+    }
+
+    fn flush(&mut self) {
+        if self.dirty {
+            self.dirty = false;
+
+            let file_path = self.ron_filepath.clone();
+            let kv = self.kv.clone();
+
+            if let Some(join_handle) = self.last_save_join_handle.take() {
+                // wait for previous save to complete.
+                join_handle.join().ok();
+            }
+
+            let join_handle = std::thread::spawn(move || {
+                let file = std::fs::File::create(&file_path).unwrap();
+                let config = Default::default();
+                ron::ser::to_writer_pretty(file, &kv, config).unwrap();
+                tracing::trace!("Persisted to {:?}", file_path);
+            });
+
+            self.last_save_join_handle = Some(join_handle);
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+fn read_ron<T>(ron_path: impl AsRef<Path>) -> Option<T>
+where
+    T: serde::de::DeserializeOwned,
+{
+    match std::fs::File::open(ron_path) {
+        Ok(file) => {
+            let reader = std::io::BufReader::new(file);
+            match ron::de::from_reader(reader) {
+                Ok(value) => Some(value),
+                Err(err) => {
+                    tracing::warn!("Failed to parse RON: {}", err);
+                    None
+                }
+            }
+        }
+        Err(_err) => {
+            // File probably doesn't exist. That's fine.
+            None
+        }
+    }
+}

crates/eframe/src/native/mod.rs

@@ -0,0 +1,6 @@
+mod epi_integration;
+pub mod run;
+
+/// File storage which can be used by native backends.
+#[cfg(feature = "persistence")]
+pub mod file_storage;

crates/eframe/src/native/run.rs

@@ -0,0 +1,735 @@
+//! Note that this file contains two similar paths - one for [`glow`], one for [`wgpu`].
+//! When making changes to one you often also want to apply it to the other.
+
+use std::time::Duration;
+use std::time::Instant;
+
+use egui_winit::winit;
+use winit::event_loop::{ControlFlow, EventLoop};
+
+use super::epi_integration::{self, EpiIntegration};
+use crate::epi;
+
+#[derive(Debug)]
+struct RequestRepaintEvent;
+
+#[cfg(feature = "glow")]
+#[allow(unsafe_code)]
+fn create_display(
+    native_options: &NativeOptions,
+    window_builder: winit::window::WindowBuilder,
+    event_loop: &EventLoop<RequestRepaintEvent>,
+) -> (
+    glutin::WindowedContext<glutin::PossiblyCurrent>,
+    glow::Context,
+) {
+    crate::profile_function!();
+
+    use crate::HardwareAcceleration;
+
+    let hardware_acceleration = match native_options.hardware_acceleration {
+        HardwareAcceleration::Required => Some(true),
+        HardwareAcceleration::Preferred => None,
+        HardwareAcceleration::Off => Some(false),
+    };
+
+    let gl_window = unsafe {
+        glutin::ContextBuilder::new()
+            .with_hardware_acceleration(hardware_acceleration)
+            .with_depth_buffer(native_options.depth_buffer)
+            .with_multisampling(native_options.multisampling)
+            .with_srgb(true)
+            .with_stencil_buffer(native_options.stencil_buffer)
+            .with_vsync(native_options.vsync)
+            .build_windowed(window_builder, event_loop)
+            .unwrap()
+            .make_current()
+            .unwrap()
+    };
+
+    let gl = unsafe { glow::Context::from_loader_function(|s| gl_window.get_proc_address(s)) };
+
+    (gl_window, gl)
+}
+
+// ----------------------------------------------------------------------------
+
+pub use epi::NativeOptions;
+
+enum EventResult {
+    Wait,
+    RepaintAsap,
+    RepaintAt(Instant),
+    Exit,
+}
+
+trait WinitApp {
+    fn is_focused(&self) -> bool;
+    fn integration(&self) -> &EpiIntegration;
+    fn window(&self) -> &winit::window::Window;
+    fn save_and_destroy(&mut self);
+    fn paint(&mut self) -> EventResult;
+    fn on_event(&mut self, event: winit::event::Event<'_, RequestRepaintEvent>) -> EventResult;
+}
+
+/// Access a thread-local event loop.
+///
+/// We reuse the event-loop so we can support closing and opening an eframe window
+/// multiple times. This is just a limitation of winit.
+fn with_event_loop(f: impl FnOnce(&mut EventLoop<RequestRepaintEvent>)) {
+    use std::cell::RefCell;
+    thread_local!(static EVENT_LOOP: RefCell<EventLoop<RequestRepaintEvent>> = RefCell::new(winit::event_loop::EventLoopBuilder::with_user_event().build()));
+
+    EVENT_LOOP.with(|event_loop| {
+        f(&mut *event_loop.borrow_mut());
+    });
+}
+
+fn run_and_return(event_loop: &mut EventLoop<RequestRepaintEvent>, mut winit_app: impl WinitApp) {
+    use winit::platform::run_return::EventLoopExtRunReturn as _;
+
+    tracing::debug!("event_loop.run_return");
+
+    let mut next_repaint_time = Instant::now();
+
+    event_loop.run_return(|event, _, control_flow| {
+        let event_result = match event {
+            winit::event::Event::LoopDestroyed => EventResult::Exit,
+
+            // Platform-dependent event handlers to workaround a winit bug
+            // See: https://github.com/rust-windowing/winit/issues/987
+            // See: https://github.com/rust-windowing/winit/issues/1619
+            winit::event::Event::RedrawEventsCleared if cfg!(windows) => {
+                next_repaint_time = Instant::now() + Duration::from_secs(1_000_000_000);
+                winit_app.paint()
+            }
+            winit::event::Event::RedrawRequested(_) if !cfg!(windows) => {
+                next_repaint_time = Instant::now() + Duration::from_secs(1_000_000_000);
+                winit_app.paint()
+            }
+
+            winit::event::Event::UserEvent(RequestRepaintEvent)
+            | winit::event::Event::NewEvents(winit::event::StartCause::ResumeTimeReached {
+                ..
+            }) => EventResult::RepaintAsap,
+
+            winit::event::Event::WindowEvent { window_id, .. }
+                if window_id != winit_app.window().id() =>
+            {
+                // This can happen if we close a window, and then reopen a new one,
+                // or if we have multiple windows open.
+                EventResult::Wait
+            }
+
+            event => winit_app.on_event(event),
+        };
+
+        match event_result {
+            EventResult::Wait => {}
+            EventResult::RepaintAsap => {
+                next_repaint_time = Instant::now();
+            }
+            EventResult::RepaintAt(repaint_time) => {
+                next_repaint_time = next_repaint_time.min(repaint_time);
+            }
+            EventResult::Exit => {
+                *control_flow = ControlFlow::Exit;
+                return;
+            }
+        }
+
+        *control_flow = match next_repaint_time.checked_duration_since(Instant::now()) {
+            None => {
+                winit_app.window().request_redraw();
+                ControlFlow::Poll
+            }
+            Some(time_until_next_repaint) => {
+                ControlFlow::WaitUntil(Instant::now() + time_until_next_repaint)
+            }
+        }
+    });
+
+    tracing::debug!("eframe window closed");
+
+    winit_app.save_and_destroy();
+
+    drop(winit_app);
+
+    // Needed to clean the event_loop:
+    event_loop.run_return(|_, _, control_flow| {
+        control_flow.set_exit();
+    });
+}
+
+fn run_and_exit(
+    event_loop: EventLoop<RequestRepaintEvent>,
+    mut winit_app: impl WinitApp + 'static,
+) -> ! {
+    tracing::debug!("event_loop.run");
+
+    let mut next_repaint_time = Instant::now();
+
+    event_loop.run(move |event, _, control_flow| {
+        let event_result = match event {
+            winit::event::Event::LoopDestroyed => EventResult::Exit,
+
+            // Platform-dependent event handlers to workaround a winit bug
+            // See: https://github.com/rust-windowing/winit/issues/987
+            // See: https://github.com/rust-windowing/winit/issues/1619
+            winit::event::Event::RedrawEventsCleared if cfg!(windows) => {
+                next_repaint_time = Instant::now() + Duration::from_secs(1_000_000_000);
+                winit_app.paint()
+            }
+            winit::event::Event::RedrawRequested(_) if !cfg!(windows) => {
+                next_repaint_time = Instant::now() + Duration::from_secs(1_000_000_000);
+                winit_app.paint()
+            }
+
+            winit::event::Event::UserEvent(RequestRepaintEvent)
+            | winit::event::Event::NewEvents(winit::event::StartCause::ResumeTimeReached {
+                ..
+            }) => EventResult::RepaintAsap,
+
+            event => winit_app.on_event(event),
+        };
+
+        match event_result {
+            EventResult::Wait => {}
+            EventResult::RepaintAsap => {
+                next_repaint_time = Instant::now();
+            }
+            EventResult::RepaintAt(repaint_time) => {
+                next_repaint_time = next_repaint_time.min(repaint_time);
+            }
+            EventResult::Exit => {
+                tracing::debug!("Quitting…");
+                winit_app.save_and_destroy();
+                #[allow(clippy::exit)]
+                std::process::exit(0);
+            }
+        }
+
+        *control_flow = match next_repaint_time.checked_duration_since(Instant::now()) {
+            None => {
+                winit_app.window().request_redraw();
+                ControlFlow::Poll
+            }
+            Some(time_until_next_repaint) => {
+                ControlFlow::WaitUntil(Instant::now() + time_until_next_repaint)
+            }
+        }
+    })
+}
+
+// ----------------------------------------------------------------------------
+
+/// Run an egui app
+#[cfg(feature = "glow")]
+mod glow_integration {
+    use std::sync::Arc;
+
+    use super::*;
+
+    struct GlowWinitApp {
+        gl_window: glutin::WindowedContext<glutin::PossiblyCurrent>,
+        gl: Arc<glow::Context>,
+        painter: egui_glow::Painter,
+        integration: epi_integration::EpiIntegration,
+        app: Box<dyn epi::App>,
+        is_focused: bool,
+    }
+
+    impl GlowWinitApp {
+        fn new(
+            event_loop: &EventLoop<RequestRepaintEvent>,
+            app_name: &str,
+            native_options: &epi::NativeOptions,
+            app_creator: epi::AppCreator,
+        ) -> Self {
+            let storage = epi_integration::create_storage(app_name);
+            let window_settings = epi_integration::load_window_settings(storage.as_deref());
+
+            let window_builder = epi_integration::window_builder(native_options, &window_settings)
+                .with_title(app_name);
+            let (gl_window, gl) = create_display(native_options, window_builder, event_loop);
+            let gl = Arc::new(gl);
+
+            let painter = egui_glow::Painter::new(gl.clone(), None, "")
+                .unwrap_or_else(|error| panic!("some OpenGL error occurred {}\n", error));
+
+            let system_theme = native_options.system_theme();
+            let mut integration = epi_integration::EpiIntegration::new(
+                event_loop,
+                painter.max_texture_side(),
+                gl_window.window(),
+                system_theme,
+                storage,
+                Some(gl.clone()),
+                #[cfg(feature = "wgpu")]
+                None,
+            );
+            let theme = system_theme.unwrap_or(native_options.default_theme);
+            integration.egui_ctx.set_visuals(theme.egui_visuals());
+
+            {
+                let event_loop_proxy = egui::mutex::Mutex::new(event_loop.create_proxy());
+                integration.egui_ctx.set_request_repaint_callback(move || {
+                    event_loop_proxy.lock().send_event(RequestRepaintEvent).ok();
+                });
+            }
+
+            let mut app = app_creator(&epi::CreationContext {
+                egui_ctx: integration.egui_ctx.clone(),
+                integration_info: integration.frame.info(),
+                storage: integration.frame.storage(),
+                gl: Some(gl.clone()),
+                #[cfg(feature = "wgpu")]
+                wgpu_render_state: None,
+            });
+
+            if app.warm_up_enabled() {
+                integration.warm_up(app.as_mut(), gl_window.window());
+            }
+
+            Self {
+                gl_window,
+                gl,
+                painter,
+                integration,
+                app,
+                is_focused: true,
+            }
+        }
+    }
+
+    impl WinitApp for GlowWinitApp {
+        fn is_focused(&self) -> bool {
+            self.is_focused
+        }
+
+        fn integration(&self) -> &EpiIntegration {
+            &self.integration
+        }
+
+        fn window(&self) -> &winit::window::Window {
+            self.gl_window.window()
+        }
+
+        fn save_and_destroy(&mut self) {
+            self.integration
+                .save(&mut *self.app, self.gl_window.window());
+            self.app.on_exit(Some(&self.gl));
+            self.painter.destroy();
+        }
+
+        fn paint(&mut self) -> EventResult {
+            #[cfg(feature = "puffin")]
+            puffin::GlobalProfiler::lock().new_frame();
+            crate::profile_scope!("frame");
+
+            let Self {
+                gl_window,
+                gl,
+                app,
+                integration,
+                painter,
+                ..
+            } = self;
+            let window = gl_window.window();
+
+            let screen_size_in_pixels: [u32; 2] = window.inner_size().into();
+
+            egui_glow::painter::clear(
+                gl,
+                screen_size_in_pixels,
+                app.clear_color(&integration.egui_ctx.style().visuals),
+            );
+
+            let egui::FullOutput {
+                platform_output,
+                repaint_after,
+                textures_delta,
+                shapes,
+            } = integration.update(app.as_mut(), window);
+
+            integration.handle_platform_output(window, platform_output);
+
+            let clipped_primitives = {
+                crate::profile_scope!("tessellate");
+                integration.egui_ctx.tessellate(shapes)
+            };
+
+            painter.paint_and_update_textures(
+                screen_size_in_pixels,
+                integration.egui_ctx.pixels_per_point(),
+                &clipped_primitives,
+                &textures_delta,
+            );
+
+            integration.post_rendering(app.as_mut(), window);
+
+            {
+                crate::profile_scope!("swap_buffers");
+                gl_window.swap_buffers().unwrap();
+            }
+
+            let control_flow = if integration.should_quit() {
+                EventResult::Exit
+            } else if repaint_after.is_zero() {
+                EventResult::RepaintAsap
+            } else if let Some(repaint_after_instant) =
+                std::time::Instant::now().checked_add(repaint_after)
+            {
+                // if repaint_after is something huge and can't be added to Instant,
+                // we will use `ControlFlow::Wait` instead.
+                // technically, this might lead to some weird corner cases where the user *WANTS*
+                // winit to use `WaitUntil(MAX_INSTANT)` explicitly. they can roll their own
+                // egui backend impl i guess.
+                EventResult::RepaintAt(repaint_after_instant)
+            } else {
+                EventResult::Wait
+            };
+
+            integration.maybe_autosave(app.as_mut(), window);
+
+            if !self.is_focused {
+                // On Mac, a minimized Window uses up all CPU: https://github.com/emilk/egui/issues/325
+                // We can't know if we are minimized: https://github.com/rust-windowing/winit/issues/208
+                // But we know if we are focused (in foreground). When minimized, we are not focused.
+                // However, a user may want an egui with an animation in the background,
+                // so we still need to repaint quite fast.
+                crate::profile_scope!("bg_sleep");
+                std::thread::sleep(std::time::Duration::from_millis(10));
+            }
+
+            control_flow
+        }
+
+        fn on_event(&mut self, event: winit::event::Event<'_, RequestRepaintEvent>) -> EventResult {
+            match event {
+                winit::event::Event::WindowEvent { event, .. } => {
+                    match &event {
+                        winit::event::WindowEvent::Focused(new_focused) => {
+                            self.is_focused = *new_focused;
+                        }
+                        winit::event::WindowEvent::Resized(physical_size) => {
+                            // Resize with 0 width and height is used by winit to signal a minimize event on Windows.
+                            // See: https://github.com/rust-windowing/winit/issues/208
+                            // This solves an issue where the app would panic when minimizing on Windows.
+                            if physical_size.width > 0 && physical_size.height > 0 {
+                                self.gl_window.resize(*physical_size);
+                            }
+                        }
+                        winit::event::WindowEvent::ScaleFactorChanged {
+                            new_inner_size, ..
+                        } => {
+                            self.gl_window.resize(**new_inner_size);
+                        }
+                        winit::event::WindowEvent::CloseRequested
+                            if self.integration.should_quit() =>
+                        {
+                            return EventResult::Exit
+                        }
+                        _ => {}
+                    }
+
+                    self.integration.on_event(self.app.as_mut(), &event);
+
+                    if self.integration.should_quit() {
+                        EventResult::Exit
+                    } else {
+                        // TODO(emilk): ask egui if the event warrants a repaint
+                        EventResult::RepaintAsap
+                    }
+                }
+                _ => EventResult::Wait,
+            }
+        }
+    }
+
+    pub fn run_glow(
+        app_name: &str,
+        native_options: &epi::NativeOptions,
+        app_creator: epi::AppCreator,
+    ) {
+        if native_options.run_and_return {
+            with_event_loop(|event_loop| {
+                let glow_eframe =
+                    GlowWinitApp::new(event_loop, app_name, native_options, app_creator);
+                run_and_return(event_loop, glow_eframe);
+            });
+        } else {
+            let event_loop = winit::event_loop::EventLoopBuilder::with_user_event().build();
+            let glow_eframe = GlowWinitApp::new(&event_loop, app_name, native_options, app_creator);
+            run_and_exit(event_loop, glow_eframe);
+        }
+    }
+}
+
+#[cfg(feature = "glow")]
+pub use glow_integration::run_glow;
+
+// ----------------------------------------------------------------------------
+
+#[cfg(feature = "wgpu")]
+mod wgpu_integration {
+    use super::*;
+
+    struct WgpuWinitApp {
+        window: winit::window::Window,
+        painter: egui_wgpu::winit::Painter<'static>,
+        integration: epi_integration::EpiIntegration,
+        app: Box<dyn epi::App>,
+        is_focused: bool,
+    }
+
+    impl WgpuWinitApp {
+        fn new(
+            event_loop: &EventLoop<RequestRepaintEvent>,
+            app_name: &str,
+            native_options: &epi::NativeOptions,
+            app_creator: epi::AppCreator,
+        ) -> Self {
+            let storage = epi_integration::create_storage(app_name);
+            let window_settings = epi_integration::load_window_settings(storage.as_deref());
+
+            let window = epi_integration::window_builder(native_options, &window_settings)
+                .with_title(app_name)
+                .build(event_loop)
+                .unwrap();
+
+            // SAFETY: `window` must outlive `painter`.
+            #[allow(unsafe_code, unused_mut, unused_unsafe)]
+            let painter = unsafe {
+                let mut painter = egui_wgpu::winit::Painter::new(
+                    wgpu::Backends::PRIMARY | wgpu::Backends::GL,
+                    wgpu::PowerPreference::HighPerformance,
+                    wgpu::DeviceDescriptor {
+                        label: None,
+                        features: wgpu::Features::default(),
+                        limits: wgpu::Limits::default(),
+                    },
+                    wgpu::PresentMode::Fifo,
+                    native_options.multisampling.max(1) as _,
+                );
+                #[cfg(not(target_os = "android"))]
+                painter.set_window(Some(&window));
+                painter
+            };
+
+            let wgpu_render_state = painter.render_state();
+
+            let system_theme = native_options.system_theme();
+            let mut integration = epi_integration::EpiIntegration::new(
+                event_loop,
+                painter.max_texture_side().unwrap_or(2048),
+                &window,
+                system_theme,
+                storage,
+                #[cfg(feature = "glow")]
+                None,
+                wgpu_render_state.clone(),
+            );
+            let theme = system_theme.unwrap_or(native_options.default_theme);
+            integration.egui_ctx.set_visuals(theme.egui_visuals());
+
+            {
+                let event_loop_proxy = egui::mutex::Mutex::new(event_loop.create_proxy());
+                integration.egui_ctx.set_request_repaint_callback(move || {
+                    event_loop_proxy.lock().send_event(RequestRepaintEvent).ok();
+                });
+            }
+
+            let mut app = app_creator(&epi::CreationContext {
+                egui_ctx: integration.egui_ctx.clone(),
+                integration_info: integration.frame.info(),
+                storage: integration.frame.storage(),
+                #[cfg(feature = "glow")]
+                gl: None,
+                wgpu_render_state,
+            });
+
+            if app.warm_up_enabled() {
+                integration.warm_up(app.as_mut(), &window);
+            }
+
+            Self {
+                window,
+                painter,
+                integration,
+                app,
+                is_focused: true,
+            }
+        }
+    }
+
+    impl WinitApp for WgpuWinitApp {
+        fn is_focused(&self) -> bool {
+            self.is_focused
+        }
+
+        fn integration(&self) -> &EpiIntegration {
+            &self.integration
+        }
+
+        fn window(&self) -> &winit::window::Window {
+            &self.window
+        }
+
+        fn save_and_destroy(&mut self) {
+            self.integration.save(&mut *self.app, &self.window);
+
+            #[cfg(feature = "glow")]
+            self.app.on_exit(None);
+
+            #[cfg(not(feature = "glow"))]
+            self.app.on_exit();
+
+            self.painter.destroy();
+        }
+
+        fn paint(&mut self) -> EventResult {
+            #[cfg(feature = "puffin")]
+            puffin::GlobalProfiler::lock().new_frame();
+            crate::profile_scope!("frame");
+
+            let Self {
+                window,
+                app,
+                integration,
+                painter,
+                ..
+            } = self;
+
+            let egui::FullOutput {
+                platform_output,
+                repaint_after,
+                textures_delta,
+                shapes,
+            } = integration.update(app.as_mut(), window);
+
+            integration.handle_platform_output(window, platform_output);
+
+            let clipped_primitives = {
+                crate::profile_scope!("tessellate");
+                integration.egui_ctx.tessellate(shapes)
+            };
+
+            painter.paint_and_update_textures(
+                integration.egui_ctx.pixels_per_point(),
+                app.clear_color(&integration.egui_ctx.style().visuals),
+                &clipped_primitives,
+                &textures_delta,
+            );
+
+            integration.post_rendering(app.as_mut(), window);
+
+            let control_flow = if integration.should_quit() {
+                EventResult::Exit
+            } else if repaint_after.is_zero() {
+                EventResult::RepaintAsap
+            } else if let Some(repaint_after_instant) =
+                std::time::Instant::now().checked_add(repaint_after)
+            {
+                // if repaint_after is something huge and can't be added to Instant,
+                // we will use `ControlFlow::Wait` instead.
+                // technically, this might lead to some weird corner cases where the user *WANTS*
+                // winit to use `WaitUntil(MAX_INSTANT)` explicitly. they can roll their own
+                // egui backend impl i guess.
+                EventResult::RepaintAt(repaint_after_instant)
+            } else {
+                EventResult::Wait
+            };
+
+            integration.maybe_autosave(app.as_mut(), window);
+
+            if !self.is_focused {
+                // On Mac, a minimized Window uses up all CPU: https://github.com/emilk/egui/issues/325
+                // We can't know if we are minimized: https://github.com/rust-windowing/winit/issues/208
+                // But we know if we are focused (in foreground). When minimized, we are not focused.
+                // However, a user may want an egui with an animation in the background,
+                // so we still need to repaint quite fast.
+                crate::profile_scope!("bg_sleep");
+                std::thread::sleep(std::time::Duration::from_millis(10));
+            }
+
+            control_flow
+        }
+
+        fn on_event(&mut self, event: winit::event::Event<'_, RequestRepaintEvent>) -> EventResult {
+            match event {
+                #[cfg(target_os = "android")]
+                winit::event::Event::Resumed => unsafe {
+                    self.painter.set_window(Some(&self.window));
+                    EventResult::RepaintAsap
+                },
+                #[cfg(target_os = "android")]
+                winit::event::Event::Suspended => unsafe {
+                    self.painter.set_window(None);
+                    EventResult::Wait
+                },
+
+                winit::event::Event::WindowEvent { event, .. } => {
+                    match &event {
+                        winit::event::WindowEvent::Focused(new_focused) => {
+                            self.is_focused = *new_focused;
+                        }
+                        winit::event::WindowEvent::Resized(physical_size) => {
+                            // Resize with 0 width and height is used by winit to signal a minimize event on Windows.
+                            // See: https://github.com/rust-windowing/winit/issues/208
+                            // This solves an issue where the app would panic when minimizing on Windows.
+                            if physical_size.width > 0 && physical_size.height > 0 {
+                                self.painter
+                                    .on_window_resized(physical_size.width, physical_size.height);
+                            }
+                        }
+                        winit::event::WindowEvent::ScaleFactorChanged {
+                            new_inner_size, ..
+                        } => {
+                            self.painter
+                                .on_window_resized(new_inner_size.width, new_inner_size.height);
+                        }
+                        winit::event::WindowEvent::CloseRequested
+                            if self.integration.should_quit() =>
+                        {
+                            return EventResult::Exit
+                        }
+                        _ => {}
+                    };
+
+                    self.integration.on_event(self.app.as_mut(), &event);
+                    if self.integration.should_quit() {
+                        EventResult::Exit
+                    } else {
+                        // TODO(emilk): ask egui if the event warrants a repaint
+                        EventResult::RepaintAsap
+                    }
+                }
+                _ => EventResult::Wait,
+            }
+        }
+    }
+
+    pub fn run_wgpu(
+        app_name: &str,
+        native_options: &epi::NativeOptions,
+        app_creator: epi::AppCreator,
+    ) {
+        if native_options.run_and_return {
+            with_event_loop(|event_loop| {
+                let wgpu_eframe =
+                    WgpuWinitApp::new(event_loop, app_name, native_options, app_creator);
+                run_and_return(event_loop, wgpu_eframe);
+            });
+        } else {
+            let event_loop = winit::event_loop::EventLoopBuilder::with_user_event().build();
+            let wgpu_eframe = WgpuWinitApp::new(&event_loop, app_name, native_options, app_creator);
+            run_and_exit(event_loop, wgpu_eframe);
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[cfg(feature = "wgpu")]
+pub use wgpu_integration::run_wgpu;