Struct BlendAnimations

pub struct BlendAnimations<T>
where
    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> BlendAnimations<T>

where T: EntityId,

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

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

impl<T> BlendAnimations<T>

where T: EntityId,

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

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> AnimationPoseSource<T> for BlendAnimations<T>

where T: EntityId,

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 for BlendAnimations<T>

where T: Clone + EntityId,

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 for BlendAnimations<T>

where T: Debug + EntityId,

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

Formats the value using the given formatter.

impl<T> Default for BlendAnimations<T>

where T: Default + EntityId,

fn default() -> BlendAnimations<T>

Returns the “default value” for a type.

impl<T> DerefMut for BlendAnimations<T>

where T: EntityId,

fn deref_mut(&mut self) -> &mut <BlendAnimations<T> as Deref>::Target

Mutably dereferences the value.

impl<T> PartialEq for BlendAnimations<T>

where T: PartialEq + EntityId,

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> Reflect for BlendAnimations<T>

where T: EntityId, BlendAnimations<T>: 'static, BasePoseNode<T>: Reflect, Vec<BlendPose<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<BlendAnimations<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 BlendAnimations<T>

where T: EntityId, BasePoseNode<T>: Visit, Vec<BlendPose<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> Deref for BlendAnimations<T>

where T: EntityId,

type Target = BasePoseNode<T>

The resulting type after dereferencing.

fn deref(&self) -> &<BlendAnimations<T> as Deref>::Target

Dereferences the value.

impl<T> StructuralPartialEq for BlendAnimations<T>

where T: EntityId,