Struct LayerNode 

pub struct LayerNode {

    pub node_id: Option<NodeId>,
    pub wraps: Option<NodeId>,
    pub local_bounds: Rect,
    pub node_bounds: Option<Rect>,
    pub transform_to_parent: ProjectiveTransform,
    pub content_offset: Point,
    pub motion_context_animated: bool,
    pub translated_content_context: bool,
    pub translated_content_offset: Point,
    pub origin_in_parent: Point,
    pub graphics_layer: LayerProperties,
    pub clip_to_bounds: bool,
    pub hit_test: Option<HitTestNode>,
    pub has_hit_targets: bool,
    pub has_origin_sinks: bool,
    pub draws_within_bounds: bool,
    pub isolation: IsolationReasons,
    pub cache_policy: CachePolicy,
    pub cache_hashes: Cell<Option<LayerRasterCacheHashes>>,
    pub content_changes: ContentChanges,
    pub children: Vec<RenderNode>,
}

A node of the render graph that groups content under one set of layer properties: bounds, transform, clip, graphics layer and children.

Fields

node_id: Option<NodeId>

Layout node of this layer, or None for the root and the synthetic wrapper layers.

wraps: Option<NodeId>

Set on the synthetic layer that holds a node’s outer draws, those chained before its graphics layer, around that node’s own layer. Scene updates address the node through this id because the node’s layer has none of the outer draws and the wrapper has no node id of its own.

local_bounds: Rect

The bounds of the node’s layer, where its clip cuts, its transforms pivot and an offscreen pass draws it.

node_bounds: Option<Rect>

The node’s own rect, (0, 0, size), where its pointer handlers are, when it differs from local_bounds: a clip or graphics layer that wraps a coordinator a later padding or offset moves bounds the layer there instead, as in Compose. None when the two agree.

transform_to_parent: ProjectiveTransform

Maps the layer’s local space to its parent’s content space, with the placement, the graphics layer transform and the parent’s content offset applied.

content_offset: Point

Offset in logical pixels of the node’s content box from the node origin, for example from padding. Children are placed relative to it.

motion_context_animated: bool

Whether the layer is inside a motion context such as an animated scroll, where a renderer must not snap its content rigidly to the pixel grid.

translated_content_context: bool

Whether the layer moves its content as one translated block, as a scroll container does, so a renderer may snap that content to the pixel grid as a whole.

translated_content_offset: Point

Translation in logical pixels of the content when translated_content_context is set.

origin_in_parent: Point

Where layout placed this layer within its parent’s content, before the parent’s content offset. Scene updates add these up from the root, with each layer’s content offset and graphics-layer translation, to find the window origin of a subtree they rebuild.

graphics_layer: LayerProperties

The graphics layer properties; they read as defaults when none were set.

clip_to_bounds: bool

Whether the layer cuts its content to local_bounds.

hit_test: Option<HitTestNode>

Pointer handling of the node, or None when the node has none.

has_hit_targets: bool

Whether this layer or a layer beneath it has a hit test node. Scene building keeps it current.

has_origin_sinks: bool

Whether this subtree publishes live window origins (a text field’s popup anchor, a scroll container’s viewport rect). Those sinks are written during a full lowering, so the scroll fast path may translate a retained subtree in place only when this is false.

draws_within_bounds: bool

Whether everything this layer and its subtree draw lies within its local_bounds, give or take CONTAINED_DRAW_SLACK, so a renderer may skip the whole subtree where those bounds are clipped away. Scene building keeps it current; false promises nothing.

isolation: IsolationReasons

The reasons this layer is drawn through its own offscreen buffer.

cache_policy: CachePolicy

Whether a renderer may keep this layer’s pixels between frames.

cache_hashes: Cell<Option<LayerRasterCacheHashes>>

The raster cache hashes, computed the first time a renderer asks and kept until the layer or a layer beneath it changes.

content_changes: ContentChanges

The scene updates that changed what the layer draws.

children: Vec<RenderNode>

Content in draw order: primitives, draw runs and child layers.

Implementations

impl LayerNode

pub fn painted_text(&self) -> Vec<String>

Every string this layer and the layers below it paint, in draw order.

pub fn content_draws_within_bounds(&self) -> bool

Whether this layer’s content, as LayerNode::draws_within_bounds describes it, stays within its bounds: it clips to them, or its draws, its texts and its children placed where they are all fit inside.

pub fn node_rect(&self) -> Rect

The node’s own rect, where its pointer handlers are.

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

The rectangle that cuts the layer’s content and pointer hits: its bounds when the layer clips to bounds or its graphics layer clips, otherwise None.

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

Where the layer’s own shadow is cut: its bounds when it clips its content to them. A graphics-layer clip leaves the shadow whole.

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

Where the layer’s drawing is cut: its clip or, when it composites through an offscreen buffer for its alpha or by request, its bounds, as Compose’s layer-sized buffer cuts it. Hit testing takes only Self::clip_rect: alpha hides nothing from a finger.

pub fn effect(&self) -> Option<&RenderEffect>

The render effect applied to the layer’s content, if any.

pub fn backdrop(&self) -> Option<&RenderEffect>

The effect applied to what lies behind the layer, if any.

pub fn opacity(&self) -> f32

Alpha of the layer from 0.0 (transparent) to 1.0 (opaque).

pub fn blend_mode(&self) -> BlendMode

How the layer composites onto what lies beneath it.

pub fn color_filter(&self) -> Option<ColorFilter>

The color filter applied to the layer’s content, if any.

pub fn target_content_hash(&self) -> u64

Hash of everything the layer draws into its target: bounds, clip, alpha, children and their placement. Equal hashes mean cached pixels are still valid. Computed on first use.

pub fn motion_source_content_hash(&self) -> u64

Hash of the layer’s content like target_content_hash, except that the translated content offset is left out, so the hash stays equal while the content only moves.

pub fn effect_hash(&self) -> u64

Hash of the layer’s render effect, for keying cached effect output.

pub fn forget_raster_cache_hashes(&mut self)

Forgets the raster cache hashes of this layer and every layer beneath it, after a change the scene builder did not make: they are computed again when asked for.

pub fn content_churns(&self, update: u64) -> bool

Whether what this layer draws changed in scene update update and in the one before it. A raster cache keyed on its content would miss again on the next frame, so a renderer neither hashes nor caches it.

Trait Implementations

impl Clone for LayerNode

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for LayerNode

fn default() -> Self

Returns the “default value” for a type.