Struct rerun::external::eframe::egui_wgpu::winit::Painter

pub struct Painter {

    context: Context,
    configuration: WgpuConfiguration,
    msaa_samples: u32,
    support_transparent_backbuffer: bool,
    dithering: bool,
    depth_format: Option<TextureFormat>,
    screen_capture_state: Option<CaptureState>,
    instance: Instance,
    render_state: Option<RenderState>,
    depth_texture_view: HashMap<ViewportId, TextureView, BuildHasherDefault<NoHashHasher<ViewportId>>>,
    msaa_texture_view: HashMap<ViewportId, TextureView, BuildHasherDefault<NoHashHasher<ViewportId>>>,
    surfaces: HashMap<ViewportId, SurfaceState, BuildHasherDefault<NoHashHasher<ViewportId>>>,
    capture_tx: Sender<(ViewportId, Vec<UserData>, ColorImage)>,
    capture_rx: Receiver<(ViewportId, Vec<UserData>, ColorImage)>,
}

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.

Fields

context: Context

configuration: WgpuConfiguration

msaa_samples: u32

support_transparent_backbuffer: bool

dithering: bool

depth_format: Option<TextureFormat>

screen_capture_state: Option<CaptureState>

instance: Instance

render_state: Option<RenderState>

depth_texture_view: HashMap<ViewportId, TextureView, BuildHasherDefault<NoHashHasher<ViewportId>>>

msaa_texture_view: HashMap<ViewportId, TextureView, BuildHasherDefault<NoHashHasher<ViewportId>>>

surfaces: HashMap<ViewportId, SurfaceState, BuildHasherDefault<NoHashHasher<ViewportId>>>

capture_tx: Sender<(ViewportId, Vec<UserData>, ColorImage)>

capture_rx: Receiver<(ViewportId, Vec<UserData>, ColorImage)>

Implementations

impl Painter

pub async fn new( context: Context, configuration: WgpuConfiguration, msaa_samples: u32, depth_format: Option<TextureFormat>, support_transparent_backbuffer: bool, dithering: bool, ) -> Painter

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_resized( &mut self, viewport_id: ViewportId, width_in_pixels: NonZero<u32>, height_in_pixels: NonZero<u32>, )

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: &HashSet<ViewportId, BuildHasherDefault<NoHashHasher<ViewportId>>>, )

pub fn destroy(&mut self)