Struct ObservingRenderer 

pub struct ObservingRenderer<R, F> { /* private fields */ }

A renderer that hands every scene it is given to a closure before passing it on.

Observation belongs here rather than in a backend. It needs nothing from the platform, so a backend that learned about inspection would carry it once per API, and the scene is already an engine type: a scene optimiser, a culling pass, an assertion about what primitives a renderer is handed and in what order, are all statements about this layer.

What a window painted is observable one layer up, where the frame still holds the scene it built (Window::painted_quads), so this is for observing a renderer rather than a frame.

This wraps a renderer in another renderer, and the choices that make it useful are the forwarding ones: it observes draw and render_scene, and it does not override render_scene_to_image, so a readback is observed once through the render_scene it composes rather than twice.

Implementations

impl<R, F> ObservingRenderer<R, F>

pub fn new(inner: R, on_scene: F) -> Self

Wraps inner, calling on_scene with each scene it is asked to draw.

pub fn inner(&self) -> &R

The renderer being observed.

pub fn inner_mut(&mut self) -> &mut R

The renderer being observed.

pub fn into_inner(self) -> R

Takes back the observed renderer.

Trait Implementations

impl<R, F> SceneRenderer for ObservingRenderer<R, F>

where R: SceneRenderer, F: FnMut(&Scene) + 'static,

fn draw(&mut self, scene: &Scene) -> bool

Encodes and submits scene, returning whether it was presented.

fn sprite_atlas(&self) -> Arc<dyn PlatformAtlas>

Returns the sprite atlas used by this renderer.

fn set_viewport_size(&mut self, size: Size<DevicePixels>)

Sets the size of the target that draw renders into.

fn render_scene( &mut self, scene: &Scene, size: Size<DevicePixels>, ) -> Result<()>

Renders scene into an offscreen target of size, without reading it back.

fn read_pixels(&mut self) -> Result<PixelBuffer>

Reads the offscreen target of the last render_scene back.

fn render_scene_to_image( &mut self, scene: &Scene, size: Size<DevicePixels>, ) -> Result<PixelBuffer>

Renders scene offscreen and reads the result back.