Struct NodeHandleMap

pub struct NodeHandleMap<N> { /* private fields */ }

A OriginalHandle -> CopyHandle map. It is used to map handles to nodes after copying.

For example, scene nodes have lots of cross references, the simplest cross reference is a handle to parent node, and a set of handles to children nodes. Skinned meshes also store handles to scenes nodes that serve as bones. When you copy a node, you need handles of the copy to point to respective copies. This map allows you to do this.

Mapping could fail if you do a partial copy of some hierarchy that does not have respective copies of nodes that must be remapped. For example you can copy just a skinned mesh, but not its bones - in this case mapping will fail, but you still can use old handles even it does not make any sense.

Implementations

impl<N> NodeHandleMap<N>

where N: Reflect + NameProvider,

pub fn insert( &mut self, original_handle: Handle<N>, copy_handle: Handle<N>, ) -> Option<Handle<N>>

Adds new original -> copy handle mapping.

pub fn map(&self, handle: &mut Handle<N>) -> &Self

Maps a handle to a handle of its origin, or sets it to Handle::NONE if there is no such node. It should be used when you are sure that respective origin exists.

pub fn map_slice<T>(&self, handles: &mut [T]) -> &Self

where T: Deref<Target = Handle<N>> + DerefMut,

Maps each handle in the slice to a handle of its origin, or sets it to Handle::NONE if there is no such node. It should be used when you are sure that respective origin exists.

pub fn try_map(&self, handle: &mut Handle<N>) -> bool

Tries to map a handle to a handle of its origin. If it exists, the method returns true or false otherwise. It should be used when you not sure that respective origin exists.

pub fn try_map_slice<T>(&self, handles: &mut [T]) -> bool

where T: Deref<Target = Handle<N>> + DerefMut,

Tries to map each handle in the slice to a handle of its origin. If it exists, the method returns true or false otherwise. It should be used when you not sure that respective origin exists.

pub fn try_map_silent( &self, inheritable_handle: &mut InheritableVariable<Handle<N>>, ) -> bool

Tries to silently map (without setting modified flag) a templated handle to a handle of its origin. If it exists, the method returns true or false otherwise. It should be used when you not sure that respective origin exists.

pub fn inner(&self) -> &FxHashMap<Handle<N>, Handle<N>>

Returns a shared reference to inner map.

pub fn into_inner(self) -> FxHashMap<Handle<N>, Handle<N>>

Returns inner map.

pub fn remap_handles(&self, node: &mut N, ignored_types: &[TypeId])

Tries to remap handles to nodes in a given entity using reflection. It finds all supported fields recursively (Handle<Node>, Vec<Handle<Node>>, InheritableVariable<Handle<Node>>, InheritableVariable<Vec<Handle<Node>>>) and automatically maps old handles to new.

pub fn remap_inheritable_handles(&self, node: &mut N, ignored_types: &[TypeId])

Trait Implementations

impl<N> Clone for NodeHandleMap<N>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<N> Default for NodeHandleMap<N>

fn default() -> Self

Returns the “default value” for a type.