Struct OffscreenRenderer 

pub struct OffscreenRenderer { /* private fields */ }

Headless scene renderer: renders a Scene into CPU-readable RGBA8.

Contracts

• Output is width * height * 4 bytes, row-major, premultiplied-alpha sRGB (Rgba8UnormSrgb): opaque content reads back exact sRGB bytes; translucent pixels carry rgb * a (divide by a for straight alpha).
• clear = None fills with scene.clear_color; Some(c) overrides it with linear-space [r, g, b, a] doubles.
• All sizes clamp to a minimum of 1 (no zero-sized textures/buffers).
• render_rgba blocks until the GPU work completes and the pixels are mapped; it is safe to call every frame (no per-frame allocations beyond the returned Vec).
• Without a usable GPU adapter, new/new_blocking fail with an error (never a panic, never silent fallback).

Implementations

impl OffscreenRenderer

pub async fn new(width: u32, height: u32, msaa: u32) -> Result<Self>

Create a renderer for widthxheight frames with msaa samples (clamped to what the adapter supports via pick_surface_msaa). Dimensions clamp to ≥ 1. Errors when no GPU adapter is available.

pub fn new_blocking(width: u32, height: u32, msaa: u32) -> Result<Self>

Blocking new. Must not run on the wasm main thread without block support (debug-asserted); use render_rgba_async there.

pub fn from_device( device: Device, queue: Queue, width: u32, height: u32, msaa: u32, ) -> Result<Self>

Shared-device: reuse Device/Queue, no Adapter. Dimensions clamp to ≥ 1; msaa clamps to ≥ 1 (no adapter-based picking without one — prefer from_device_with_adapter when an adapter is handy).

pub fn from_device_with_adapter( device: Device, queue: Queue, adapter: &Adapter, width: u32, height: u32, msaa: u32, ) -> Result<Self>

Shared-device with adapter-based MSAA picking. Dimensions clamp to ≥ 1.

pub fn from_renderer( renderer: WgpuSceneRenderer, width: u32, height: u32, ) -> Result<Self>

Wrap an existing scene renderer with a fresh target + readback buffer. Dimensions clamp to ≥ 1.

pub fn render_rgba( &mut self, scene: &Scene, clear: Option<[f64; 4]>, ) -> Result<Vec<u8>>

Render scene and read back width * height * 4 premultiplied sRGB bytes (see the struct contracts). clear = None uses scene.clear_color; an empty scene therefore reads back the clear color exactly. Blocks until mapping completes.

pub fn renderer_mut(&mut self) -> &mut WgpuSceneRenderer

pub fn renderer(&self) -> &WgpuSceneRenderer

pub fn width(&self) -> u32

Current target width in pixels.

pub fn height(&self) -> u32

Current target height in pixels.

pub fn ensure_size(&mut self, width: u32, height: u32) -> Result<()>

Resize the target + readback buffer. A no-op when the size already matches (no reallocation). Dimensions clamp to ≥ 1. After this, render_rgba returns width * height * 4 bytes at the new size.

pub async fn render_rgba_unified( &mut self, scene: &Scene, clear: Option<[f64; 4]>, ) -> Result<Vec<u8>>