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: GraphicsLayer,
    pub clip_to_bounds: bool,
    pub shadow_clip: Option<Rect>,
    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: LayerRasterCacheHashes,
    pub cache_hashes_valid: bool,
    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: GraphicsLayer

clip_to_bounds: bool

shadow_clip: Option<Rect>

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: LayerRasterCacheHashes

cache_hashes_valid: bool

children: Vec<RenderNode>

Implementations

impl LayerNode

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 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 recompute_raster_cache_hashes(&mut self)

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.