Struct webrender::clip::ClipTreeBuilder

pub struct ClipTreeBuilder {
    clip_map: FastHashMap<ClipId, Handle<ClipIntern>>,
    clip_chains: Vec<ClipChain>,
    clip_chain_map: FastHashMap<ClipChainId, usize>,
    clip_stack: Vec<ClipStackEntry>,
    tree: ClipTree,
    clip_handles_buffer: Vec<Handle<ClipIntern>>,
}

Used by the scene builder to build the clip-tree that is part of the built scene.

Fields

clip_map: FastHashMap<ClipId, Handle<ClipIntern>>

Clips defined by the display list

clip_chains: Vec<ClipChain>

Clip-chains defined by the display list

clip_chain_map: FastHashMap<ClipChainId, usize>

clip_stack: Vec<ClipStackEntry>

List of clips pushed/popped by grouping items, such as stacking contexts and iframes

tree: ClipTree

The tree we are building

clip_handles_buffer: Vec<Handle<ClipIntern>>

A temporary buffer stored here to avoid constant heap allocs/frees

Implementations

impl ClipTreeBuilder

pub fn new() -> Self

pub fn begin(&mut self)

pub fn recycle_tree(&mut self, tree: ClipTree)

pub fn define_rect_clip(&mut self, id: ClipId, handle: Handle<ClipIntern>)

Define a new rect clip

pub fn define_rounded_rect_clip( &mut self, id: ClipId, handle: Handle<ClipIntern>, )

Define a new rounded rect clip

pub fn define_image_mask_clip(&mut self, id: ClipId, handle: Handle<ClipIntern>)

Define a image mask clip

pub fn define_clip_chain<I: Iterator<Item = ClipId>>( &mut self, id: ClipChainId, parent: Option<ClipChainId>, clips: I, )

Define a clip-chain

pub fn push_clip_chain( &mut self, clip_chain_id: Option<ClipChainId>, reset_seen: bool, )

Push a clip-chain that will be applied to any prims built prior to next pop

pub fn push_clip_id(&mut self, clip_id: ClipId)

Push a clip-id that will be applied to any prims built prior to next pop

pub fn pop_clip(&mut self)

Pop a clip off the clip_stack, when exiting a grouping item

fn add_clips( clip_chain_index: usize, seen_clips: &mut HashSet<Handle<ClipIntern>, BuildHasherDefault<FxHasher>>, output: &mut Vec<Handle<ClipIntern>>, clip_chains: &[ClipChain], )

Add clips from a given clip-chain to the set of clips for a primitive during clip-set building

pub fn build_clip_set(&mut self, clip_chain_id: ClipChainId) -> ClipNodeId

Main entry point to build a path in the clip-tree for a given primitive

fn has_complex_clips_impl( &self, clip_chain_index: usize, interners: &Interners, ) -> bool

Recursive impl to check if a clip-chain has complex (non-rectangular) clips

pub fn clip_chain_has_complex_clips( &self, clip_chain_id: ClipChainId, interners: &Interners, ) -> bool

Check if a clip-chain has complex (non-rectangular) clips

pub fn clip_node_has_complex_clips( &self, clip_node_id: ClipNodeId, interners: &Interners, ) -> bool

Check if a clip-node has complex (non-rectangular) clips

pub fn finalize(&mut self) -> ClipTree

Finalize building and return the clip-tree

pub fn get_node(&self, id: ClipNodeId) -> &ClipTreeNode

Get a clip node by id

pub fn get_leaf(&self, id: ClipLeafId) -> &ClipTreeLeaf

Get a clip leaf by id

pub fn build_for_tile_cache( &mut self, clip_node_id: ClipNodeId, extra_clips: &[ClipId], ) -> ClipLeafId

Build a clip-leaf for a tile-cache

pub fn build_for_picture(&mut self, clip_node_id: ClipNodeId) -> ClipLeafId

Build a clip-leaf for a picture

pub fn build_for_prim( &mut self, clip_node_id: ClipNodeId, info: &LayoutPrimitiveInfo, extra_clips: &[ClipItemKey], interners: &mut Interners, ) -> ClipLeafId

Build a clip-leaf for a normal primitive

pub fn find_lowest_common_ancestor( &self, node1: ClipNodeId, node2: ClipNodeId, ) -> ClipNodeId

Trait Implementations

impl Serialize for ClipTreeBuilder

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.