Struct LayerMask

pub struct LayerMask<T>
where
    T: EntityId,
{ /* private fields */ }

Layer mask is a sort of blacklist that prevents layer from animating certain nodes. Its main use case is to disable animation on animation layers for specific body parts of humanoid (but not only) characters. The mask holds handles of nodes that will not be animated.

Implementations

impl<T> LayerMask<T>

where T: EntityId,

pub const EXCLUDED_BONES: &'static str = "excluded_bones"

impl<T> LayerMask<T>

where T: EntityId,

pub fn merge(&mut self, other: LayerMask<T>)

Merges a given layer mask in the current mask, handles will be automatically de-duplicated.

pub fn add(&mut self, node: T)

Adds a node handle to the mask. You can add as many nodes here as you want and pretty much any handle, but you should keep handles only to nodes are affected by your animations. Otherwise you’ll just make the inner container bigger and it will degrade in performance.

Performance

The method has O(log(n)) complexity, which means it is very fast for most use cases.

pub fn remove(&mut self, node: T)

Removes a given node handle from the mask (if any).

Performance

The method has O(log(n)) complexity, which means it is very fast for most use cases.

pub fn contains(&self, node: T) -> bool

Checks if the mask contains a given node handle or not.

Performance

The method has O(log(n)) complexity, which means it is very fast for most use cases.

pub fn should_animate(&self, node: T) -> bool

Check if a node should be animated or not.

Performance

The method has O(log(n)) complexity, which means it is very fast for most use cases.

pub fn inner(&self) -> &Vec<T>

Return a reference to inner container. There’s only non-mutable version because inner container must always be sorted.

pub fn into_inner(self) -> Vec<T>

Converts the mask into inner container.

Trait Implementations

impl<T> Clone for LayerMask<T>

where T: Clone + EntityId,

fn clone(&self) -> LayerMask<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for LayerMask<T>

where T: Debug + EntityId,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T> Default for LayerMask<T>

where T: Default + EntityId,

fn default() -> LayerMask<T>

Returns the “default value” for a type.

impl<T> From<Vec<T>> for LayerMask<T>

where T: EntityId,

fn from(excluded_bones: Vec<T>) -> LayerMask<T>

Converts to this type from the input type.

impl<T> PartialEq for LayerMask<T>

where T: PartialEq + EntityId,

fn eq(&self, other: &LayerMask<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Reflect for LayerMask<T>

where T: EntityId, LayerMask<T>: 'static, Vec<T>: Reflect,

fn source_path() -> &'static str

fn type_name(&self) -> &'static str

fn doc(&self) -> &'static str

fn assembly_name(&self) -> &'static str

Returns a parent assembly name of the type that implements this trait. WARNING: You should use proc-macro (#[derive(Reflect)]) to ensure that this method will return correct assembly name. In other words - there’s no guarantee, that any implementation other than proc-macro will return a correct name of the assembly. Alternatively, you can use env!("CARGO_PKG_NAME") as an implementation.

fn type_assembly_name() -> &'static str

Returns a parent assembly name of the type that implements this trait. WARNING: You should use proc-macro (#[derive(Reflect)]) to ensure that this method will return correct assembly name. In other words - there’s no guarantee, that any implementation other than proc-macro will return a correct name of the assembly. Alternatively, you can use env!("CARGO_PKG_NAME") as an implementation.

fn fields_info(&self, func: &mut dyn FnMut(&[FieldInfo<'_, '_>]))

fn into_any(self: Box<LayerMask<T>>) -> Box<dyn Any>

fn set( &mut self, value: Box<dyn Reflect>, ) -> Result<Box<dyn Reflect>, Box<dyn Reflect>>

fn as_any(&self, func: &mut dyn FnMut(&(dyn Any + 'static)))

fn as_any_mut(&mut self, func: &mut dyn FnMut(&mut (dyn Any + 'static)))

fn as_reflect(&self, func: &mut dyn FnMut(&(dyn Reflect + 'static)))

fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut (dyn Reflect + 'static)))

fn fields(&self, func: &mut dyn FnMut(&[&(dyn Reflect + 'static)]))

fn fields_mut( &mut self, func: &mut dyn FnMut(&mut [&mut (dyn Reflect + 'static)]), )

fn field( &self, name: &str, func: &mut dyn FnMut(Option<&(dyn Reflect + 'static)>), )

fn field_mut( &mut self, name: &str, func: &mut dyn FnMut(Option<&mut (dyn Reflect + 'static)>), )

fn set_field( &mut self, field: &str, value: Box<dyn Reflect>, func: &mut dyn FnMut(Result<Box<dyn Reflect>, Box<dyn Reflect>>), )

Calls user method specified with #[reflect(setter = ..)] or falls back to Reflect::field_mut

fn as_array(&self, func: &mut dyn FnMut(Option<&(dyn ReflectArray + 'static)>))

fn as_array_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectArray + 'static)>), )

fn as_list(&self, func: &mut dyn FnMut(Option<&(dyn ReflectList + 'static)>))

fn as_list_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectList + 'static)>), )

fn as_inheritable_variable( &self, func: &mut dyn FnMut(Option<&(dyn ReflectInheritableVariable + 'static)>), )

fn as_inheritable_variable_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectInheritableVariable + 'static)>), )

fn as_hash_map( &self, func: &mut dyn FnMut(Option<&(dyn ReflectHashMap + 'static)>), )

fn as_hash_map_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectHashMap + 'static)>), )

impl<T> Visit for LayerMask<T>

where T: EntityId, Vec<T>: Visit,

fn visit(&mut self, name: &str, visitor: &mut Visitor) -> Result<(), VisitError>

Read or write this value, depending on whether Visitor::is_reading() is true or false.

impl<T> Eq for LayerMask<T>

where T: Eq + EntityId,

impl<T> StructuralPartialEq for LayerMask<T>

where T: EntityId,