Struct bevy::animation::prelude::AnimationGraph

pub struct AnimationGraph {
    pub graph: Graph<AnimationGraphNode, ()>,
    pub root: NodeIndex,
}

A graph structure that describes how animation clips are to be blended together.

Applications frequently want to be able to play multiple animations at once and to fine-tune the influence that animations have on a skinned mesh. Bevy uses an animation graph to store this information. Animation graphs are a directed acyclic graph (DAG) that describes how animations are to be weighted and combined together. Every frame, Bevy evaluates the graph from the root and blends the animations together in a bottom-up fashion to produce the final pose.

There are two types of nodes: blend nodes and clip nodes, both of which can have an associated weight. Blend nodes have no associated animation clip and simply affect the weights of all their descendant nodes. Clip nodes specify an animation clip to play. When a graph is created, it starts with only a single blend node, the root node.

For example, consider the following graph:

┌────────────┐                                      
│            │                                      
│    Idle    ├─────────────────────┐                
│            │                     │                
└────────────┘                     │                
                                   │                
┌────────────┐                     │  ┌────────────┐
│            │                     │  │            │
│    Run     ├──┐                  ├──┤    Root    │
│            │  │  ┌────────────┐  │  │            │
└────────────┘  │  │   Blend    │  │  └────────────┘
                ├──┤            ├──┘                
┌────────────┐  │  │    0.5     │                   
│            │  │  └────────────┘                   
│    Walk    ├──┘                                   
│            │                                      
└────────────┘                                      

In this case, assuming that Idle, Run, and Walk are all playing with weight 1.0, the Run and Walk animations will be equally blended together, then their weights will be halved and finally blended with the Idle animation. Thus the weight of Run and Walk are effectively half of the weight of Idle.

Animation graphs are assets and can be serialized to and loaded from RON files. Canonically, such files have an .animgraph.ron extension.

The animation graph implements RFC 51. See that document for more information.

Fields

graph: Graph<AnimationGraphNode, ()>

The petgraph data structure that defines the animation graph.

root: NodeIndex

The index of the root node in the animation graph.

Implementations

impl AnimationGraph

pub fn new() -> AnimationGraph

Creates a new animation graph with a root node and no other nodes.

pub fn from_clip(clip: Handle<AnimationClip>) -> (AnimationGraph, NodeIndex)

A convenience function for creating an AnimationGraph from a single AnimationClip.

The clip will be a direct child of the root with weight 1.0. Both the graph and the index of the added node are returned as a tuple.

pub fn add_clip( &mut self, clip: Handle<AnimationClip>, weight: f32, parent: NodeIndex ) -> NodeIndex

Adds an AnimationClip to the animation graph with the given weight and returns its index.

The animation clip will be the child of the given parent.

pub fn add_clips<'a, I>( &'a mut self, clips: I, weight: f32, parent: NodeIndex ) -> impl Iterator<Item = NodeIndex> + 'a

where I: IntoIterator<Item = Handle<AnimationClip>>, <I as IntoIterator>::IntoIter: 'a,

A convenience method to add multiple AnimationClips to the animation graph.

All of the animation clips will have the same weight and will be parented to the same node.

Returns the indices of the new nodes.

pub fn add_blend(&mut self, weight: f32, parent: NodeIndex) -> NodeIndex

Adds a blend node to the animation graph with the given weight and returns its index.

The blend node will be placed under the supplied parent node. During animation evaluation, the descendants of this blend node will have their weights multiplied by the weight of the blend.

pub fn add_edge(&mut self, from: NodeIndex, to: NodeIndex)

Adds an edge from the edge from to to, making to a child of from.

The behavior is unspecified if adding this produces a cycle in the graph.

pub fn remove_edge(&mut self, from: NodeIndex, to: NodeIndex) -> bool

Removes an edge between from and to if it exists.

Returns true if the edge was successfully removed or false if no such edge existed.

pub fn get(&self, animation: NodeIndex) -> Option<&AnimationGraphNode>

Returns the AnimationGraphNode associated with the given index.

If no node with the given index exists, returns None.

pub fn get_mut( &mut self, animation: NodeIndex ) -> Option<&mut AnimationGraphNode>

Returns a mutable reference to the AnimationGraphNode associated with the given index.

If no node with the given index exists, returns None.

pub fn nodes(&self) -> impl Iterator<Item = NodeIndex>

Returns an iterator over the AnimationGraphNodes in this graph.

pub fn save<W>(&self, writer: &mut W) -> Result<(), AnimationGraphLoadError>

where W: Write,

Serializes the animation graph to the given Writer in RON format.

If writing to a file, it can later be loaded with the AnimationGraphAssetLoader to reconstruct the graph.

Trait Implementations

impl Clone for AnimationGraph

fn clone(&self) -> AnimationGraph

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AnimationGraph

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

Formats the value using the given formatter.

impl Default for AnimationGraph

fn default() -> AnimationGraph

Returns the “default value” for a type.

impl From<AnimationGraph> for SerializedAnimationGraph

fn from(animation_graph: AnimationGraph) -> SerializedAnimationGraph

Converts to this type from the input type.

impl FromReflect for AnimationGraph

where AnimationGraph: Any + Send + Sync, Graph<AnimationGraphNode, ()>: FromReflect + TypePath + RegisterForReflection, NodeIndex: FromReflect + TypePath + RegisterForReflection,

fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<AnimationGraph>

Constructs a concrete instance of Self from a reflected value.

fn take_from_reflect( reflect: Box<dyn Reflect> ) -> Result<Self, Box<dyn Reflect>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl GetTypeRegistration for AnimationGraph

where AnimationGraph: Any + Send + Sync, Graph<AnimationGraphNode, ()>: FromReflect + TypePath + RegisterForReflection, NodeIndex: FromReflect + TypePath + RegisterForReflection,

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type.

impl Index<NodeIndex> for AnimationGraph

type Output = AnimationGraphNode

The returned type after indexing.

fn index( &self, index: NodeIndex ) -> &<AnimationGraph as Index<NodeIndex>>::Output

Performs the indexing (container[index]) operation.

impl IndexMut<NodeIndex> for AnimationGraph

fn index_mut( &mut self, index: NodeIndex ) -> &mut <AnimationGraph as Index<NodeIndex>>::Output

Performs the mutable indexing (container[index]) operation.

impl Reflect for AnimationGraph

where AnimationGraph: Any + Send + Sync, Graph<AnimationGraphNode, ()>: FromReflect + TypePath + RegisterForReflection, NodeIndex: FromReflect + TypePath + RegisterForReflection,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the TypeInfo of the type represented by this value.

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

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &(dyn Any + 'static)

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<AnimationGraph>) -> Box<dyn Reflect>

Casts this type to a boxed reflected value.

fn as_reflect(&self) -> &(dyn Reflect + 'static)

Casts this type to a reflected value.

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

Casts this type to a mutable reflected value.

fn clone_value(&self) -> Box<dyn Reflect>

Clones the value as a Reflect trait object.

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

Performs a type-checked assignment of a reflected value to this value.

fn try_apply( &mut self, value: &(dyn Reflect + 'static) ) -> Result<(), ApplyError>

Tries to apply a reflected value to this value.

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an immutable enumeration of “kinds” of type.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<AnimationGraph>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn reflect_partial_eq(&self, value: &(dyn Reflect + 'static)) -> Option<bool>

Returns a “partial equality” comparison result.

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

Debug formatter for the value.

fn apply(&mut self, value: &(dyn Reflect + 'static))

Applies a reflected value to this value.

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

fn serializable(&self) -> Option<Serializable<'_>>

Returns a serializable version of the value.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Serialize for AnimationGraph

fn serialize<__S>( &self, __serializer: __S ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Struct for AnimationGraph

where AnimationGraph: Any + Send + Sync, Graph<AnimationGraphNode, ()>: FromReflect + TypePath + RegisterForReflection, NodeIndex: FromReflect + TypePath + RegisterForReflection,

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

Returns a reference to the value of the field named name as a &dyn Reflect.

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

Returns a mutable reference to the value of the field named name as a &mut dyn Reflect.

fn field_at(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

Returns a reference to the value of the field with index index as a &dyn Reflect.

fn field_at_mut(&mut self, index: usize) -> Option<&mut (dyn Reflect + 'static)>

Returns a mutable reference to the value of the field with index index as a &mut dyn Reflect.

fn name_at(&self, index: usize) -> Option<&str>

Returns the name of the field with index index.

fn field_len(&self) -> usize

Returns the number of fields in the struct.

fn iter_fields(&self) -> FieldIter<'_>

Returns an iterator over the values of the reflectable fields for this struct.

fn clone_dynamic(&self) -> DynamicStruct

Clones the struct into a DynamicStruct.

impl TypePath for AnimationGraph

where AnimationGraph: Any + Send + Sync,

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

impl Typed for AnimationGraph

where AnimationGraph: Any + Send + Sync, Graph<AnimationGraphNode, ()>: FromReflect + TypePath + RegisterForReflection, NodeIndex: FromReflect + TypePath + RegisterForReflection,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl VisitAssetDependencies for AnimationGraph

fn visit_dependencies(&self, visit: &mut impl FnMut(UntypedAssetId))

impl Asset for AnimationGraph