migrations/egui
1
0
Fork 0
mirror of https://github.com/emilk/egui.git synced 2026-09-01 22:30:03 -04:00
Code Activity

Refactor integrations (#871)

Browse Source 
* Unify code in egui_glium and egui_glow into egui_winit::EpiIntegration
* Simplify `EguiGlium` interface
* Simplify `EguiGlow` interface
* egui_web refactor: merge `WebBackend` into `AppRunner`
This commit is contained in:
Emil Ernerfeldt
2021-11-03 13:45:51 +01:00
committed by GitHub
parent b1716be745
commit 1dbe608e73
14 changed files with 381 additions and 479 deletions
Download Patch File Download Diff File Expand all files Collapse all files

131
egui_glium/src/epi_backend.rs
View File

@@ -2,7 +2,6 @@ use crate::*;
use egui::Color32;
#[cfg(target_os = "windows")]
use glium::glutin::platform::windows::WindowBuilderExtWindows;
use std::time::Instant;
impl epi::TextureAllocator for Painter {
fn alloc_srgba_premultiplied(
@@ -45,85 +44,35 @@ fn create_display(
glium::Display::new(window_builder, context_builder, event_loop).unwrap()
}
fn integration_info(
display: &glium::Display,
previous_frame_time: Option<f32>,
) -> epi::IntegrationInfo {
epi::IntegrationInfo {
name: "egui_glium",
web_info: None,
prefer_dark_mode: None, // TODO: figure out system default
cpu_usage: previous_frame_time,
native_pixels_per_point: Some(egui_winit::native_pixels_per_point(
display.gl_window().window(),
)),
}
}
// ----------------------------------------------------------------------------
pub use epi::NativeOptions;
/// Run an egui app
pub fn run(mut app: Box<dyn epi::App>, native_options: &epi::NativeOptions) -> ! {
let mut persistence = egui_winit::epi::Persistence::from_app_name(app.name());
pub fn run(app: Box<dyn epi::App>, native_options: &epi::NativeOptions) -> ! {
let persistence = egui_winit::epi::Persistence::from_app_name(app.name());
let window_settings = persistence.load_window_settings();
let event_loop = glutin::event_loop::EventLoop::with_user_event();
let window_builder =
egui_winit::epi::window_builder(native_options, &window_settings).with_title(app.name());
let event_loop = glutin::event_loop::EventLoop::with_user_event();
let display = create_display(window_builder, &event_loop);
let repaint_signal = std::sync::Arc::new(GliumRepaintSignal(std::sync::Mutex::new(
event_loop.create_proxy(),
)));
let mut egui = EguiGlium::new(&display);
*egui.ctx().memory() = persistence.load_memory().unwrap_or_default();
{
let (ctx, painter) = egui.ctx_and_painter_mut();
let mut app_output = epi::backend::AppOutput::default();
let mut frame = epi::backend::FrameBuilder {
info: integration_info(&display, None),
tex_allocator: painter,
output: &mut app_output,
repaint_signal: repaint_signal.clone(),
}
.build();
app.setup(ctx, &mut frame, persistence.storage());
}
let mut previous_frame_time = None;
let mut painter = crate::Painter::new(&display);
let mut integration = egui_winit::epi::EpiIntegration::new(
"egui_glium",
display.gl_window().window(),
&mut painter,
repaint_signal,
persistence,
app,
);
let mut is_focused = true;
if app.warm_up_enabled() {
let saved_memory = egui.ctx().memory().clone();
egui.ctx().memory().set_everything_is_visible(true);
egui.begin_frame(&display);
let (ctx, painter) = egui.ctx_and_painter_mut();
let mut app_output = epi::backend::AppOutput::default();
let mut frame = epi::backend::FrameBuilder {
info: integration_info(&display, None),
tex_allocator: painter,
output: &mut app_output,
repaint_signal: repaint_signal.clone(),
}
.build();
app.update(ctx, &mut frame);
let _ = egui.end_frame(&display);
*egui.ctx().memory() = saved_memory; // We don't want to remember that windows were huge.
egui.ctx().clear_animations();
// TODO: handle app_output
// eprintln!("Warmed up in {} ms", warm_up_start.elapsed().as_millis())
}
event_loop.run(move |event, _, control_flow| {
let mut redraw = || {
if !is_focused {
@@ -135,41 +84,29 @@ pub fn run(mut app: Box<dyn epi::App>, native_options: &epi::NativeOptions) -> !
std::thread::sleep(std::time::Duration::from_millis(10));
}
let frame_start = std::time::Instant::now();
egui.begin_frame(&display);
let (ctx, painter) = egui.ctx_and_painter_mut();
let mut app_output = epi::backend::AppOutput::default();
let mut frame = epi::backend::FrameBuilder {
info: integration_info(&display, previous_frame_time),
tex_allocator: painter,
output: &mut app_output,
repaint_signal: repaint_signal.clone(),
}
.build();
app.update(ctx, &mut frame);
let (needs_repaint, shapes) = egui.end_frame(&display);
let frame_time = (Instant::now() - frame_start).as_secs_f64() as f32;
previous_frame_time = Some(frame_time);
let (needs_repaint, shapes) =
integration.update(display.gl_window().window(), &mut painter);
let clipped_meshes = integration.egui_ctx.tessellate(shapes);
{
use glium::Surface as _;
let mut target = display.draw();
let color = app.clear_color();
let color = integration.app.clear_color();
target.clear_color(color[0], color[1], color[2], color[3]);
egui.paint(&display, &mut target, shapes);
painter.paint_meshes(
&display,
&mut target,
integration.egui_ctx.pixels_per_point(),
clipped_meshes,
&integration.egui_ctx.texture(),
);
target.finish().unwrap();
}
{
egui_winit::epi::handle_app_output(
display.gl_window().window(),
egui.ctx().pixels_per_point(),
app_output.clone(),
);
*control_flow = if app_output.quit {
*control_flow = if integration.should_quit() {
glutin::event_loop::ControlFlow::Exit
} else if needs_repaint {
display.gl_window().window().request_redraw();
@@ -179,7 +116,7 @@ pub fn run(mut app: Box<dyn epi::App>, native_options: &epi::NativeOptions) -> !
};
}
persistence.maybe_autosave(&mut *app, egui.ctx(), display.gl_window().window());
integration.maybe_autosave(display.gl_window().window());
};
match event {
@@ -190,27 +127,23 @@ pub fn run(mut app: Box<dyn epi::App>, native_options: &epi::NativeOptions) -> !
glutin::event::Event::RedrawRequested(_) if !cfg!(windows) => redraw(),
glutin::event::Event::WindowEvent { event, .. } => {
if egui.is_quit_event(&event) {
*control_flow = glium::glutin::event_loop::ControlFlow::Exit;
}
if let glutin::event::WindowEvent::Focused(new_focused) = event {
is_focused = new_focused;
}
egui.on_event(&event);
integration.on_event(&event);
if integration.should_quit() {
*control_flow = glium::glutin::event_loop::ControlFlow::Exit;
}
display.gl_window().window().request_redraw(); // TODO: ask egui if the events warrants a repaint instead
}
glutin::event::Event::LoopDestroyed => {
app.on_exit();
persistence.save(&mut *app, egui.ctx(), display.gl_window().window());
integration.on_exit(display.gl_window().window());
}
glutin::event::Event::UserEvent(RequestRepaintEvent) => {
display.gl_window().window().request_redraw();
}
_ => (),
}
});