Struct egui_render_wgpu::WgpuBackend

pub struct WgpuBackend {
    pub instance: Arc<Instance>,
    pub adapter: Arc<Adapter>,
    pub device: Arc<Device>,
    pub queue: Arc<Queue>,
    pub painter: EguiPainter,
    pub surface_manager: SurfaceManager,
    pub command_encoders: Vec<CommandEncoder>,
}

This provides a Gfx backend for egui using wgpu as the backend If you are making your own wgpu integration, then you can reuse the EguiPainter instead which contains only egui render specific data.

Fields

instance: Arc<Instance>

wgpu instance

adapter: Arc<Adapter>

wgpu adapter

device: Arc<Device>

wgpu device.

queue: Arc<Queue>

wgpu queue. if you have commands that you would like to submit, instead push them into Self::command_encoders

painter: EguiPainter

contains egui specific wgpu data like textures or buffers or pipelines etc..

surface_manager: SurfaceManager

command_encoders: Vec<CommandEncoder>

this is where we store our command encoders. we will create one during the prepare_frame fn. users can just use this. or create new encoders, and push them into this vec. wgpu::Queue::submit is very expensive, so we will submit ALL command encoders at the same time during the present_frame method just before presenting the swapchain image (surface texture).

Implementations

impl WgpuBackend

pub async fn new_async( window_backend: &mut impl WindowBackend, config: <Self as GfxBackend>::Configuration ) -> Self

Trait Implementations

impl Drop for WgpuBackend

fn drop(&mut self)

Executes the destructor for this type.

impl GfxBackend for WgpuBackend

type Configuration = WgpuConfig

similar to WindowBackendConfig. A custom config struct for the creation of GfxBackend

fn new( window_backend: &mut impl WindowBackend, config: Self::Configuration ) -> Self

create a new GfxBackend using info from window backend and custom config struct WindowBackend trait provides the backend config, which can be used by the renderer to check for compatibility.

fn resume(&mut self, window_backend: &mut impl WindowBackend)

Android Only. called when app is resumed after suspension. On Android, window can only be created on resume event. so, you cannot create a Surface before entering the event loop. when this fn is called, we can create a new surface (swapchain) for the window. doesn’t apply on other platforms.

fn prepare_frame(&mut self, window_backend: &mut impl WindowBackend)

prepare the surface / swapchain etc.. by acquiring an image for the current frame. use WindowBackend::get_live_physical_size_framebuffer fn to resize your swapchain if it is out of date.

fn render_egui( &mut self, meshes: Vec<ClippedPrimitive>, textures_delta: TexturesDelta, logical_screen_size: [f32; 2] )

This is where the renderers will start creating renderpasses, issue draw calls etc.. using the data previously prepared.

fn present(&mut self, _window_backend: &mut impl WindowBackend)

This is called at the end of the frame. after everything is drawn, you can now present on opengl, renderer might call WindowBackend::swap_buffers. on wgpu / vulkan, renderer might submit commands to queues, present swapchain image etc..

fn resize_framebuffer(&mut self, window_backend: &mut impl WindowBackend)

called if framebuffer has been resized. use this to reconfigure your swapchain/surface/viewport..

fn suspend(&mut self, _window_backend: &mut impl WindowBackend)

Android only. callend on app suspension, which destroys the window. so, will need to destroy the Surface and recreate during resume event.