Struct LayerTree 

pub struct LayerTree { /* private fields */ }

Renderer-independent retained layer arena. Picture display lists are owned once and scene flattening only emits a transient linear command stream. This deliberately has no GPU resources or offscreen textures.

Implementations

impl LayerTree

pub fn new() -> Self

pub fn diagnostics(&self) -> CompositorDiagnostics

pub fn root(&self) -> Option<LayerId>

pub fn layer(&self, id: LayerId) -> Option<(&LayerKind, &[LayerId])>

Read-only view of one layer’s kind and ordered children, for diagnostics and inspection tooling.

pub fn set_root(&mut self, root: LayerId)

pub fn scene_bounds(&self) -> Option<Rect>

Returns the retained scene’s conservative world-space visual bounds after compositor transforms, rectangular clipping, blur support, and drop-shadow support have been applied.

This is renderer-independent geometry. It is useful to embedders that need to size a native host around retained content without inspecting widget types or GPU commands.

pub fn create_picture( &mut self, display_list: DisplayList, bounds: Rect, ) -> LayerId

pub fn create_transform(&mut self, transform: Transform) -> LayerId

pub fn create_clip_rect(&mut self, rect: Rect) -> LayerId

pub fn create_clip_rrect(&mut self, rrect: RRect) -> LayerId

Creates a rounded-rectangle clip stage in local space; the world shape resolves at flatten time like Self::create_clip_rect.

pub fn create_clip_oval(&mut self, rect: Rect) -> LayerId

Creates an oval clip stage in local space; the world shape resolves at flatten time like Self::create_clip_rect.

pub fn create_clip_path( &mut self, path: Arc<Path>, fill_rule: FillRule, ) -> LayerId

Creates a path clip stage in local space; the world shape resolves at flatten time like Self::create_clip_rect.

pub fn create_opacity(&mut self, alpha: f32) -> LayerId

Creates an isolated compositor group. Alpha is normalized at the renderer-neutral boundary so every backend observes identical values.

pub fn create_blur(&mut self, blur: GaussianBlur) -> LayerId

Creates an isolated Gaussian-filtered compositor group.

pub fn create_drop_shadow(&mut self, shadow: DropShadowEffect) -> LayerId

Creates an isolated arbitrary-subtree drop-shadow compositor group.

pub fn create_color_filter(&mut self, filter: ColorFilter) -> LayerId

Creates an isolated color-matrix stage. Matrix changes are compositor updates and deliberately do not change the source generation.

pub fn create_blend(&mut self, mode: BlendMode) -> LayerId

Creates a retained blend group whose source remains cached when only the discrete blend mode changes.

pub fn create_shader_mask( &mut self, shader: Brush, blend_mode: BlendMode, mask_size: Size, mask_transform: Transform, ) -> LayerId

Creates an isolated shader-mask stage. The callback is evaluated by the retained widget during paint; this layer only owns the resolved, renderer-neutral shader description and its local coordinate space.

pub fn create_backdrop_filter( &mut self, blur: GaussianBlur, blend_mode: BlendMode, enabled: bool, ) -> LayerId

Creates a backdrop-filter stage. Unlike Self::create_blur, this stage samples the already painted destination before its child is composited.

pub fn update_backdrop_matrix( &mut self, id: LayerId, matrix: Option<Transform>, ) -> bool

Sets the matrix a backdrop-filter stage transforms its backdrop by (Flutter ImageFilter.matrix), or clears it for the blur.

pub fn update_backdrop_key( &mut self, id: LayerId, key: Option<BackdropKey>, ) -> bool

Sets the backdrop a backdrop-filter stage shares with others (Flutter BackdropKey), or clears it.

pub fn create_annotated_region( &mut self, annotation: Annotation, sized: bool, size: Size, ) -> LayerId

pub fn create_leader(&mut self, link: LayerLink, size: Size) -> LayerId

pub fn create_follower(&mut self, follower: FollowerLayer) -> LayerId

pub fn remove(&mut self, id: LayerId)

pub fn set_children(&mut self, id: LayerId, children: Vec<LayerId>)

pub fn set_surface_partition( &mut self, id: LayerId, partition: Option<SurfacePartitionId>, )

Marks one retained layer subtree as detachable presentation content. The marker is renderer-neutral and does not alter layout, painting, or the retained layer topology.

pub fn clear_surface_partitions(&mut self)

Clears every detachable-surface marker. WidgetTree reapplies markers for the currently visible transient portals before flattening each frame.

pub fn update_picture( &mut self, id: LayerId, display_list: DisplayList, bounds: Rect, )

pub fn update_picture_if_changed( &mut self, id: LayerId, display_list: &DisplayList, bounds: Rect, ) -> bool

Replaces a picture layer’s contents only when display_list or bounds differ from what it holds, copying the list in that case. A repaint that records the same picture keeps the retained one and its generation, so a caller can record into one reused buffer without allocating per layer. Returns whether the layer changed.

pub fn update_transform(&mut self, id: LayerId, transform: Transform) -> bool

pub fn update_clip(&mut self, id: LayerId, rect: Rect) -> bool

pub fn update_clip_rrect(&mut self, id: LayerId, rrect: RRect) -> bool

pub fn update_clip_oval(&mut self, id: LayerId, rect: Rect) -> bool

pub fn update_clip_path( &mut self, id: LayerId, path: Arc<Path>, fill_rule: FillRule, ) -> bool

pub fn update_opacity(&mut self, id: LayerId, alpha: f32) -> bool

Updates only the group alpha. This deliberately does not change the content generation, allowing a cached offscreen texture to be reused while an opacity animation is ticking.

pub fn update_blur(&mut self, id: LayerId, blur: GaussianBlur) -> bool

Updates Gaussian parameters without changing the retained source generation. A backend recomputes only the filtered result.

pub fn update_drop_shadow( &mut self, id: LayerId, shadow: DropShadowEffect, ) -> bool

Updates shadow presentation properties without changing source pixels. Sigma invalidates the filtered mask; offset/color remain composite-only in GPU backends.

pub fn update_color_filter(&mut self, id: LayerId, filter: ColorFilter) -> bool

pub fn update_blend(&mut self, id: LayerId, mode: BlendMode) -> bool

pub fn update_shader_mask( &mut self, id: LayerId, shader: Brush, blend_mode: BlendMode, mask_size: Size, mask_transform: Transform, ) -> bool

pub fn update_shader_mask_blend( &mut self, id: LayerId, blend_mode: BlendMode, ) -> bool

pub fn update_backdrop_filter( &mut self, id: LayerId, blur: GaussianBlur, blend_mode: BlendMode, enabled: bool, ) -> bool

pub fn update_annotated_region( &mut self, id: LayerId, annotation: Annotation, sized: bool, size: Size, ) -> bool

pub fn update_leader( &mut self, id: LayerId, link: LayerLink, size: Size, ) -> bool

pub fn update_leader_size(&mut self, id: LayerId, size: Size) -> bool

pub fn update_follower(&mut self, id: LayerId, follower: FollowerLayer) -> bool

pub fn flattened_pictures(&self) -> &[FlattenedPicture]

World-space logical bounds captured by the most recent Self::flatten call. This keeps coordinate diagnostics out of the renderer hot path.

pub fn flattened_annotations(&self) -> &[FlattenedAnnotation]

pub fn find_annotation<T: Any + Clone>(&self, point: Offset) -> Option<T>

Returns the front-most annotation of type T at point. Annotation lookup follows layer paint order, honours ancestor clips, and treats sized: false regions as covering the entire clipped subtree.

pub fn find_annotations<T: Any + Clone>(&self, point: Offset) -> Vec<T>

pub fn flatten(&mut self) -> DisplayList

pub fn publish_leader_links(&mut self)

Republishes leader links from current layer state for readers that run before flatten (notably semantic collection, which the frame runs pre-paint). Same pass flatten runs, so follower visibility reflects this frame’s layout instead of the previous paint; genuinely hidden leaders still stay unpublished. Idempotent.

pub fn debug_tree(&self) -> String

Trait Implementations

impl Default for LayerTree

fn default() -> Self

Returns the “default value” for a type.