Struct InstrumentedPipeline 

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

Times the root passes of the pipeline it wraps, recording into the PhaseMetrics the caller holds.

Wrap the standard pipeline to time the standard frame, or wrap another decorator — .max_fps(30).instrumented(metrics) stacks a rate cap under the timings, in either order.

let metrics = Rc::new(RefCell::new(PhaseMetrics::default()));
application.with_frame_pipeline({
    let metrics = metrics.clone();
    move |_window_id| Box::new(StandardImmediatePipeline.instrumented(metrics.clone()))
})

Implementations

impl<P> InstrumentedPipeline<P>

pub fn new(inner: P, metrics: Rc<RefCell<PhaseMetrics>>) -> Self

Wraps inner, recording its root passes into metrics, which the caller keeps in order to read what it measures.

pub fn inner(&self) -> &P

The pipeline this one wraps.

Trait Implementations

impl<P: FramePipeline> FramePipeline for InstrumentedPipeline<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: 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.