Struct GltfTree 

pub struct GltfTree {
    pub tree: Node<MeshItem>,
    pub node_paths: Vec<Option<Vec<usize>>>,
}

Available on crate feature gltf only.

A glTF scene imported as a Node tree, plus the mapping from glTF node indices to index paths in the tree.

glTF addresses nodes structurally by index (animation channels and skin.joints reference the document’s node array), while names are optional display labels that are neither unique nor guaranteed present. This type carries both views: GltfTree::node resolves a document index, and Node::by_id resolves a label.

Fields

tree: Node<MeshItem>

The default scene (or the first scene) as a node tree; the scene’s root nodes are direct children of this synthetic root group.

node_paths: Vec<Option<Vec<usize>>>

glTF node index → index path into GltfTree::tree (see Node::get). None for document nodes that are not part of the imported scene.

Implementations

impl GltfTree

pub fn node( &self, index: usize, ) -> Option<&Transformed<Node<MeshItem>, DAffine3>>

The tree node for glTF node index, or None when the index is out of range or the node is not part of the imported scene.

pub fn node_mut( &mut self, index: usize, ) -> Option<&mut Transformed<Node<MeshItem>, DAffine3>>

Mutable variant of GltfTree::node.

Methods from Deref<Target = Node<MeshItem>>

pub fn is_leaf(&self) -> bool

Whether this node is a bare leaf: a payload with no children.

pub fn is_group(&self) -> bool

Whether this node is a pure frame: no payload, only (possibly empty) children.

pub fn item(&self) -> Option<&I>

The payload carried by this node, if any.

pub fn children(&self) -> &[Transformed<Self, G>]

The placed children.

pub fn first_leaf(&self) -> Option<&I>

The first leaf payload in depth-first order, without composing any transforms. This backs the color/stroke-width getters; None means the tree has no payloads at all.

pub fn get(&self, path: &[usize]) -> Option<&Transformed<Self, G>>

Look up a placement by walking child indices: [i] returns child i (including its pose), [i, j] returns child j of child i’s frame, and so on. Paths must be non-empty — the receiver is the frame itself, not a placement — and None is returned when an index is out of bounds.

pub fn by_id(&self, id: &str) -> Option<&Transformed<Self, G>>

The first placement (depth-first preorder) whose id equals id.

Ids are external labels (SVG ids, glTF node names) and are not guaranteed unique, so duplicates resolve to the preorder-first match; see Node::by_ids for every match and Node::by_id_path for a reusable address. Placements are searched, not the receiver — the receiver is the frame they live in. None when no placement carries the id.

pub fn by_ids(&self, id: &str) -> Vec<&Transformed<Self, G>>

Every placement whose id equals id, in depth-first order.

fn collect_by_id<'a>( &'a self, id: &str, matches: &mut Vec<&'a Transformed<Self, G>>, )

pub fn by_id_path(&self, id: &str) -> Option<Vec<usize>>

The index path (see Node::get) of the first placement in depth-first order whose id equals id. Useful to reuse an address across frames without re-searching.

pub fn leaves(&self) -> Leaves<'_, I, G>

where G: Clone + Into<DAffine3>,

Iterate over flattened leaf payloads with their accumulated world affine, yielding (world_affine, &item) pairs in depth-first order — i.e. painter’s-algorithm draw order.

The world affine composes top-down through every placement’s transform, starting from the identity at the receiver: the receiver is an unplaced frame, so wrapping the tree in [Transformed] places it (see PlacedLeaves). Render extraction composes the same placement into typed frame entries. Implemented with an explicit stack, so deep trees cannot overflow the call stack.

Trait Implementations

impl Deref for GltfTree

type Target = Node<MeshItem>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.