Struct PaxGpuRenderer 

pub struct PaxGpuRenderer { /* private fields */ }

Runtime RenderContext implementation backed by pax-gpu/wgpu.

Implementations

impl PaxGpuRenderer

pub fn new( layer_factory: impl Fn(usize, LayerCreationRequest) -> Pin<Box<dyn Future<Output = Option<(LayerTarget, Pin<Box<dyn Fn() -> LayerSurfaceLayout>>)>>>> + 'static, ) -> Self

Create a renderer that lazily asks the chassis for layer backends.

impl PaxGpuRenderer

pub fn with_layer_initialization_priority( self, priority: impl Fn(usize) -> i32 + 'static, ) -> Self

Prioritize queued layer creation using current chassis presentation state. Lower values start first; equal values retain FIFO order. This does not preempt in-flight work or increase the initialization concurrency limit.

Trait Implementations

impl RenderContext for PaxGpuRenderer

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

Fills a path with an explicit opacity multiplier.

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_with_opacity( &mut self, layer: usize, path: BezPath, stroke: &ResolvedStroke, opacity: f64, )

Strokes a path with an explicit opacity multiplier.

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( &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 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 save(&mut self, layer: usize)

Saves the current graphics state for a layer.

fn restore(&mut self, layer: usize)

Restores the previous graphics state for a layer.

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

Applies a clipping path to a layer.

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 transform(&mut self, layer: usize, affine: Affine)

Applies an affine transform to a layer.

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

Loads raw RGBA image bytes under an identifier.

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 get_image_size(&mut self, image_path: &str) -> Option<(usize, usize)>

Returns the loaded image size, if known.

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

Returns true when the image is available for drawing.

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 clear(&mut self, layer: usize)

Clears a layer.

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 set_scene_lighting(&mut self, layer: usize, lighting: &SceneLighting)

Installs resolved lighting for a logical canvas layer.

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_layers(&mut self) -> Vec<usize>

Returns canvas layers that should replay prior draw commands.

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

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

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.

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, mapping: 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 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 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 stroke(&mut self, layer: usize, path: BezPath, stroke: &ResolvedStroke)

Strokes a path at full opacity.

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

Draws a previously loaded image into rect at full opacity.

fn retains_canvas_nodes(&self) -> bool

Returns whether the backend retains individual canvas nodes across frames.