Struct PietRenderer 

pub struct PietRenderer<S: PietSurface> { /* private fields */ }

RenderContext implementation backed by piet.

Implementations

impl<S: PietSurface> PietRenderer<S>

pub fn new( layer_factory: impl Fn(usize) -> (PietLayerTarget<S>, Box<dyn Fn() -> LayerSurfaceLayout>) + 'static, ) -> Self

Create a piet renderer with a chassis-provided logical layer factory.

Trait Implementations

impl<S: PietSurface> RenderContext for PietRenderer<S>

fn fill_with_opacity( &mut self, layer: usize, path: BezPath, fill: &Paint, opacity: f64, )

Fills a path with an explicit opacity multiplier.

fn stroke_with_opacity( &mut self, layer: usize, path: BezPath, stroke: &ResolvedStroke, opacity: f64, )

Strokes a path with an explicit opacity multiplier.

fn stroke_with_draw_range_and_material_and_opacity( &mut self, layer: usize, path: BezPath, stroke: &ResolvedStroke, _material: &ResolvedMaterial, opacity: f64, draw_start: f64, draw_end: f64, )

Strokes a path with a normalized visible range over the path’s total length.

fn save(&mut self, layer: usize)

Saves the current graphics state for a layer.

fn transform(&mut self, layer: usize, affine: Affine)

Applies an affine transform to a layer.

fn clip(&mut self, layer: usize, path: BezPath)

Applies a clipping path to a layer.

fn restore(&mut self, layer: usize)

Restores the previous graphics state for a layer.

fn load_image(&mut self, path: &str, buf: &[u8], width: usize, height: usize)

Loads raw RGBA image bytes under an identifier.

fn get_image_size(&mut self, image_path: &str) -> Option<(usize, usize)>

Returns the loaded image size, if known.

fn draw_image_with_opacity( &mut self, layer: usize, image_path: &str, rect: Rect, opacity: f64, )

Draws an image with an opacity multiplier, in addition to source pixel alpha. Backends must apply this at draw time without changing the cached source image.

fn layers(&self) -> usize

Returns the current number of render layers.

fn resize_layers_to( &mut self, layer_count: usize, dirty_canvases: Rc<RefCell<Vec<bool>>>, )

Resizes the backend layer set to layer_count.

fn image_loaded(&self, path: &str) -> bool

Returns true when the image is available for drawing.

fn clear(&mut self, layer: usize)

Clears a layer.

fn supports_subtree_opacity(&self) -> bool

Whether canvas opacity is applied after composing each subtree’s canvas content. This does not imply that the backend caches content across frames.

fn set_node_opacity_scopes( &mut self, layer: usize, _node_id: u32, scopes: &[OpacityScope], )

Assigns stable opacity ancestry to the currently recorded canvas node.

fn flush(&mut self, layer: usize, _dirty_canvases: Rc<RefCell<Vec<bool>>>)

Flushes a layer to its presentation target.

fn resize(&mut self, _width: usize, _height: usize)

Resizes the render surface.

fn refresh_layers(&mut self, layers: &[usize])

Requests refresh of specific layers.

fn clear_targeted_replay(&mut self, layer: usize)

Cancels any narrowed replay scope for a layer so subsequent work targets all surfaces.

fn take_ready_canvas_layers(&mut self) -> Vec<usize>

Returns canvas layers ready to present.

fn take_replay_canvas_layer_updates(&mut self) -> Vec<ReplayCanvasLayerUpdate>

Returns canvas layer replay work, optionally narrowed to canvas-content regions.

fn retains_canvas_nodes(&self) -> bool

Returns whether the backend retains individual canvas nodes across frames.

fn begin_node( &mut self, layer: usize, _node_id: u32, _z_index: i32, _light_mask: u32, ) -> bool

Begins rendering a node and returns false when the backend can skip it.

fn begin_node_with_bounds( &mut self, layer: usize, node_id: u32, _z_index: i32, coverage_bounds: Rect, _light_mask: u32, ) -> bool

Begins rendering a node with conservative canvas-space coverage bounds.

fn take_clean_skipped_node(&mut self, layer: usize, node_id: u32) -> bool

Returns true when a bounded node skipped by begin_node_with_bounds is clean for now.

fn end_node(&mut self, layer: usize, _node_id: u32) -> bool

Ends rendering a node and returns true when the node was recorded.

fn remove_node(&mut self, _layer: usize, _node_id: u32) -> bool

Removes a node from backend retained state, if any.

fn fill(&mut self, layer: usize, path: BezPath, fill: &Paint)

Fills a path at full opacity.

fn fill_with_material_and_opacity( &mut self, layer: usize, path: BezPath, fill: &Paint, _material: &ResolvedMaterial, opacity: f64, )

Fills a path with a material and explicit opacity multiplier.

fn fill_with_material_and_opacity_and_smoothing( &mut self, layer: usize, path: BezPath, fill: &Paint, material: &ResolvedMaterial, opacity: f64, smoothing: PathSmoothing, )

Fills a path after optional geometry smoothing.

fn stroke(&mut self, layer: usize, path: BezPath, stroke: &ResolvedStroke)

Strokes a path at full opacity.

fn stroke_with_material_and_opacity( &mut self, layer: usize, path: BezPath, stroke: &ResolvedStroke, _material: &ResolvedMaterial, opacity: f64, )

Strokes a path with a material and explicit opacity multiplier.

fn stroke_with_material_and_opacity_and_smoothing( &mut self, layer: usize, path: BezPath, stroke: &ResolvedStroke, material: &ResolvedMaterial, opacity: f64, smoothing: PathSmoothing, )

Strokes a path after optional geometry smoothing.

fn stroke_with_draw_range_and_material_and_opacity_and_smoothing( &mut self, layer: usize, path: BezPath, stroke: &ResolvedStroke, material: &ResolvedMaterial, opacity: f64, draw_start: f64, draw_end: f64, smoothing: PathSmoothing, )

Strokes a draw-ranged path after optional geometry smoothing.

fn clip_alpha( &mut self, _layer: usize, _paints: &[AlphaMaskPaint], _feather: f64, )

Clips canvas drawing by source-over vector paint alpha, optionally feathered with a Gaussian of this standard deviation in logical pixels.

fn supports_alpha_source_capture(&self) -> bool

Whether alpha sources can use ordinary retained vector rendering.

fn alpha_source_layer(&self) -> Option<usize>

Destination layer while recording a detached alpha source. Source coordinates are world coordinates; begin_alpha_source supplies the mapping to the destination surface.

fn begin_alpha_source( &mut self, _layer: usize, _world_to_surface: Affine, _inherited_scopes: usize, _feather: f64, )

Isolates source draws from visible content and inherited clips. The currently open node owns the result. Scopes before inherited_scopes belong to the consumer, not the source.

fn end_alpha_source(&mut self, _layer: usize)

Completes the source and installs its captured alpha in the consumer’s clip stack.

fn draw_image(&mut self, layer: usize, image_path: &str, rect: Rect)

Draws a previously loaded image into rect at full opacity.

fn set_scene_lighting(&mut self, _layer: usize, _lighting: &SceneLighting)

Installs resolved lighting for a logical canvas layer.

fn take_replay_canvas_layers(&mut self) -> Vec<usize>

Returns canvas layers that should replay prior draw commands.

fn request_layer_screenshot(&mut self, _layer: usize, _request_id: u32)

Requests a screenshot for one render layer.

fn take_layer_screenshot( &mut self, _layer: usize, _request_id: u32, ) -> Option<ScreenshotData>

Returns a previously requested layer screenshot, if ready.

fn take_layer_surface_screenshots( &mut self, layer: usize, request_id: u32, ) -> Vec<LayerSurfaceScreenshotData>

Returns ready screenshots for the physical surfaces backing one logical layer.