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>,
}

Fields

node_id: Option<NodeId>

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

content_offset: Point

motion_context_animated: bool

translated_content_context: bool

translated_content_offset: Point

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

clip_to_bounds: bool

hit_test: Option<HitTestNode>

has_hit_targets: bool

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

cache_policy: CachePolicy

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>

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>

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>

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

pub fn opacity(&self) -> f32

pub fn blend_mode(&self) -> BlendMode

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

pub fn target_content_hash(&self) -> u64

pub fn motion_source_content_hash(&self) -> u64

pub fn effect_hash(&self) -> u64

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.