Struct MachineLayer

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

Layer is a separate state graph. Layers mainly used to animate different parts of humanoid (but not only) characters. For example there could a layer for upper body and a layer for lower body. Upper body layer could contain animations for aiming, melee attacks while lower body layer could contain animations for standing, running, crouching, etc. This gives you an ability to have running character that could aim or melee attack, or crouching and aiming, and so on with any combination. Both layers use the same set of parameters, so a change in a parameter will affect all layers that use it.

Example

use fyrox_animation::{
    machine::{
        State, Transition, PoseNode, MachineLayer,
        Parameter, PlayAnimation, PoseWeight, BlendAnimations, BlendPose
    },
    core::pool::Handle
};
use fyrox_core::pool::ErasedHandle;

// Assume that these are correct handles.
let idle_animation = Handle::default();
let walk_animation = Handle::default();
let aim_animation = Handle::default();

let mut root_layer = MachineLayer::<ErasedHandle>::new();

let aim = root_layer.add_node(PoseNode::PlayAnimation(PlayAnimation::new(aim_animation)));
let walk = root_layer.add_node(PoseNode::PlayAnimation(PlayAnimation::new(walk_animation)));

// Blend two animations together
let blend_aim_walk = root_layer.add_node(PoseNode::BlendAnimations(
    BlendAnimations::new(vec![
        BlendPose::new(PoseWeight::Constant(0.75), aim),
        BlendPose::new(PoseWeight::Constant(0.25), walk)
    ])
));

let walk_state = root_layer.add_state(State::new("Walk", blend_aim_walk));

let idle = root_layer.add_node(PoseNode::PlayAnimation(PlayAnimation::new(idle_animation)));
let idle_state = root_layer.add_state(State::new("Idle", idle));

root_layer.add_transition(Transition::new("Walk->Idle", walk_state, idle_state, 1.0, "WalkToIdle"));
root_layer.add_transition(Transition::new("Idle->Walk", idle_state, walk_state, 1.0, "IdleToWalk"));

Implementations

impl<T> MachineLayer<T>

where T: EntityId,

pub const NAME: &'static str = "name"

pub const WEIGHT: &'static str = "weight"

pub const MASK: &'static str = "mask"

impl<T> MachineLayer<T>

where T: EntityId,

pub fn new() -> MachineLayer<T>

Creates a new machine layer. See examples in MachineLayer docs.

pub fn set_name<S>(&mut self, name: S)

where S: AsRef<str>,

Sets new name for the layer. The name can then be used to find a layer in a parent state machine.

pub fn name(&self) -> &str

Returns a current name of the layer.

pub fn add_node(&mut self, node: PoseNode<T>) -> Handle<PoseNode<T>>

Adds a new node to the layer and returns its handle.

pub fn set_entry_state(&mut self, entry_state: Handle<State<T>>)

Sets new entry state of the layer. Entry state will always be active on the first frame and will remain active until some transition won’t change it.

pub fn entry_state(&self) -> Handle<State<T>>

Returns a handle of current entry state.

pub fn debug(&mut self, state: bool)

Turns on/off the debug mode. Debug mode forces to log all events happening in the layer. For example when a state changes, there will be a respective message in the log.

pub fn add_state(&mut self, state: State<T>) -> Handle<State<T>>

Adds a new state to the layer and returns its handle.

pub fn add_transition( &mut self, transition: Transition<T>, ) -> Handle<Transition<T>>

Adds a new transition to the layer and returns its handle.

pub fn get_state(&self, state: Handle<State<T>>) -> &State<T>

Borrows a state using its handle, panics if the handle is invalid.

pub fn get_transition( &self, transition: Handle<Transition<T>>, ) -> &Transition<T>

Borrows a transition using its handle, panics if the handle is invalid.

pub fn pop_event(&mut self) -> Option<Event<T>>

Tries to extract a next event from the inner event queue. You should use this method if you need to react to layer events somehow. For example you might want to do some action when jump state had become active.

Example

use fyrox_animation::machine::{Event, MachineLayer};
use fyrox_core::pool::ErasedHandle;

let mut layer = MachineLayer::<ErasedHandle>::new();

while let Some(event) = layer.pop_event() {
    match event {
        Event::StateEnter(state_handle) => {
            // Occurs when a state is just entered.
        }
        Event::StateLeave(state_handle) => {
            // Occurs when a state is just left.
        }
        Event::ActiveStateChanged { prev, new } => {
            // Occurs when active state has changed.
        }
        Event::ActiveTransitionChanged(transition_handle) => {
            // Occurs when active transition has changed.
        }
    }
}

pub fn reset(&mut self)

Resets layer state; deactivates all active transitions and sets active state to entry state.

pub fn collect_active_animations_events( &self, params: &ParameterContainer, animations: &AnimationContainer<T>, strategy: AnimationEventCollectionStrategy, ) -> LayerAnimationEventsCollection<T>

Fetches animation events from an active state (or a transition). It could be used to fetch animation events from a layer and receive events only from active state (or transition) without a need to manually fetching the events from a dozens of animations. Additionally, it provides a way of weight filtering of events - you can pick one of AnimationEventCollectionStrategy. For example, AnimationEventCollectionStrategy::MaxWeight could be used to fetch events from the animations with the largest weight (when blending them together).

Important notes

This method does not remove the events from events queue of respective animations, so you need to clear the queue manually each frame.

pub fn node(&self, handle: Handle<PoseNode<T>>) -> &PoseNode<T>

Tries to borrow a node by its handle, panics if the handle is invalid.

pub fn node_mut(&mut self, handle: Handle<PoseNode<T>>) -> &mut PoseNode<T>

Tries to borrow a node by its handle, panics if the handle is invalid.

pub fn nodes(&self) -> &Pool<PoseNode<T>>

Returns a reference to inner node container.

pub fn nodes_mut(&mut self) -> &mut Pool<PoseNode<T>>

Returns a reference to inner node container.

pub fn active_state(&self) -> Handle<State<T>>

Returns a handle of active state. It could be used if you need to perform some action only if some state is active. For example jumping could be done only from idle and run state, and not from crouch and other states.

pub fn active_transition(&self) -> Handle<Transition<T>>

Returns a handle of active transition. It is not empty only while a transition is active (doing blending between states).

pub fn transition(&self, handle: Handle<Transition<T>>) -> &Transition<T>

Tries to borrow a transition using its handle, panics if the handle is invalid.

pub fn transition_mut( &mut self, handle: Handle<Transition<T>>, ) -> &mut Transition<T>

Tries to borrow a transition using its handle, panics if the handle is invalid.

pub fn transitions(&self) -> &Pool<Transition<T>>

Returns a reference to inner transitions container.

pub fn transitions_mut(&mut self) -> &mut Pool<Transition<T>>

Returns a reference to inner transitions container.

pub fn find_transition_by_name_ref<S>( &self, name: S, ) -> Option<(Handle<Transition<T>>, &Transition<T>)>

where S: AsRef<str>,

Tries to find a transition by its name.

pub fn find_transition_by_name_mut<S>( &mut self, name: S, ) -> Option<(Handle<Transition<T>>, &mut Transition<T>)>

where S: AsRef<str>,

Tries to find a transition by its name.

pub fn state(&self, handle: Handle<State<T>>) -> &State<T>

Tries to borrow a state using its handle, panics if the handle is invalid.

pub fn state_mut(&mut self, handle: Handle<State<T>>) -> &mut State<T>

Tries to borrow a state using its handle, panics if the handle is invalid.

pub fn find_state_by_name_ref<S>( &self, name: S, ) -> Option<(Handle<State<T>>, &State<T>)>

where S: AsRef<str>,

Tries to find a state by its name.

pub fn find_state_by_name_mut<S>( &mut self, name: S, ) -> Option<(Handle<State<T>>, &mut State<T>)>

where S: AsRef<str>,

Tries to find a state by its name.

pub fn states(&self) -> &Pool<State<T>>

Returns a reference to inner states container.

pub fn states_mut(&mut self) -> &mut Pool<State<T>>

Returns a reference to inner states container.

pub fn set_weight(&mut self, weight: f32)

Sets layer weight. The weight will be used by parent state machine to blend into final pose. By default the weight is 1.0.

pub fn weight(&self) -> f32

Returns the layer weight.

pub fn set_mask(&mut self, mask: LayerMask<T>) -> LayerMask<T>

Sets new layer mask. See docs of LayerMask for more info about layer masks.

pub fn mask(&self) -> &LayerMask<T>

Returns a reference to current layer mask.

pub fn pose(&self) -> &AnimationPose<T>

Returns final pose of the layer.

pub fn animations_of_state( &self, state: Handle<State<T>>, ) -> impl Iterator<Item = Handle<Animation<T>>>

Returns an iterator over all animations of a given state. It fetches the animations from PoseNode::PlayAnimation nodes and returns them. This method could be useful to extract all animations used by a particular state. For example, to listen for animation events and react to them.

pub fn is_all_animations_of_state_ended( &self, state: Handle<State<T>>, animations: &AnimationContainer<T>, ) -> bool

Returns true if all animations of the given state has ended, false - otherwise.

Trait Implementations

impl<T> Clone for MachineLayer<T>

where T: Clone + EntityId,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for MachineLayer<T>

where T: Debug + EntityId,

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

Formats the value using the given formatter.

impl<T> Default for MachineLayer<T>

where T: Default + EntityId,

fn default() -> MachineLayer<T>

Returns the “default value” for a type.

impl<T> NameProvider for MachineLayer<T>

where T: EntityId,

fn name(&self) -> &str

Returns a reference to the name of the entity.

impl<T> PartialEq for MachineLayer<T>

where T: PartialEq + EntityId,

fn eq(&self, other: &MachineLayer<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 MachineLayer<T>

where T: EntityId, MachineLayer<T>: 'static, String: Reflect, f32: Reflect, LayerMask<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<MachineLayer<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 MachineLayer<T>

where T: EntityId, String: Visit, f32: Visit, LayerMask<T>: Visit, Pool<PoseNode<T>>: Visit, Pool<Transition<T>>: Visit, Pool<State<T>>: Visit, Handle<State<T>>: Visit, Handle<Transition<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> StructuralPartialEq for MachineLayer<T>

where T: EntityId,