Struct PaneOverlay 

pub struct PaneOverlay { /* private fields */ }

A Pane UI instance that renders into an existing wgpu surface.

You retain full control of the window, event loop, and wgpu device. Pane composites its output on top of whatever you have already rendered that frame.

Create with overlay, then call handle_event from your winit event loop and draw each frame.

Implementations

impl PaneOverlay

pub fn handle_event(&mut self, event: &WindowEvent, pw: f32, ph: f32)

Forward a winit WindowEvent to Pane’s input handler.

pub fn handle_gamepad_event(&mut self, event: Event)

Forward a gilrs gamepad event manually.

Use this if you own the gilrs instance yourself — pass None for gilrs in overlay first to prevent Pane from also polling it internally.

pub fn disable_auto_gamepad(&mut self)

Stop Pane from polling gilrs internally.

pub fn draw( &mut self, encoder: &mut CommandEncoder, view: &TextureView, pw: f32, ph: f32, ) -> Vec<PaneAction>

Tick and render the UI into an existing render pass.

Call once per frame, after your own render commands and before presenting. Returns all PaneActions emitted since the last call.

• encoder — your active command encoder for the current frame.
• view — the texture view to render into (typically your swap chain image).
• pw / ph — window dimensions in logical pixels.

pub fn read(&self, id: &str) -> Option<(&UiItem, WidgetState)>

Returns the item data and its current visual state for any widget by id.

Pattern-match on UiItem to access widget-specific fields:

if let Some((UiItem::Button(b), vis)) = ui.read("my_button") {
    println!("disabled={} hovered={}", b.disabled, vis.hovered);
}
if let Some((UiItem::Slider(s), vis)) = ui.read("volume") {
    println!("value={} grabbed={}", s.value, vis.grabbed);
}

pub fn write(&mut self, id: &str, value: &WriteValue)

Set a widget’s value programmatically.

See WriteValue for the supported widget types and their matching variants. Mismatched types and unknown ids are logged and ignored.

pub fn create(&mut self, root: &str, builder: impl WidgetBuilder) -> bool

Add a code-built widget to a named root. Returns false if the id is already in use or the root doesn’t exist.

pub fn destroy(&mut self, id: &str) -> bool

Remove a widget by id from any root. Returns true if a widget was removed.

pub fn create_root(&mut self, name: impl Into<String>)

Create an empty root that can be populated with Self::create.

pub fn style_id(&self, name: &str) -> Option<StyleId>

Resolve a style name to its StyleId for use with builders.

pub fn default_style(&self) -> Option<&str>

Returns the name of the current default style, if one is set.

pub fn set_default_style(&mut self, name: &str) -> bool

Switch the default style by name. Returns false if the name is not registered.

pub const fn set_debug(&mut self, on: bool)

Enable or disable debug message logging. When on, every internal UiMsg is printed to stdout.

pub fn push_toast( &mut self, message: impl Into<String>, duration: f32, x: f32, y: f32, width: f32, height: f32, )

Spawn a transient toast notification at the given position.

pub fn actor_move_to(&mut self, id: &str, x: f32, y: f32, speed: f32)

Programmatically send an actor to a fixed position, overriding its RON behaviours.

pub fn actor_follow_cursor(&mut self, id: &str, speed: f32, trail: f32)

Programmatically make an actor follow the cursor, overriding its RON behaviours.

pub fn actor_reset(&mut self, id: &str)

Clear any programmatic override on an actor, returning it to its RON behaviours.

pub fn actor_set_pos(&mut self, id: &str, x: f32, y: f32)

Teleport an actor to a position instantly, without lerping.