Struct ThrottledPipeline 

pub struct ThrottledPipeline<P> { /* private fields */ }

Defers frames that arrive sooner than a target rate.

Changes only should_render and forwards every other pass to the pipeline it wraps, so the wrapped pipeline draws exactly as it would have. Wrap the standard pipeline to cap an application’s frame rate, or wrap another decorator — .max_fps(30) reads the same on an InstrumentedPipeline as on a StandardImmediatePipeline.

A deferred frame is not a dropped one. It leaves the window dirty and leaves what the frame would have done pending, so the next frame draws it — including when the platform asks for a frame on its own, which it does while the window is dirty. Deferring does not need to schedule that next frame: should_render is asked before a frame’s work starts, with no window to schedule one with.

Implementations

impl<P> ThrottledPipeline<P>

pub fn new(inner: P, max_fps: u32) -> Self

Limits inner to max_fps frames a second.

Zero is treated as one frame a second. A pipeline that should never draw is what answering false from should_render is for.

pub fn inner(&self) -> &P

The pipeline this one wraps.

Trait Implementations

impl<P: FramePipeline> FramePipeline for ThrottledPipeline<P>

fn should_render(&mut self, is_dirty: bool, metrics: &WindowMetrics) -> bool

Whether the frame the application is about to draw should be drawn.

fn begin_frame(&mut self, window: &mut Window<'_>, cx: &mut App)

Opens the frame: samples the platform window, resets the scratch state the frame rebuilds, and takes ownership of the invalidations this frame owes.

fn evaluate_roots( &mut self, window: &mut Window<'_>, cx: &mut App, ) -> PreparedRoots

Gathers the roots this frame will draw.

fn layout_roots( &mut self, window: &mut Window<'_>, roots: &mut PreparedRoots, cx: &mut App, )

Lays out and prepaints roots, then hit tests the pointer against what they registered.

fn paint_roots( &mut self, window: &mut Window<'_>, roots: PreparedRoots, cx: &mut App, )

Paints roots, in the order they stack.

fn finish_frame(&mut self, window: &mut Window<'_>, cx: &mut App)

Closes the painted frame: records the views it touched and hands the platform the input handler the frame asked for.

fn complete_frame( &mut self, window: &mut Window<'_>, cx: &mut App, ) -> Option<FocusId>

Retires the painted frame, swaps it in, and dispatches the focus changes the swap produced.

fn end_frame( &mut self, window: &mut Window<'_>, cx: &mut App, focus_before_listeners: Option<FocusId>, )

Closes the frame out and marks it ready to present.

fn draw_roots(&mut self, window: &mut Window<'_>, cx: &mut App)

Lays out and paints the window’s roots: the window’s own view tree, plus a prompt, drag image or tooltip if the frame has one.

fn draw(&mut self, window: &mut Window<'_>, cx: &mut App) -> ArenaClearNeeded

Draws one frame by running the phases above in order.