Struct WgpuRenderer 

pub struct WgpuRenderer { /* private fields */ }

Implementations

impl WgpuRenderer

pub fn new<W>( gpu_context: WgpuContextSlot, window: &W, config: WgpuSurfaceConfig, compositor_gpu: Option<CompositorGpuHint>, gpu_preference: GpuPreference, ) -> Result<Self>

where W: HasWindowHandle + HasDisplayHandle + Debug + Send + Sync + Clone + 'static,

Creates a new WgpuRenderer from raw window handles.

The gpu_context is a shared reference that coordinates GPU context across multiple windows. The first window to create a renderer will initialize the context; subsequent windows will share it.

Safety

The caller must ensure that the window handle remains valid for the lifetime of the returned renderer.

impl WgpuRenderer

pub fn update_drawable_size(&mut self, size: Size<DevicePixels>)

Records the new drawable size and reconfigures the surface when one is present. The size is kept even without GPU resources so that recovery restores it.

pub fn set_subpixel_layout(&mut self, is_bgr: bool)

pub fn update_transparency(&mut self, transparent: bool)

pub fn viewport_size(&self) -> Size<DevicePixels>

pub fn sprite_atlas(&self) -> &Arc<WgpuAtlas>

pub fn supports_dual_source_blending(&self) -> bool

pub fn device(&self) -> &Device

Returns None once GPU resources have been released by destroy or a pending device recovery. A producer on this path renders its texture on this device – that is the whole of the same-device rule – so a renderer that can be built without a window is where an application that owns one reaches a device from. A window’s is reached through GpuRenderer::device, which is the same device by another route.

pub fn queue(&self) -> &Queue

The queue this renderer submits on.

pub fn gpu_context(&self) -> Option<WgpuContextSlot>

The shared context slot this renderer draws through, if it has one.

pub fn gpu_specs(&self) -> Option<GpuSpecs>

pub fn max_texture_size(&self) -> u32

pub fn draw(&mut self, scene: &Scene) -> bool

impl WgpuRenderer

pub fn unconfigure_surface(&mut self)

Mark the surface as unconfigured so rendering is skipped until a new surface is provided via replace_surface.

This does not drop the renderer — the device, queue, atlas, and pipelines stay alive. Use this when the native window is destroyed (e.g. Android TerminateWindow) but you intend to re-create the surface later without losing cached atlas textures.

pub fn replace_surface<W: HasWindowHandle>( &mut self, window: &W, config: WgpuSurfaceConfig, instance: &Instance, ) -> Result<()>

Replace the wgpu surface with a new one (e.g. after Android destroys and recreates the native window). Keeps the device, queue, atlas, and all pipelines intact so cached AtlasTextureIds remain valid.

The instance must be the same wgpu::Instance that was used to create the adapter and device (i.e. from the WgpuContext). Using a different instance will cause a “Device does not exist” panic because the wgpu device is bound to its originating instance.

pub fn destroy(&mut self)

pub fn device_lost(&self) -> bool

Returns true if the GPU device was lost and recovery is needed.

pub fn needs_redraw(&mut self) -> bool

Returns true if a redraw is needed because GPU state was cleared. Calling this method clears the flag.

pub fn recover<W>(&mut self, window: &W) -> Result<()>

where W: HasWindowHandle + HasDisplayHandle + Debug + Send + Sync + Clone + 'static,

Recovers from a lost GPU device by recreating the renderer with a new context.

Call this after detecting device_lost() returns true.

This method coordinates recovery across multiple windows:

• The first window to call this will recreate the shared context
• Subsequent windows will adopt the already-recovered context

Trait Implementations

impl GpuRenderer for WgpuRenderer

type Device = (Arc<Device>, Arc<Queue>)

The shared context slot, which is where a producer on this path reaches the device and the queue: it is the same Rc every window in the process draws through, so reading them out of it is the rendezvous it exists for. None for a renderer built offscreen, which holds no context because it has no window to coordinate with.

fn device(&self) -> Option<Self::Device>

The device, or None while there is none to lend: a renderer mid-recovery has taken its device apart and has not yet rebuilt it.

impl PlatformRenderer for WgpuRenderer

fn update_drawable_size(&mut self, size: Size<DevicePixels>)

The target’s size changed, in device pixels.

fn max_texture_size(&self) -> u32

The largest texture this renderer can allocate, in pixels.

fn gpu_specs(&self) -> Option<GpuSpecs>

What GPU this renderer is on, if it can tell.

fn set_subpixel_layout(&mut self, is_bgr: bool)

Whether glyphs are rasterized with subpixel antialiasing in BGR order.

fn update_transparency(&mut self, transparent: bool)

The window’s transparency changed.

fn destroy(&mut self)

Release the renderer’s resources, keeping it reconstructible.

fn device_lost(&self) -> bool

Whether the GPU device or its surface has been lost.

fn needs_redraw(&mut self) -> bool

Whether the renderer has work the frame loop should not wait on.

fn recover(&mut self, target: RendererTarget<'_>) -> Result<()>

Rebuild from the target the renderer was built against, after a lost device or surface.

impl SceneRenderer for WgpuRenderer

fn draw(&mut self, scene: &Scene) -> bool

Encodes and submits scene, returning whether it was presented.

fn sprite_atlas(&self) -> Arc<dyn PlatformAtlas>

Returns the sprite atlas used by this renderer.

fn set_viewport_size(&mut self, _size: Size<DevicePixels>)

Sets the size of the target that draw renders into.

fn render_scene( &mut self, _scene: &Scene, _size: Size<DevicePixels>, ) -> Result<(), Error>

Renders scene into an offscreen target of size, without reading it back.

fn read_pixels(&mut self) -> Result<PixelBuffer, Error>

Reads the offscreen target of the last render_scene back.

fn offscreen_surface_handle(&self) -> Option<Arc<dyn Any + Send + Sync>>

The offscreen target of the last render_scene, as a handle that may cross a thread boundary.

fn render_scene_to_image( &mut self, scene: &Scene, size: Size<DevicePixels>, ) -> Result<PixelBuffer, Error>

Renders scene offscreen and reads the result back.