Struct Gpu 

pub struct Gpu { /* private fields */ }

wgpu device + surface bundle for one OS window.

Implementations

impl Gpu

pub fn surface_configured(&self) -> bool

Is the swap chain currently configured?

false while a configure-failure run is in progress: a Surface::configure (in Self::resize or Self::try_acquire_frame) failed and no retry has succeeded yet, so Self::try_acquire_frame will skip frames until one does. A shell can use this to hold off attempts that cannot succeed — agg-gui-shell stops painting a minimized window only while this is false. Read-only; true again as soon as a configure succeeds.

pub fn try_acquire_frame(&self) -> Result<FrameAcquire, SurfaceError>

Acquire the next surface texture.

• A stale swap chain (Outdated/Lost) is reconfigured and the acquire retried once, this call.
• A swap chain left unconfigured by a failed configure (here or in Self::resize) is configured again first, paced by a backoff: the first retry is immediate, later ones wait 50 ms doubling to 1 s, and a call made before the next attempt is due skips without calling configure (each attempt costs a full GPU wait-idle).
• Otherwise the frame is skipped with the RetryWake the caller should arrange; see FrameAcquire.

Errors

SurfaceError::ConfigureRetriesExhausted once a configure retry fails after the surface has been unconfigured for longer than crate::GpuConfig::surface_retry_budget and at least 12 attempts in the run have failed.

While the window is minimized and Self::surface_configured is false, don’t call this: every configure retry against a minimized window fails and counts against the budget (agg-gui-shell skips the paint in exactly that state). The budget clock still runs from the run’s first failure while attempts are paused, so it is the attempt minimum that gives a restored window a real retry run (about 6.5 s) instead of an exit at its first failed retry.

A lost device also fails configure; shells should check Self::device_lost before each frame and rebuild the Gpu, which starts with a fresh retry state, rather than let the budget run out.

pub fn acquire_frame(&self, request_redraw: impl Fn()) -> Option<SurfaceTexture>

Legacy form of Self::try_acquire_frame, kept for existing callers. Prefer try_acquire_frame; this will be deprecated in 0.6.

Returns None when the frame must be skipped, and arranges the retry itself: RetryWake::Now calls request_redraw (pass a closure that calls Window::request_redraw), RetryWake::After schedules agg_gui::animation::request_draw_after — agg_gui’s thread-local draw state, so call this on the UI thread — and RetryWake::OnEvent does nothing.

Panics

When Self::try_acquire_frame returns SurfaceError — the surface could not be configured for the whole retry budget. Before the retry existed the first failed configure panicked inside wgpu, so this keeps crash-and-restart supervision working; handle the error instead by moving to try_acquire_frame.

impl Gpu

pub fn new( target: impl Into<SurfaceTarget<'static>>, size: (u32, u32), config: GpuConfig, ) -> Result<Self, GpuInitError>

Create the surface, adapter, device and queue for target (typically an Arc<winit::window::Window>) and configure the swap chain at size physical pixels, clamped by clamp_surface_size.

A non-sRGB surface format is preferred so the renderer’s colour maths — which writes linear-space values — isn’t gamma-corrected twice by the surface.

pub fn device_lost(&self) -> bool

Has this device been lost since it was created?

Set from wgpu’s device-lost callback (TDR / driver reset / GPU removal / RDP session change); our own Device::destroy is not counted. A lost device cannot be revived — every resource created from it is dead too — so the only recovery is to build a fresh Gpu for the same window, rebuild the renderer on the new device, and drop any GPU resources the app cached. Shells should poll this once per frame.

The C# port polls the same flag at the top of a frame and rebuilds from it in PlatformWin32/win32/WebGpuControl.cs::TryRecoverDevice (agg-sharp), which is the closest thing to a reference implementation of the recovery this flag is meant to drive.

pub fn device(&self) -> &Arc<Device>

pub fn queue(&self) -> &Arc<Queue>

pub fn surface(&self) -> &Surface<'static>

pub fn surface_format(&self) -> TextureFormat

pub fn config(&self) -> &SurfaceConfiguration

The live swap-chain configuration — width / height are the clamped physical pixel size the shell should hand to layout and WgpuGfxCtx.

pub fn resize(&mut self, w: u32, h: u32)

Reconfigure the swap chain for a new physical size. A zero-sized (minimized) window is ignored — there is no presentable surface then, and wgpu rejects a zero extent.

A failed configure (DX12 ResizeBuffers rejecting a window Windows is still settling) does not panic: it is recorded, logged, and retried by Self::try_acquire_frame with backoff. A new size is new information, so it is configured immediately even while an earlier failure is backing off.