Struct RunOptions 

#[non_exhaustive]
pub struct RunOptions { /* private fields */ }

Options controlling run_on_with’s pacing and idle behavior.

Implementations

impl RunOptions

pub const fn animated(target_fps: u32) -> RunOptions

Options for a continuously-rendering, target_fps-paced loop.

event_driven is false: Flow::Idle only skips present, it never blocks. Use this for apps that drive a retroglyph_ui::animate::Tween/ FrameClock from Frame::delta and need update called every tick regardless of input.

target_fps becomes RunOptions::target_fps verbatim, including 0: run_on_with treats Some(0) as uncapped, the same as None, rather than deriving a zero-length frame budget from it.

pub const fn with_target_fps(self, target_fps: u32) -> RunOptions

Caps the loop at this many App::update calls per second whenever a frame actually runs, sleeping out the remainder of each frame’s budget to pace them evenly. None (the default) runs uncapped: as fast as update allows for back-to-back Flow::Continue frames, or immediately after whatever woke an event_driven loop from Flow::Idle.

pub const fn target_fps(&self) -> Option<u32>

Returns the configured target_fps cap, if any.

pub const fn event_driven(self, event_driven: bool) -> RunOptions

On Flow::Idle, block on input instead of calling update again immediately.

true (the default) is right for turn-based, event-driven apps that are idle most of the time: an idle frame costs approximately nothing, blocked in the backend’s input read rather than spinning update as fast as the host can manage. false keeps Flow::Idle non-blocking (skip present, keep looping at whatever rate target_fps allows): right for apps that animate from Frame::delta and only return Idle between animation-driven Continue frames, where blocking would freeze the animation until the next stray input event. See RunOptions::animated for that shape.

pub const fn is_event_driven(&self) -> bool

Returns whether Flow::Idle blocks on input rather than looping immediately.

pub const fn with_idle_wake(self, idle_wake: Duration) -> RunOptions

When is_event_driven is true, the longest an idle loop blocks before calling update again anyway, even with no input. None (the default) blocks indefinitely: right for apps with nothing to redraw until input arrives. Some(d) additionally wakes the loop every d, for apps that need a periodic idle redraw (a blinking cursor, a clock) without paying full frame-rate cost. Builder calls apply in order: this always switches idle to Idle::Block with idle_wake, even after a preceding event_driven(false) or animated; a later event_driven(false) still switches back to Idle::Spin and drops the wake interval.

pub const fn idle_wake(&self) -> Option<Duration>

Returns the configured idle_wake interval, if any.

pub const fn idle(&self) -> Idle

Returns the configured Idle behavior.

Trait Implementations

impl Clone for RunOptions

fn clone(&self) -> RunOptions

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for RunOptions

impl Debug for RunOptions

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for RunOptions

fn default() -> RunOptions

Event-driven, uncapped, blocks indefinitely on Flow::Idle: see run_on.

impl Eq for RunOptions

impl PartialEq for RunOptions

fn eq(&self, other: &RunOptions) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for RunOptions