Struct Painter 

pub struct Painter { /* private fields */ }

Everything you need to paint egui with wgpu on winit.

Alternatively you can use crate::Renderer directly.

NOTE: all egui viewports share the same painter.

Implementations

impl Painter

pub async fn new( context: Context, configuration: WgpuConfiguration, support_transparent_backbuffer: bool, options: RendererOptions, ) -> Self

Manages wgpu state, including surface state, required to render egui.

Only the wgpu::Instance is initialized here. Device selection and the initialization of render + surface state is deferred until the painter is given its first window target via set_window(). (Ensuring that a device that’s compatible with the native window is chosen)

Before calling paint_and_update_textures() a wgpu::Surface must be initialized (and corresponding render state) by calling set_window() once you have a winit::window::Window with a valid .raw_window_handle() associated.

pub fn render_state(&self) -> Option<RenderState>

Get the RenderState.

Will return None if the render state has not been initialized yet.

pub async fn set_window( &mut self, viewport_id: ViewportId, window: Option<Arc<Window>>, ) -> Result<(), WgpuError>

Updates (or clears) the winit::window::Window associated with the Painter

This creates a wgpu::Surface for the given Window (as well as initializing render state if needed) that is used for egui rendering.

This must be called before trying to render via paint_and_update_textures

Portability

In particular it’s important to note that on Android a it’s only possible to create a window surface between Resumed and Paused lifecycle events, and Winit will panic on attempts to query the raw window handle while paused.

On Android set_window should be called with Some(window) for each Resumed event and None for each Paused event. Currently, on all other platforms set_window may be called with Some(window) as soon as you have a valid winit::window::Window.

Errors

If the provided wgpu configuration does not match an available device.

pub async unsafe fn set_window_unsafe( &mut self, viewport_id: ViewportId, window: Option<&Window>, ) -> Result<(), WgpuError>

Updates (or clears) the winit::window::Window associated with the Painter without taking ownership of the window.

Like set_window except:

Safety

The user is responsible for ensuring that the window is alive for as long as it is set.

pub fn max_texture_side(&self) -> Option<usize>

Returns the maximum texture dimension supported if known

This API will only return a known dimension after set_window() has been called at least once, since the underlying device and render state are initialized lazily once we have a window (that may determine the choice of adapter/device).

pub fn on_window_resize_state_change( &mut self, viewport_id: ViewportId, resizing: bool, )

Handles changes of the resizing state.

Should be called prior to the first Painter::on_window_resized call and after the last in the chain. Used to apply platform-specific logic, e.g. OSX Metal window resize jitter fix.

pub fn on_window_resized( &mut self, viewport_id: ViewportId, width_in_pixels: NonZeroU32, height_in_pixels: NonZeroU32, )

pub fn paint_and_update_textures( &mut self, viewport_id: ViewportId, pixels_per_point: f32, clear_color: [f32; 4], clipped_primitives: &[ClippedPrimitive], textures_delta: &TexturesDelta, capture_data: Vec<UserData>, ) -> f32

Returns two things:

The approximate number of seconds spent on vsync-waiting (if any), and the captures captured screenshot if it was requested.

If capture_data isn’t empty, a screenshot will be captured.

pub fn handle_screenshots(&self, events: &mut Vec<Event>)

Call this at the beginning of each frame to receive the requested screenshots.

pub fn gc_viewports(&mut self, active_viewports: &ViewportIdSet)

pub fn destroy(&mut self)