egui_glow/
winit.rs

1pub use egui_winit::{self, EventResponse};
2
3use egui::{ViewportId, ViewportOutput};
4use egui_winit::winit;
5
6use crate::shader_version::ShaderVersion;
7
8/// Use [`egui`] from a [`glow`] app based on [`winit`].
9pub struct EguiGlow {
10    pub egui_ctx: egui::Context,
11    pub egui_winit: egui_winit::State,
12    pub painter: crate::Painter,
13
14    viewport_info: egui::ViewportInfo,
15
16    // output from the last update:
17    shapes: Vec<egui::epaint::ClippedShape>,
18    pixels_per_point: f32,
19    textures_delta: egui::TexturesDelta,
20}
21
22impl EguiGlow {
23    /// For automatic shader version detection set `shader_version` to `None`.
24    pub fn new(
25        event_loop: &winit::event_loop::ActiveEventLoop,
26        gl: std::sync::Arc<glow::Context>,
27        shader_version: Option<ShaderVersion>,
28        native_pixels_per_point: Option<f32>,
29        dithering: bool,
30    ) -> Self {
31        let painter = crate::Painter::new(gl, "", shader_version, dithering)
32            .map_err(|err| {
33                log::error!("error occurred in initializing painter:\n{err}");
34            })
35            .unwrap();
36
37        let egui_ctx = egui::Context::default();
38
39        let egui_winit = egui_winit::State::new(
40            egui_ctx.clone(),
41            ViewportId::ROOT,
42            event_loop,
43            native_pixels_per_point,
44            event_loop.system_theme(),
45            Some(painter.max_texture_side()),
46        );
47
48        Self {
49            egui_ctx,
50            egui_winit,
51            painter,
52            viewport_info: Default::default(),
53            shapes: Default::default(),
54            pixels_per_point: native_pixels_per_point.unwrap_or(1.0),
55            textures_delta: Default::default(),
56        }
57    }
58
59    pub fn on_window_event(
60        &mut self,
61        window: &winit::window::Window,
62        event: &winit::event::WindowEvent,
63    ) -> EventResponse {
64        self.egui_winit.on_window_event(window, event)
65    }
66
67    /// Call [`Self::paint`] later to paint.
68    pub fn run(&mut self, window: &winit::window::Window, run_ui: impl FnMut(&egui::Context)) {
69        let raw_input = self.egui_winit.take_egui_input(window);
70
71        let egui::FullOutput {
72            platform_output,
73            textures_delta,
74            shapes,
75            pixels_per_point,
76            viewport_output,
77        } = self.egui_ctx.run(raw_input, run_ui);
78
79        if viewport_output.len() > 1 {
80            log::warn!("Multiple viewports not yet supported by EguiGlow");
81        }
82        for (_, ViewportOutput { commands, .. }) in viewport_output {
83            let mut actions_requested = Default::default();
84            egui_winit::process_viewport_commands(
85                &self.egui_ctx,
86                &mut self.viewport_info,
87                commands,
88                window,
89                &mut actions_requested,
90            );
91            for action in actions_requested {
92                log::warn!("{action:?} not yet supported by EguiGlow");
93            }
94        }
95
96        self.egui_winit
97            .handle_platform_output(window, platform_output);
98
99        self.shapes = shapes;
100        self.pixels_per_point = pixels_per_point;
101        self.textures_delta.append(textures_delta);
102    }
103
104    /// Paint the results of the last call to [`Self::run`].
105    pub fn paint(&mut self, window: &winit::window::Window) {
106        let shapes = std::mem::take(&mut self.shapes);
107        let mut textures_delta = std::mem::take(&mut self.textures_delta);
108
109        for (id, image_delta) in textures_delta.set {
110            self.painter.set_texture(id, &image_delta);
111        }
112
113        let pixels_per_point = self.pixels_per_point;
114        let clipped_primitives = self.egui_ctx.tessellate(shapes, pixels_per_point);
115        let dimensions: [u32; 2] = window.inner_size().into();
116        self.painter
117            .paint_primitives(dimensions, pixels_per_point, &clipped_primitives);
118
119        for id in textures_delta.free.drain(..) {
120            self.painter.free_texture(id);
121        }
122    }
123
124    /// Call to release the allocated graphics resources.
125    pub fn destroy(&mut self) {
126        self.painter.destroy();
127    }
128}