Struct BlendAnimations 

pub struct BlendAnimations<T: EntityId> {
    pub base: BasePoseNode<T>,
    pub pose_sources: Vec<BlendPose<T>>,
    pub output_pose: RefCell<AnimationPose<T>>,
}

Animation blend node. It takes multiple input poses and mixes them together into single pose with specified weights. Could be used to mix hit and run animations for example - once your character got hit, you set some significant weight for hit animation (0.8 for example) and lower weight for run animation (0.2) and it will look like your character got wounded while it still running (probably you should decrease speed here too). Weights can be parametrized, which means that you can dynamically change them in runtime. In our example we can decrease weight of hit animation over time and increase weight of run animation, so character will recover from his wounds.

Fields

base: BasePoseNode<T>

Base node.

pose_sources: Vec<BlendPose<T>>

A list of pose sources. See BlendPose docs for more info.

output_pose: RefCell<AnimationPose<T>>

Output pose of the node, contains final result of blending all input poses.

Implementations

impl<T: EntityId> BlendAnimations<T>

pub const BASE: &'static str = "base"

pub const POSE_SOURCES: &'static str = "pose_sources"

impl<T: EntityId> BlendAnimations<T>

pub fn new(poses: Vec<BlendPose<T>>) -> Self

Creates new animation blend node with given poses.

pub fn children(&self) -> Vec<Handle<PoseNode<T>>>

Returns a set of handles to children pose nodes.

Methods from Deref<Target = BasePoseNode<T>>

pub const POSITION: &'static str = "position"

Trait Implementations

impl<T: EntityId> AnimationPoseSource<T> for BlendAnimations<T>

fn eval_pose( &self, nodes: &Pool<PoseNode<T>>, params: &ParameterContainer, animations: &AnimationContainer<T>, dt: f32, ) -> Ref<'_, AnimationPose<T>>

Evaluates animation pose and returns a reference to it.

fn pose(&self) -> Ref<'_, AnimationPose<T>>

Returns a reference to inner pose of a node.

fn collect_animation_events( &self, nodes: &Pool<PoseNode<T>>, params: &ParameterContainer, animations: &AnimationContainer<T>, strategy: AnimationEventCollectionStrategy, ) -> Vec<(Handle<Animation<T>>, AnimationEvent)>

Collects animation events from internals.

impl<T: Clone + EntityId> Clone for BlendAnimations<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + EntityId> Debug for BlendAnimations<T>

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

Formats the value using the given formatter.

impl<T: Default + EntityId> Default for BlendAnimations<T>

fn default() -> BlendAnimations<T>

Returns the “default value” for a type.

impl<T: EntityId> Deref for BlendAnimations<T>

type Target = BasePoseNode<T>

The resulting type after dereferencing.

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

Dereferences the value.

impl<T: EntityId> DerefMut for BlendAnimations<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T: PartialEq + EntityId> PartialEq for BlendAnimations<T>

fn eq(&self, other: &BlendAnimations<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: EntityId> Reflect for BlendAnimations<T>

where Self: 'static,

fn source_path() -> &'static str

fn try_clone_box(&self) -> Option<Box<dyn Reflect>>

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

fn derived_types() -> &'static [TypeId]

fn query_derived_types(&self) -> &'static [TypeId]

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_ref(&self, func: &mut dyn FnMut(&[FieldRef<'_, '_>]))

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

fn into_any(self: Box<Self>) -> 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))

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

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

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

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

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

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 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)>), )

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

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

impl<T: EntityId> Visit for BlendAnimations<T>

fn visit(&mut self, name: &str, visitor: &mut Visitor) -> VisitResult

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

impl<T: EntityId> StructuralPartialEq for BlendAnimations<T>