From 17f630c360f07d1567662272c70786daee1aef81 Mon Sep 17 00:00:00 2001
From: Sirmadeira <nicolaumori@gmail.com>
Date: Sat, 26 Apr 2025 20:32:15 -0300
Subject: [PATCH 01/25] Making so animation transition is non reliant on
 animation players

---
 crates/bevy_animation/src/transition.rs | 101 ++++++------------------
 1 file changed, 22 insertions(+), 79 deletions(-)

diff --git a/crates/bevy_animation/src/transition.rs b/crates/bevy_animation/src/transition.rs
index 494855970441d..1148fad4319fb 100644
--- a/crates/bevy_animation/src/transition.rs
+++ b/crates/bevy_animation/src/transition.rs
@@ -3,6 +3,7 @@
 //! Please note that this is an unstable temporary API. It may be replaced by a
 //! state machine in the future.
 
+use bevy_derive::{Deref, DerefMut};
 use bevy_ecs::{
     component::Component,
     reflect::ReflectComponent,
@@ -12,7 +13,7 @@ use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 use bevy_time::Time;
 use core::time::Duration;
 
-use crate::{graph::AnimationNodeIndex, ActiveAnimation, AnimationPlayer};
+use crate::{graph::{AnimationGraph, AnimationGraphNode, AnimationNodeIndex},  AnimationPlayer};
 
 /// Manages fade-out of animation blend factors, allowing for smooth transitions
 /// between animations.
@@ -21,89 +22,45 @@ use crate::{graph::AnimationNodeIndex, ActiveAnimation, AnimationPlayer};
 /// [`AnimationPlayer`] and [`AnimationGraphHandle`](crate::AnimationGraphHandle). It'll take
 /// responsibility for adjusting the weight on the [`ActiveAnimation`] in order
 /// to fade out animations smoothly.
-///
-/// When using an [`AnimationTransitions`] component, you should play all
-/// animations through the [`AnimationTransitions::play`] method, rather than by
-/// directly manipulating the [`AnimationPlayer`]. Playing animations through
-/// the [`AnimationPlayer`] directly will cause the [`AnimationTransitions`]
-/// component to get confused about which animation is the "main" animation, and
-/// transitions will usually be incorrect as a result.
-#[derive(Component, Default, Reflect)]
+#[derive(Component, Default, Reflect,Deref,DerefMut,Clone)]
 #[reflect(Component, Default, Clone)]
-pub struct AnimationTransitions {
-    main_animation: Option<AnimationNodeIndex>,
-    transitions: Vec<AnimationTransition>,
-}
+pub struct AnimationTransitions (Vec<AnimationTransition>);
 
-// This is needed since `#[derive(Clone)]` does not generate optimized `clone_from`.
-impl Clone for AnimationTransitions {
-    fn clone(&self) -> Self {
-        Self {
-            main_animation: self.main_animation,
-            transitions: self.transitions.clone(),
-        }
-    }
-
-    fn clone_from(&mut self, source: &Self) {
-        self.main_animation = source.main_animation;
-        self.transitions.clone_from(&source.transitions);
-    }
-}
 
 /// An animation that is being faded out as part of a transition
-#[derive(Debug, Clone, Copy, Reflect)]
+#[derive(Debug, Clone,  Reflect)]
 #[reflect(Clone)]
 pub struct AnimationTransition {
     /// The current weight. Starts at 1.0 and goes to 0.0 during the fade-out.
     current_weight: f32,
     /// How much to decrease `current_weight` per second
     weight_decline_per_sec: f32,
-    /// The animation that is being faded out
-    animation: AnimationNodeIndex,
+    /// The animation that is beind fade out
+    old_node:AnimationGraphNode,
+    /// The animation that is gaining weight
+    new_node: AnimationGraphNode,
 }
 
 impl AnimationTransitions {
-    /// Creates a new [`AnimationTransitions`] component, ready to be added to
-    /// an entity with an [`AnimationPlayer`].
-    pub fn new() -> AnimationTransitions {
-        AnimationTransitions::default()
-    }
-
     /// Plays a new animation on the given [`AnimationPlayer`], fading out any
     /// existing animations that were already playing over the
     /// `transition_duration`.
     ///
     /// Pass [`Duration::ZERO`] to instantly switch to a new animation, avoiding
     /// any transition.
-    pub fn play<'p>(
+    pub fn transition(
         &mut self,
-        player: &'p mut AnimationPlayer,
+        graph: & mut AnimationGraph,
+        old_animation: AnimationNodeIndex,
         new_animation: AnimationNodeIndex,
         transition_duration: Duration,
-    ) -> &'p mut ActiveAnimation {
-        if let Some(old_animation_index) = self.main_animation.replace(new_animation) {
-            if let Some(old_animation) = player.animation_mut(old_animation_index) {
-                if !old_animation.is_paused() {
-                    self.transitions.push(AnimationTransition {
-                        current_weight: old_animation.weight,
-                        weight_decline_per_sec: 1.0 / transition_duration.as_secs_f32(),
-                        animation: old_animation_index,
-                    });
-                }
-            }
-        }
+    ) {
+        let old_node = graph.get(old_animation).unwrap().clone();
+        let new_node = graph.get(new_animation).unwrap().clone();
 
-        // If already transitioning away from this animation, cancel the transition.
-        // Otherwise the transition ending would incorrectly stop the new animation.
-        self.transitions
-            .retain(|transition| transition.animation != new_animation);
+        self.push(AnimationTransition { current_weight: old_node.weight, weight_decline_per_sec: 1.0 / transition_duration.as_secs_f32(), old_node,new_node });
 
-        player.start(new_animation)
-    }
 
-    /// Obtain the currently playing main animation.
-    pub fn get_main_animation(&self) -> Option<AnimationNodeIndex> {
-        self.main_animation
     }
 }
 
@@ -121,24 +78,14 @@ pub fn advance_transitions(
     for (mut animation_transitions, mut player) in query.iter_mut() {
         let mut remaining_weight = 1.0;
 
-        for transition in &mut animation_transitions.transitions.iter_mut().rev() {
+        for transition in &mut animation_transitions.iter_mut().rev() {
             // Decrease weight.
             transition.current_weight = (transition.current_weight
                 - transition.weight_decline_per_sec * time.delta_secs())
             .max(0.0);
 
-            // Update weight.
-            let Some(ref mut animation) = player.animation_mut(transition.animation) else {
-                continue;
-            };
-            animation.weight = transition.current_weight * remaining_weight;
-            remaining_weight -= animation.weight;
-        }
-
-        if let Some(main_animation_index) = animation_transitions.main_animation {
-            if let Some(ref mut animation) = player.animation_mut(main_animation_index) {
-                animation.weight = remaining_weight;
-            }
+            transition.old_node.weight = transition.current_weight * remaining_weight;
+            remaining_weight -= transition.old_node.weight;
         }
     }
 }
@@ -148,13 +95,9 @@ pub fn advance_transitions(
 pub fn expire_completed_transitions(
     mut query: Query<(&mut AnimationTransitions, &mut AnimationPlayer)>,
 ) {
-    for (mut animation_transitions, mut player) in query.iter_mut() {
-        animation_transitions.transitions.retain(|transition| {
-            let expire = transition.current_weight <= 0.0;
-            if expire {
-                player.stop(transition.animation);
-            }
-            !expire
+    for (mut animation_transitions, _player) in query.iter_mut() {
+        animation_transitions.retain(|transition| {
+            transition.current_weight > 0.0
         });
     }
 }

From 0ff35438c4229cc836559cf3e8623ac34144e166 Mon Sep 17 00:00:00 2001
From: Sirmadeira <nicolaumori@gmail.com>
Date: Sat, 26 Apr 2025 20:33:21 -0300
Subject: [PATCH 02/25] Format

---
 crates/bevy_animation/src/transition.rs | 29 ++++++++++++++-----------
 1 file changed, 16 insertions(+), 13 deletions(-)

diff --git a/crates/bevy_animation/src/transition.rs b/crates/bevy_animation/src/transition.rs
index 1148fad4319fb..976aac27f73c8 100644
--- a/crates/bevy_animation/src/transition.rs
+++ b/crates/bevy_animation/src/transition.rs
@@ -13,7 +13,10 @@ use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 use bevy_time::Time;
 use core::time::Duration;
 
-use crate::{graph::{AnimationGraph, AnimationGraphNode, AnimationNodeIndex},  AnimationPlayer};
+use crate::{
+    graph::{AnimationGraph, AnimationGraphNode, AnimationNodeIndex},
+    AnimationPlayer,
+};
 
 /// Manages fade-out of animation blend factors, allowing for smooth transitions
 /// between animations.
@@ -22,13 +25,12 @@ use crate::{graph::{AnimationGraph, AnimationGraphNode, AnimationNodeIndex},  An
 /// [`AnimationPlayer`] and [`AnimationGraphHandle`](crate::AnimationGraphHandle). It'll take
 /// responsibility for adjusting the weight on the [`ActiveAnimation`] in order
 /// to fade out animations smoothly.
-#[derive(Component, Default, Reflect,Deref,DerefMut,Clone)]
+#[derive(Component, Default, Reflect, Deref, DerefMut, Clone)]
 #[reflect(Component, Default, Clone)]
-pub struct AnimationTransitions (Vec<AnimationTransition>);
-
+pub struct AnimationTransitions(Vec<AnimationTransition>);
 
 /// An animation that is being faded out as part of a transition
-#[derive(Debug, Clone,  Reflect)]
+#[derive(Debug, Clone, Reflect)]
 #[reflect(Clone)]
 pub struct AnimationTransition {
     /// The current weight. Starts at 1.0 and goes to 0.0 during the fade-out.
@@ -36,7 +38,7 @@ pub struct AnimationTransition {
     /// How much to decrease `current_weight` per second
     weight_decline_per_sec: f32,
     /// The animation that is beind fade out
-    old_node:AnimationGraphNode,
+    old_node: AnimationGraphNode,
     /// The animation that is gaining weight
     new_node: AnimationGraphNode,
 }
@@ -50,7 +52,7 @@ impl AnimationTransitions {
     /// any transition.
     pub fn transition(
         &mut self,
-        graph: & mut AnimationGraph,
+        graph: &mut AnimationGraph,
         old_animation: AnimationNodeIndex,
         new_animation: AnimationNodeIndex,
         transition_duration: Duration,
@@ -58,9 +60,12 @@ impl AnimationTransitions {
         let old_node = graph.get(old_animation).unwrap().clone();
         let new_node = graph.get(new_animation).unwrap().clone();
 
-        self.push(AnimationTransition { current_weight: old_node.weight, weight_decline_per_sec: 1.0 / transition_duration.as_secs_f32(), old_node,new_node });
-
-
+        self.push(AnimationTransition {
+            current_weight: old_node.weight,
+            weight_decline_per_sec: 1.0 / transition_duration.as_secs_f32(),
+            old_node,
+            new_node,
+        });
     }
 }
 
@@ -96,8 +101,6 @@ pub fn expire_completed_transitions(
     mut query: Query<(&mut AnimationTransitions, &mut AnimationPlayer)>,
 ) {
     for (mut animation_transitions, _player) in query.iter_mut() {
-        animation_transitions.retain(|transition| {
-            transition.current_weight > 0.0
-        });
+        animation_transitions.retain(|transition| transition.current_weight > 0.0);
     }
 }

From debc131360e5b2fb87918938619d7f3f57b72cf9 Mon Sep 17 00:00:00 2001
From: Sirmadeira <nicolaumori@gmail.com>
Date: Mon, 28 Apr 2025 08:52:16 -0300
Subject: [PATCH 03/25] Chore: Node transitions

---
 crates/bevy_animation/src/lib.rs        |  90 +++++++--------
 crates/bevy_animation/src/transition.rs | 146 +++++++++++++-----------
 2 files changed, 122 insertions(+), 114 deletions(-)

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 43ea343aa311c..210c6ac834b1a 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -24,7 +24,7 @@ use core::{
     iter, slice,
 };
 use graph::AnimationNodeType;
-use prelude::AnimationCurveEvaluator;
+use prelude::{handle_node_transition, AnimationCurveEvaluator};
 
 use crate::{
     graph::{AnimationGraphHandle, ThreadedAnimationGraphs},
@@ -60,10 +60,53 @@ pub mod prelude {
 use crate::{
     animation_curves::AnimationCurve,
     graph::{AnimationGraph, AnimationGraphAssetLoader, AnimationNodeIndex},
-    transition::{advance_transitions, expire_completed_transitions, AnimationTransitions},
+    transition::{expire_completed_transitions, AnimationTransitions},
 };
 use alloc::sync::Arc;
 
+/// Adds animation support to an app
+#[derive(Default)]
+pub struct AnimationPlugin;
+
+impl Plugin for AnimationPlugin {
+    fn build(&self, app: &mut App) {
+        app.init_asset::<AnimationClip>()
+            .init_asset::<AnimationGraph>()
+            .init_asset_loader::<AnimationGraphAssetLoader>()
+            .register_asset_reflect::<AnimationClip>()
+            .register_asset_reflect::<AnimationGraph>()
+            .register_type::<AnimationPlayer>()
+            .register_type::<AnimationTarget>()
+            .register_type::<AnimationTransitions>()
+            .register_type::<AnimationGraphHandle>()
+            .register_type::<NodeIndex>()
+            .register_type::<ThreadedAnimationGraphs>()
+            .init_resource::<ThreadedAnimationGraphs>()
+            .add_systems(
+                PostUpdate,
+                (
+                    graph::thread_animation_graphs.before(AssetEvents),
+                    handle_node_transition,
+                    advance_animations,
+                    // TODO: `animate_targets` can animate anything, so
+                    // ambiguity testing currently considers it ambiguous with
+                    // every other system in `PostUpdate`. We may want to move
+                    // it to its own system set after `Update` but before
+                    // `PostUpdate`. For now, we just disable ambiguity testing
+                    // for this system.
+                    animate_targets
+                        .before(bevy_render::mesh::inherit_weights)
+                        .ambiguous_with_all(),
+                    trigger_untargeted_animation_events,
+                    expire_completed_transitions,
+                )
+                    .chain()
+                    .in_set(Animation)
+                    .before(TransformSystem::TransformPropagate),
+            );
+    }
+}
+
 /// The [UUID namespace] of animation targets (e.g. bones).
 ///
 /// [UUID namespace]: https://en.wikipedia.org/wiki/Universally_unique_identifier#Versions_3_and_5_(namespace_name-based)
@@ -1223,49 +1266,6 @@ pub fn animate_targets(
         });
 }
 
-/// Adds animation support to an app
-#[derive(Default)]
-pub struct AnimationPlugin;
-
-impl Plugin for AnimationPlugin {
-    fn build(&self, app: &mut App) {
-        app.init_asset::<AnimationClip>()
-            .init_asset::<AnimationGraph>()
-            .init_asset_loader::<AnimationGraphAssetLoader>()
-            .register_asset_reflect::<AnimationClip>()
-            .register_asset_reflect::<AnimationGraph>()
-            .register_type::<AnimationPlayer>()
-            .register_type::<AnimationTarget>()
-            .register_type::<AnimationTransitions>()
-            .register_type::<AnimationGraphHandle>()
-            .register_type::<NodeIndex>()
-            .register_type::<ThreadedAnimationGraphs>()
-            .init_resource::<ThreadedAnimationGraphs>()
-            .add_systems(
-                PostUpdate,
-                (
-                    graph::thread_animation_graphs.before(AssetEvents),
-                    advance_transitions,
-                    advance_animations,
-                    // TODO: `animate_targets` can animate anything, so
-                    // ambiguity testing currently considers it ambiguous with
-                    // every other system in `PostUpdate`. We may want to move
-                    // it to its own system set after `Update` but before
-                    // `PostUpdate`. For now, we just disable ambiguity testing
-                    // for this system.
-                    animate_targets
-                        .before(bevy_render::mesh::inherit_weights)
-                        .ambiguous_with_all(),
-                    trigger_untargeted_animation_events,
-                    expire_completed_transitions,
-                )
-                    .chain()
-                    .in_set(Animation)
-                    .before(TransformSystem::TransformPropagate),
-            );
-    }
-}
-
 impl AnimationTargetId {
     /// Creates a new [`AnimationTargetId`] by hashing a list of names.
     ///
diff --git a/crates/bevy_animation/src/transition.rs b/crates/bevy_animation/src/transition.rs
index 976aac27f73c8..d990d25d17053 100644
--- a/crates/bevy_animation/src/transition.rs
+++ b/crates/bevy_animation/src/transition.rs
@@ -1,106 +1,114 @@
-//! Animation transitions.
-//!
-//! Please note that this is an unstable temporary API. It may be replaced by a
-//! state machine in the future.
-
+use bevy_asset::{Assets, Handle};
 use bevy_derive::{Deref, DerefMut};
 use bevy_ecs::{
     component::Component,
     reflect::ReflectComponent,
-    system::{Query, Res},
+    system::{Query, Res, ResMut},
 };
 use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 use bevy_time::Time;
 use core::time::Duration;
 
-use crate::{
-    graph::{AnimationGraph, AnimationGraphNode, AnimationNodeIndex},
-    AnimationPlayer,
-};
+use crate::graph::{AnimationGraph, AnimationNodeIndex};
 
-/// Manages fade-out of animation blend factors, allowing for smooth transitions
-/// between animations.
-///
-/// To use this component, place it on the same entity as the
-/// [`AnimationPlayer`] and [`AnimationGraphHandle`](crate::AnimationGraphHandle). It'll take
-/// responsibility for adjusting the weight on the [`ActiveAnimation`] in order
-/// to fade out animations smoothly.
-#[derive(Component, Default, Reflect, Deref, DerefMut, Clone)]
-#[reflect(Component, Default, Clone)]
+/// Component responsible for making transitions among two given nodes/states. 
+/// He is also capable of making
+#[derive(Component, Default, Reflect, Deref, DerefMut)]
+#[reflect(Component, Default)]
 pub struct AnimationTransitions(Vec<AnimationTransition>);
 
 /// An animation that is being faded out as part of a transition
-#[derive(Debug, Clone, Reflect)]
-#[reflect(Clone)]
+#[derive(Debug, Reflect)]
 pub struct AnimationTransition {
-    /// The current weight. Starts at 1.0 and goes to 0.0 during the fade-out.
-    current_weight: f32,
-    /// How much to decrease `current_weight` per second
     weight_decline_per_sec: f32,
-    /// The animation that is beind fade out
-    old_node: AnimationGraphNode,
-    /// The animation that is gaining weight
-    new_node: AnimationGraphNode,
+    old_node: AnimationNodeIndex,
+    new_node: AnimationNodeIndex,
+    graph: Handle<AnimationGraph>,
+    weight: f32,
 }
-
 impl AnimationTransitions {
-    /// Plays a new animation on the given [`AnimationPlayer`], fading out any
-    /// existing animations that were already playing over the
-    /// `transition_duration`.
-    ///
-    /// Pass [`Duration::ZERO`] to instantly switch to a new animation, avoiding
-    /// any transition.
-    pub fn transition(
+    /// Transition between one graph node to another according to the given duration
+    pub fn transition_nodes(
         &mut self,
-        graph: &mut AnimationGraph,
-        old_animation: AnimationNodeIndex,
-        new_animation: AnimationNodeIndex,
-        transition_duration: Duration,
+        graph: Handle<AnimationGraph>,
+        old_node: AnimationNodeIndex,
+        new_node: AnimationNodeIndex,
+        transition: Duration,
     ) {
-        let old_node = graph.get(old_animation).unwrap().clone();
-        let new_node = graph.get(new_animation).unwrap().clone();
-
         self.push(AnimationTransition {
-            current_weight: old_node.weight,
-            weight_decline_per_sec: 1.0 / transition_duration.as_secs_f32(),
+            weight_decline_per_sec: 1.0 / transition.as_secs_f32(),
             old_node,
             new_node,
+            graph,
+            weight: 1.0,
         });
     }
+
+    // /// Plays a new animation on the given [`AnimationPlayer`], fading out any
+    // /// existing animations that were already playing over the
+    // /// `transition_duration`.
+    // ///
+    // /// Pass [`Duration::ZERO`] to instantly switch to a new animation, avoiding
+    // /// any transition.
+    // pub fn play<'p>(
+    //     &mut self,
+    //     player: &'p mut AnimationPlayer,
+    //     new_animation: AnimationNodeIndex,
+    //     transition_duration: Duration,
+    // ) -> &'p mut ActiveAnimation {
+    //     if let Some(old_animation_index) = self.main_animation.replace(new_animation) {
+    //         if let Some(old_animation) = player.animation_mut(old_animation_index) {
+    //             if !old_animation.is_paused() {
+    //                 self.transitions.push(AnimationTransition {
+    //                     current_weight: old_animation.weight,
+    //                     weight_decline_per_sec: 1.0 / transition_duration.as_secs_f32(),
+    //                     animation: old_animation_index,
+    //                 });
+    //             }
+    //         }
+    //     }
+
+    //     // If already transitioning away from this animation, cancel the transition.
+    //     // Otherwise the transition ending would incorrectly stop the new animation.
+    //     self.transitions
+    //         .retain(|transition| transition.animation != new_animation);
+
+    //     player.start(new_animation)
+    // }
 }
 
-/// A system that alters the weight of currently-playing transitions based on
-/// the current time and decline amount.
-pub fn advance_transitions(
-    mut query: Query<(&mut AnimationTransitions, &mut AnimationPlayer)>,
+/// System responsible for handling [`AnimationTransitions`] transitioning nodes among each other. According to the pacing defined by user.
+pub fn handle_node_transition(
+    mut query: Query<&mut AnimationTransitions>,
+    mut assets_graph: ResMut<Assets<AnimationGraph>>,
     time: Res<Time>,
 ) {
-    // We use a "greedy layer" system here. The top layer (most recent
-    // transition) gets as much as weight as it wants, and the remaining amount
-    // is divided between all the other layers, eventually culminating in the
-    // currently-playing animation receiving whatever's left. This results in a
-    // nicely normalized weight.
-    for (mut animation_transitions, mut player) in query.iter_mut() {
-        let mut remaining_weight = 1.0;
+    for mut animation_transitions in query.iter_mut() {
+        for transition in animation_transitions.iter_mut() {
+            let animation_graph = assets_graph.get_mut(&transition.graph).unwrap();
 
-        for transition in &mut animation_transitions.iter_mut().rev() {
-            // Decrease weight.
-            transition.current_weight = (transition.current_weight
-                - transition.weight_decline_per_sec * time.delta_secs())
-            .max(0.0);
+            if let Some(old_node) = animation_graph.get_mut(transition.old_node) {
+                if transition.weight.eq(&1.0) {
+                    old_node.weight = transition.weight;
+                }
+                old_node.weight -= transition.weight_decline_per_sec * time.delta_secs().max(0.0);
+            }
+            if let Some(new_node) = animation_graph.get_mut(transition.new_node) {
+                if transition.weight.eq(&1.0) {
+                    new_node.weight = 0.0;
+                }
+                new_node.weight += transition.weight_decline_per_sec * time.delta_secs().min(1.0);
+            }
 
-            transition.old_node.weight = transition.current_weight * remaining_weight;
-            remaining_weight -= transition.old_node.weight;
+            transition.weight -= transition.weight_decline_per_sec * time.delta_secs().max(0.0);
         }
     }
 }
 
-/// A system that removed transitions that have completed from the
+/// A system that removes transitions that have completed from the
 /// [`AnimationTransitions`] object.
-pub fn expire_completed_transitions(
-    mut query: Query<(&mut AnimationTransitions, &mut AnimationPlayer)>,
-) {
-    for (mut animation_transitions, _player) in query.iter_mut() {
-        animation_transitions.retain(|transition| transition.current_weight > 0.0);
+pub fn expire_completed_transitions(mut query: Query<&mut AnimationTransitions>) {
+    for mut animation_transitions in query.iter_mut() {
+        animation_transitions.retain(|transition| transition.weight <= 0.0);
     }
 }

From f450a3c61e47fbb146f5aae5ceb50efbab7d7304 Mon Sep 17 00:00:00 2001
From: Sirmadeira <nicolaumori@gmail.com>
Date: Mon, 28 Apr 2025 13:17:47 -0300
Subject: [PATCH 04/25] Structuring

---
 crates/bevy_animation/src/transition.rs | 81 +++++++++++++++----------
 1 file changed, 48 insertions(+), 33 deletions(-)

diff --git a/crates/bevy_animation/src/transition.rs b/crates/bevy_animation/src/transition.rs
index d990d25d17053..89886ca371ee5 100644
--- a/crates/bevy_animation/src/transition.rs
+++ b/crates/bevy_animation/src/transition.rs
@@ -11,22 +11,42 @@ use core::time::Duration;
 
 use crate::graph::{AnimationGraph, AnimationNodeIndex};
 
-/// Component responsible for making transitions among two given nodes/states. 
-/// He is also capable of making
+/// Component responsible for managing transitions between N given nodes or states.
+/// It can handle multiple transitions and supports scalable flow-based animation management.
 #[derive(Component, Default, Reflect, Deref, DerefMut)]
 #[reflect(Component, Default)]
-pub struct AnimationTransitions(Vec<AnimationTransition>);
+pub struct AnimationTransitions {
+    #[deref]
+    transitions: Vec<AnimationTransition>,
+    /// Flows represent sequences of animation states.
+    /// For example, in cases such as masked or additive animation scenarios, a user can easily define transitions between previous and new states.
+    /// This concept is similar to "main" animations but is designed to scale across multiple animation layers or parts.
+    flows: Vec<Option<AnimationNodeIndex>>,
+}
 
 /// An animation that is being faded out as part of a transition
-#[derive(Debug, Reflect)]
+#[derive(Debug, Reflect, Default, Clone)]
 pub struct AnimationTransition {
+    /// How much weight we will decrease according to the given user [`Duration`]
     weight_decline_per_sec: f32,
+    /// Node to transition from
     old_node: AnimationNodeIndex,
+    /// Node to transition into
     new_node: AnimationNodeIndex,
+    /// Handle pointer to required component [`AnimationGraph`], needed to grab nodes current weights
     graph: Handle<AnimationGraph>,
+    /// Acts similarly to a local variable, tracks how far into the transition are we, starts from 1. should go to 0
     weight: f32,
 }
 impl AnimationTransitions {
+    /// Potato
+    pub fn new(flow_amount: u8) -> Self {
+        Self {
+            flows: vec![None; flow_amount as usize],
+            transitions: vec![AnimationTransition::default(); flow_amount as usize],
+        }
+    }
+
     /// Transition between one graph node to another according to the given duration
     pub fn transition_nodes(
         &mut self,
@@ -44,37 +64,32 @@ impl AnimationTransitions {
         });
     }
 
-    // /// Plays a new animation on the given [`AnimationPlayer`], fading out any
-    // /// existing animations that were already playing over the
-    // /// `transition_duration`.
-    // ///
-    // /// Pass [`Duration::ZERO`] to instantly switch to a new animation, avoiding
-    // /// any transition.
-    // pub fn play<'p>(
-    //     &mut self,
-    //     player: &'p mut AnimationPlayer,
-    //     new_animation: AnimationNodeIndex,
-    //     transition_duration: Duration,
-    // ) -> &'p mut ActiveAnimation {
-    //     if let Some(old_animation_index) = self.main_animation.replace(new_animation) {
-    //         if let Some(old_animation) = player.animation_mut(old_animation_index) {
-    //             if !old_animation.is_paused() {
-    //                 self.transitions.push(AnimationTransition {
-    //                     current_weight: old_animation.weight,
-    //                     weight_decline_per_sec: 1.0 / transition_duration.as_secs_f32(),
-    //                     animation: old_animation_index,
-    //                 });
-    //             }
-    //         }
-    //     }
+    pub fn transition_flows(
+        &mut self,
+        player: &mut AnimationGraph,
+        new_animation: AnimationNodeIndex,
+        transition_duration: Duration,
+    ) {
 
-    //     // If already transitioning away from this animation, cancel the transition.
-    //     // Otherwise the transition ending would incorrectly stop the new animation.
-    //     self.transitions
-    //         .retain(|transition| transition.animation != new_animation);
+        // if let Some(old_animation_index) = self.main_animation.replace(new_animation) {
+        //     if let Some(old_animation) = player.animation_mut(old_animation_index) {
+        //         if !old_animation.is_paused() {
+        //             self.transitions.push(AnimationTransition {
+        //                 current_weight: old_animation.weight,
+        //                 weight_decline_per_sec: 1.0 / transition_duration.as_secs_f32(),
+        //                 animation: old_animation_index,
+        //             });
+        //         }
+        //     }
+        // }
 
-    //     player.start(new_animation)
-    // }
+        // // If already transitioning away from this animation, cancel the transition.
+        // // Otherwise the transition ending would incorrectly stop the new animation.
+        // self.transitions
+        //     .retain(|transition| transition.animation != new_animation);
+
+        // player.start(new_animation)
+    }
 }
 
 /// System responsible for handling [`AnimationTransitions`] transitioning nodes among each other. According to the pacing defined by user.

From 0e5f12a9311939637f7031a30ca2b814985fc277 Mon Sep 17 00:00:00 2001
From: Sirmadeira <nicolaumori@gmail.com>
Date: Mon, 28 Apr 2025 16:06:57 -0300
Subject: [PATCH 05/25] Updating examples blind testing

---
 crates/bevy_animation/src/transition.rs     | 126 ++++++++++++--------
 examples/animation/animated_mesh_control.rs |  36 ++++--
 examples/animation/animated_mesh_events.rs  |  17 ++-
 examples/stress_tests/many_foxes.rs         |  24 ++--
 4 files changed, 126 insertions(+), 77 deletions(-)

diff --git a/crates/bevy_animation/src/transition.rs b/crates/bevy_animation/src/transition.rs
index 89886ca371ee5..005351ce2c623 100644
--- a/crates/bevy_animation/src/transition.rs
+++ b/crates/bevy_animation/src/transition.rs
@@ -8,13 +8,26 @@ use bevy_ecs::{
 use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 use bevy_time::Time;
 use core::time::Duration;
+use tracing::info;
 
-use crate::graph::{AnimationGraph, AnimationNodeIndex};
+use crate::graph::{AnimationGraph, AnimationGraphHandle, AnimationNodeIndex};
 
-/// Component responsible for managing transitions between N given nodes or states.
-/// It can handle multiple transitions and supports scalable flow-based animation management.
+/// Component responsible for managing transitions between multiple nodes or states.
+///
+/// It supports multiple independent "flows", where each flow represents a distinct active
+/// animation or state machine. A flow tracks the transition between two states over time.
+///
+/// In the simplest case, `flow_amount` should be set to `1`, indicating a single flow.
+/// However, if multiple state machines or simultaneous animations are needed, `flow_amount`
+/// should be increased accordingly.
+///
+/// It is also the user's responsibility to track which flow they are currently operating on
+/// when triggering transitions.
+/// Ex: Flow 0 - Plays idle,walks and so on. Affect whole body
+/// Flow 1 - Plays close hands - Affects only hand bones.
 #[derive(Component, Default, Reflect, Deref, DerefMut)]
 #[reflect(Component, Default)]
+#[require(AnimationGraphHandle)]
 pub struct AnimationTransitions {
     #[deref]
     transitions: Vec<AnimationTransition>,
@@ -24,7 +37,7 @@ pub struct AnimationTransitions {
     flows: Vec<Option<AnimationNodeIndex>>,
 }
 
-/// An animation that is being faded out as part of a transition
+/// An animation node that is being faded out as part of a transition, note this does not control animation playing!
 #[derive(Debug, Reflect, Default, Clone)]
 pub struct AnimationTransition {
     /// How much weight we will decrease according to the given user [`Duration`]
@@ -33,62 +46,67 @@ pub struct AnimationTransition {
     old_node: AnimationNodeIndex,
     /// Node to transition into
     new_node: AnimationNodeIndex,
-    /// Handle pointer to required component [`AnimationGraph`], needed to grab nodes current weights
+    /// Handle pointer to required component [`AnimationGraphHandle`](crate::AnimationGraphHandle). needed to grab nodes current weights
     graph: Handle<AnimationGraph>,
-    /// Acts similarly to a local variable, tracks how far into the transition are we, starts from 1. should go to 0
+    /// Acts similarly to a local variable, tracks how far into the transition are we, should start from 1. and go to 0
     weight: f32,
 }
 impl AnimationTransitions {
-    /// Potato
-    pub fn new(flow_amount: u8) -> Self {
+    /// Define your flow amount and initializes your component!
+    pub fn new(flow_amount: usize) -> Self {
         Self {
-            flows: vec![None; flow_amount as usize],
-            transitions: vec![AnimationTransition::default(); flow_amount as usize],
+            flows: vec![None; flow_amount],
+            // Default transitions are instantaniously cleared
+            transitions: vec![AnimationTransition::default(); flow_amount],
         }
     }
 
-    /// Transition between one graph node to another according to the given duration
+    /// Transitions between two nodes in an animation graph over a given duration.
+    ///
+    /// This is a lower-level method that bypasses flow management.
+    /// It is intended for cases where the user wants direct control over node transitions,
+    /// without tracking flow state or history.
     pub fn transition_nodes(
         &mut self,
         graph: Handle<AnimationGraph>,
         old_node: AnimationNodeIndex,
         new_node: AnimationNodeIndex,
-        transition: Duration,
+        duration: Duration,
     ) {
         self.push(AnimationTransition {
-            weight_decline_per_sec: 1.0 / transition.as_secs_f32(),
+            weight_decline_per_sec: 1.0 / duration.as_secs_f32(),
             old_node,
             new_node,
             graph,
             weight: 1.0,
         });
     }
-
+    /// Transitions the specified flow from its current node to a new node over a given duration.
+    ///
+    /// This method manages transitions within a specific flow, allowing multiple independent
+    /// state machines or animation layers to transition separately. If the flow has no previous node,
+    /// it will treat the `new_node` as both the old and new node during the transition.
     pub fn transition_flows(
         &mut self,
-        player: &mut AnimationGraph,
-        new_animation: AnimationNodeIndex,
-        transition_duration: Duration,
+        graph: Handle<AnimationGraph>,
+        new_node: AnimationNodeIndex,
+        flow_position: usize,
+        duration: Duration,
     ) {
-
-        // if let Some(old_animation_index) = self.main_animation.replace(new_animation) {
-        //     if let Some(old_animation) = player.animation_mut(old_animation_index) {
-        //         if !old_animation.is_paused() {
-        //             self.transitions.push(AnimationTransition {
-        //                 current_weight: old_animation.weight,
-        //                 weight_decline_per_sec: 1.0 / transition_duration.as_secs_f32(),
-        //                 animation: old_animation_index,
-        //             });
-        //         }
-        //     }
-        // }
-
-        // // If already transitioning away from this animation, cancel the transition.
-        // // Otherwise the transition ending would incorrectly stop the new animation.
-        // self.transitions
-        //     .retain(|transition| transition.animation != new_animation);
-
-        // player.start(new_animation)
+        // Check if flow exists
+        if let Some(old_node) = self.flows.get_mut(flow_position) {
+            let previous_node = old_node.unwrap_or(new_node);
+            self.transitions.push(AnimationTransition {
+                weight_decline_per_sec: 1.0 / duration.as_secs_f32(),
+                old_node: previous_node,
+                new_node,
+                graph,
+                weight: 1.0,
+            });
+            *old_node = Some(new_node);
+        } else {
+            panic!("Flow position {flow_position} is out of bounds!");
+        }
     }
 }
 
@@ -100,22 +118,24 @@ pub fn handle_node_transition(
 ) {
     for mut animation_transitions in query.iter_mut() {
         for transition in animation_transitions.iter_mut() {
-            let animation_graph = assets_graph.get_mut(&transition.graph).unwrap();
-
-            if let Some(old_node) = animation_graph.get_mut(transition.old_node) {
-                if transition.weight.eq(&1.0) {
-                    old_node.weight = transition.weight;
+            if let Some(animation_graph) = assets_graph.get_mut(&transition.graph) {
+                if let Some(old_node) = animation_graph.get_mut(transition.old_node) {
+                    if transition.weight.eq(&1.0) {
+                        old_node.weight = transition.weight;
+                    }
+                    old_node.weight -=
+                        transition.weight_decline_per_sec * time.delta_secs().max(0.0);
                 }
-                old_node.weight -= transition.weight_decline_per_sec * time.delta_secs().max(0.0);
-            }
-            if let Some(new_node) = animation_graph.get_mut(transition.new_node) {
-                if transition.weight.eq(&1.0) {
-                    new_node.weight = 0.0;
+                if let Some(new_node) = animation_graph.get_mut(transition.new_node) {
+                    if transition.weight.eq(&1.0) {
+                        new_node.weight = 0.0;
+                    }
+                    new_node.weight +=
+                        transition.weight_decline_per_sec * time.delta_secs().min(1.0);
                 }
-                new_node.weight += transition.weight_decline_per_sec * time.delta_secs().min(1.0);
-            }
 
-            transition.weight -= transition.weight_decline_per_sec * time.delta_secs().max(0.0);
+                transition.weight -= transition.weight_decline_per_sec * time.delta_secs().max(0.0);
+            }
         }
     }
 }
@@ -124,6 +144,12 @@ pub fn handle_node_transition(
 /// [`AnimationTransitions`] object.
 pub fn expire_completed_transitions(mut query: Query<&mut AnimationTransitions>) {
     for mut animation_transitions in query.iter_mut() {
-        animation_transitions.retain(|transition| transition.weight <= 0.0);
+        animation_transitions.retain(|transition| {
+            let keep = transition.weight > 0.0;
+            if !keep {
+                println!("Remove");
+            }
+            keep
+        });
     }
 }
diff --git a/examples/animation/animated_mesh_control.rs b/examples/animation/animated_mesh_control.rs
index 0dafd0de11892..211b03139ceed 100644
--- a/examples/animation/animated_mesh_control.rs
+++ b/examples/animation/animated_mesh_control.rs
@@ -108,15 +108,20 @@ fn setup_scene_once_loaded(
     mut players: Query<(Entity, &mut AnimationPlayer), Added<AnimationPlayer>>,
 ) {
     for (entity, mut player) in &mut players {
-        let mut transitions = AnimationTransitions::new();
+        let mut transitions = AnimationTransitions::new(1);
+        let graph = animations.graph_handle.clone();
 
         // Make sure to start the animation via the `AnimationTransitions`
         // component. The `AnimationTransitions` component wants to manage all
         // the animations and will get confused if the animations are started
         // directly via the `AnimationPlayer`.
-        transitions
-            .play(&mut player, animations.animations[0], Duration::ZERO)
-            .repeat();
+        transitions.transition_flows(
+            graph.clone(),
+            animations.animations[0],
+            0,
+            Duration::from_secs(200),
+        );
+        player.play(animations.animations[0]).repeat();
 
         commands
             .entity(entity)
@@ -127,11 +132,15 @@ fn setup_scene_once_loaded(
 
 fn keyboard_control(
     keyboard_input: Res<ButtonInput<KeyCode>>,
-    mut animation_players: Query<(&mut AnimationPlayer, &mut AnimationTransitions)>,
+    mut animation_players: Query<(
+        &mut AnimationPlayer,
+        &AnimationGraphHandle,
+        &mut AnimationTransitions,
+    )>,
     animations: Res<Animations>,
     mut current_animation: Local<usize>,
 ) {
-    for (mut player, mut transitions) in &mut animation_players {
+    for (mut player, graph, mut transitions) in &mut animation_players {
         let Some((&playing_animation_index, _)) = player.playing_animations().next() else {
             continue;
         };
@@ -172,12 +181,15 @@ fn keyboard_control(
         if keyboard_input.just_pressed(KeyCode::Enter) {
             *current_animation = (*current_animation + 1) % animations.animations.len();
 
-            transitions
-                .play(
-                    &mut player,
-                    animations.animations[*current_animation],
-                    Duration::from_millis(250),
-                )
+            transitions.transition_flows(
+                graph.clone_weak(),
+                animations.animations[*current_animation],
+                0,
+                Duration::from_millis(250),
+            );
+
+            player
+                .play(animations.animations[*current_animation])
                 .repeat();
         }
 
diff --git a/examples/animation/animated_mesh_events.rs b/examples/animation/animated_mesh_events.rs
index 2048f573fd704..4a8135baaa4c2 100644
--- a/examples/animation/animated_mesh_events.rs
+++ b/examples/animation/animated_mesh_events.rs
@@ -159,6 +159,7 @@ fn setup_scene_once_loaded(
         // Send `OnStep` events once the fox feet hits the ground in the running animation.
 
         let graph = graphs.get(&animations.graph_handle).unwrap();
+        let graph_handle = AnimationGraphHandle(animations.graph_handle.clone());
         let running_animation = get_clip(animations.index, graph, &mut clips);
 
         // You can determine the time an event should trigger if you know witch frame it occurs and
@@ -169,17 +170,21 @@ fn setup_scene_once_loaded(
         running_animation.add_event_to_target(feet.back_left, 0.0, OnStep);
         running_animation.add_event_to_target(feet.back_right, 0.125, OnStep);
 
-        // Start the animation
-
-        let mut transitions = AnimationTransitions::new();
+        // Boot up your transition flows
+        let mut transitions = AnimationTransitions::new(1);
 
         // Make sure to start the animation via the `AnimationTransitions`
         // component. The `AnimationTransitions` component wants to manage all
         // the animations and will get confused if the animations are started
         // directly via the `AnimationPlayer`.
-        transitions
-            .play(&mut player, animations.index, Duration::ZERO)
-            .repeat();
+        transitions.transition_flows(
+            graph_handle.clone_weak(),
+            animations.index,
+            0,
+            Duration::ZERO,
+        );
+
+        player.play(animations.index).repeat();
 
         commands
             .entity(entity)
diff --git a/examples/stress_tests/many_foxes.rs b/examples/stress_tests/many_foxes.rs
index c1284c9bd6c1f..6582fb6e47c25 100644
--- a/examples/stress_tests/many_foxes.rs
+++ b/examples/stress_tests/many_foxes.rs
@@ -241,7 +241,7 @@ fn setup_scene_once_loaded(
             commands
                 .entity(entity)
                 .insert(AnimationGraphHandle(animations.graph.clone()))
-                .insert(AnimationTransitions::new());
+                .insert(AnimationTransitions::new(1));
 
             let playing_animation = player.play(animations.node_indices[0]).repeat();
             if !foxes.sync {
@@ -270,7 +270,11 @@ fn update_fox_rings(
 
 fn keyboard_animation_control(
     keyboard_input: Res<ButtonInput<KeyCode>>,
-    mut animation_player: Query<(&mut AnimationPlayer, &mut AnimationTransitions)>,
+    mut animation_player: Query<(
+        &mut AnimationPlayer,
+        &mut AnimationTransitions,
+        &AnimationGraphHandle,
+    )>,
     animations: Res<Animations>,
     mut current_animation: Local<usize>,
     mut foxes: ResMut<Foxes>,
@@ -291,7 +295,7 @@ fn keyboard_animation_control(
         *current_animation = (*current_animation + 1) % animations.node_indices.len();
     }
 
-    for (mut player, mut transitions) in &mut animation_player {
+    for (mut player, mut transitions, graph_handle) in &mut animation_player {
         if keyboard_input.just_pressed(KeyCode::Space) {
             if player.all_paused() {
                 player.resume_all();
@@ -317,12 +321,14 @@ fn keyboard_animation_control(
         }
 
         if keyboard_input.just_pressed(KeyCode::Enter) {
-            transitions
-                .play(
-                    &mut player,
-                    animations.node_indices[*current_animation],
-                    Duration::from_millis(250),
-                )
+            transitions.transition_flows(
+                graph_handle.clone_weak(),
+                animations.node_indices[*current_animation],
+                0,
+                Duration::from_millis(250),
+            );
+            player
+                .play(animations.node_indices[*current_animation])
                 .repeat();
         }
     }

From 8825c4e703cdebf11eb8d8c184f2d845ea6eec9a Mon Sep 17 00:00:00 2001
From: Sirmadeira <nicolaumori@gmail.com>
Date: Tue, 29 Apr 2025 11:45:34 -0300
Subject: [PATCH 06/25] Fix very clunky logic for transitioning

---
 crates/bevy_animation/src/transition.rs     | 54 +++++++++++----------
 examples/animation/animated_mesh_control.rs | 10 ++--
 2 files changed, 32 insertions(+), 32 deletions(-)

diff --git a/crates/bevy_animation/src/transition.rs b/crates/bevy_animation/src/transition.rs
index 005351ce2c623..d77ff41274af7 100644
--- a/crates/bevy_animation/src/transition.rs
+++ b/crates/bevy_animation/src/transition.rs
@@ -1,3 +1,7 @@
+//! Animation Transitioning logic goes here!
+//! Acts quite similar to a pseudo state machine and it can actually support multi-state machines
+
+use crate::graph::{AnimationGraph, AnimationGraphHandle, AnimationNodeIndex};
 use bevy_asset::{Assets, Handle};
 use bevy_derive::{Deref, DerefMut};
 use bevy_ecs::{
@@ -10,8 +14,6 @@ use bevy_time::Time;
 use core::time::Duration;
 use tracing::info;
 
-use crate::graph::{AnimationGraph, AnimationGraphHandle, AnimationNodeIndex};
-
 /// Component responsible for managing transitions between multiple nodes or states.
 ///
 /// It supports multiple independent "flows", where each flow represents a distinct active
@@ -38,10 +40,10 @@ pub struct AnimationTransitions {
 }
 
 /// An animation node that is being faded out as part of a transition, note this does not control animation playing!
-#[derive(Debug, Reflect, Default, Clone)]
+#[derive(Debug, Reflect, Clone)]
 pub struct AnimationTransition {
-    /// How much weight we will decrease according to the given user [`Duration`]
-    weight_decline_per_sec: f32,
+    /// How much weight we will decrease according to the given user value
+    weight_decline: f32,
     /// Node to transition from
     old_node: AnimationNodeIndex,
     /// Node to transition into
@@ -57,7 +59,7 @@ impl AnimationTransitions {
         Self {
             flows: vec![None; flow_amount],
             // Default transitions are instantaniously cleared
-            transitions: vec![AnimationTransition::default(); flow_amount],
+            transitions: Vec::new(),
         }
     }
 
@@ -74,7 +76,7 @@ impl AnimationTransitions {
         duration: Duration,
     ) {
         self.push(AnimationTransition {
-            weight_decline_per_sec: 1.0 / duration.as_secs_f32(),
+            weight_decline: 1. / duration.as_secs_f32(),
             old_node,
             new_node,
             graph,
@@ -97,7 +99,7 @@ impl AnimationTransitions {
         if let Some(old_node) = self.flows.get_mut(flow_position) {
             let previous_node = old_node.unwrap_or(new_node);
             self.transitions.push(AnimationTransition {
-                weight_decline_per_sec: 1.0 / duration.as_secs_f32(),
+                weight_decline: 1. / duration.as_secs_f32(),
                 old_node: previous_node,
                 new_node,
                 graph,
@@ -117,24 +119,26 @@ pub fn handle_node_transition(
     time: Res<Time>,
 ) {
     for mut animation_transitions in query.iter_mut() {
+        let mut remaining_weight = 1.0;
         for transition in animation_transitions.iter_mut() {
-            if let Some(animation_graph) = assets_graph.get_mut(&transition.graph) {
-                if let Some(old_node) = animation_graph.get_mut(transition.old_node) {
-                    if transition.weight.eq(&1.0) {
-                        old_node.weight = transition.weight;
-                    }
-                    old_node.weight -=
-                        transition.weight_decline_per_sec * time.delta_secs().max(0.0);
-                }
-                if let Some(new_node) = animation_graph.get_mut(transition.new_node) {
-                    if transition.weight.eq(&1.0) {
-                        new_node.weight = 0.0;
-                    }
-                    new_node.weight +=
-                        transition.weight_decline_per_sec * time.delta_secs().min(1.0);
-                }
+            let Some(animation_graph) = assets_graph.get_mut(&transition.graph) else {
+                info!("No graph");
+                continue;
+            };
+
+            // How much to transition per tick!
+            transition.weight =
+                (transition.weight - transition.weight_decline * time.delta_secs()).max(0.0);
+
+            info!(?transition.weight,?transition.weight_decline);
+
+            if let Some(old_node) = animation_graph.get_mut(transition.old_node) {
+                old_node.weight = transition.weight * remaining_weight;
+                remaining_weight -= old_node.weight;
+            }
 
-                transition.weight -= transition.weight_decline_per_sec * time.delta_secs().max(0.0);
+            if let Some(new_node) = animation_graph.get_mut(transition.new_node) {
+                new_node.weight = remaining_weight;
             }
         }
     }
@@ -147,7 +151,7 @@ pub fn expire_completed_transitions(mut query: Query<&mut AnimationTransitions>)
         animation_transitions.retain(|transition| {
             let keep = transition.weight > 0.0;
             if !keep {
-                println!("Remove");
+                info!("Remove");
             }
             keep
         });
diff --git a/examples/animation/animated_mesh_control.rs b/examples/animation/animated_mesh_control.rs
index 211b03139ceed..bbc0251f8541c 100644
--- a/examples/animation/animated_mesh_control.rs
+++ b/examples/animation/animated_mesh_control.rs
@@ -3,7 +3,6 @@
 use std::{f32::consts::PI, time::Duration};
 
 use bevy::{animation::RepeatAnimation, pbr::CascadeShadowConfigBuilder, prelude::*};
-
 const FOX_PATH: &str = "models/animated/Fox.glb";
 
 fn main() {
@@ -111,15 +110,12 @@ fn setup_scene_once_loaded(
         let mut transitions = AnimationTransitions::new(1);
         let graph = animations.graph_handle.clone();
 
-        // Make sure to start the animation via the `AnimationTransitions`
-        // component. The `AnimationTransitions` component wants to manage all
-        // the animations and will get confused if the animations are started
-        // directly via the `AnimationPlayer`.
+        // Make sure to still utilize animation player to control your animations
         transitions.transition_flows(
             graph.clone(),
             animations.animations[0],
             0,
-            Duration::from_secs(200),
+            Duration::from_millis(200),
         );
         player.play(animations.animations[0]).repeat();
 
@@ -185,7 +181,7 @@ fn keyboard_control(
                 graph.clone_weak(),
                 animations.animations[*current_animation],
                 0,
-                Duration::from_millis(250),
+                Duration::from_millis(200),
             );
 
             player

From a52d954bcf79695707ac16246c15e533cecf17d6 Mon Sep 17 00:00:00 2001
From: Sirmadeira <nicolaumori@gmail.com>
Date: Tue, 29 Apr 2025 11:45:55 -0300
Subject: [PATCH 07/25] Warn transition

---
 crates/bevy_animation/src/transition.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_animation/src/transition.rs b/crates/bevy_animation/src/transition.rs
index d77ff41274af7..801b835e66ce8 100644
--- a/crates/bevy_animation/src/transition.rs
+++ b/crates/bevy_animation/src/transition.rs
@@ -12,7 +12,7 @@ use bevy_ecs::{
 use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 use bevy_time::Time;
 use core::time::Duration;
-use tracing::info;
+use tracing::{info, warn};
 
 /// Component responsible for managing transitions between multiple nodes or states.
 ///
@@ -122,7 +122,7 @@ pub fn handle_node_transition(
         let mut remaining_weight = 1.0;
         for transition in animation_transitions.iter_mut() {
             let Some(animation_graph) = assets_graph.get_mut(&transition.graph) else {
-                info!("No graph");
+                warn!("No graph and you added an animation transition !");
                 continue;
             };
 

From 04ac9e02567dcb9b1231aa61c8a680fdddb19885 Mon Sep 17 00:00:00 2001
From: Sirmadeira <nicolaumori@gmail.com>
Date: Tue, 29 Apr 2025 14:10:20 -0300
Subject: [PATCH 08/25] Adjusting examples

---
 crates/bevy_animation/src/transition.rs    | 24 +++++++++++-----------
 examples/animation/animated_mesh_events.rs |  5 +----
 examples/testbed/3d.rs                     | 16 ++++++++++-----
 3 files changed, 24 insertions(+), 21 deletions(-)

diff --git a/crates/bevy_animation/src/transition.rs b/crates/bevy_animation/src/transition.rs
index 801b835e66ce8..1fde0e8a972c0 100644
--- a/crates/bevy_animation/src/transition.rs
+++ b/crates/bevy_animation/src/transition.rs
@@ -12,7 +12,7 @@ use bevy_ecs::{
 use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 use bevy_time::Time;
 use core::time::Duration;
-use tracing::{info, warn};
+use tracing::warn;
 
 /// Component responsible for managing transitions between multiple nodes or states.
 ///
@@ -107,7 +107,7 @@ impl AnimationTransitions {
             });
             *old_node = Some(new_node);
         } else {
-            panic!("Flow position {flow_position} is out of bounds!");
+            warn!("Flow position {flow_position} is out of bounds!");
         }
     }
 }
@@ -122,15 +122,21 @@ pub fn handle_node_transition(
         let mut remaining_weight = 1.0;
         for transition in animation_transitions.iter_mut() {
             let Some(animation_graph) = assets_graph.get_mut(&transition.graph) else {
-                warn!("No graph and you added an animation transition !");
+                warn!(
+                    "You have no graph yet, added an animation transition! How could you do that?"
+                );
                 continue;
             };
-
             // How much to transition per tick!
             transition.weight =
                 (transition.weight - transition.weight_decline * time.delta_secs()).max(0.0);
 
-            info!(?transition.weight,?transition.weight_decline);
+            if transition.old_node.eq(&transition.new_node) {
+                if let Some(old_node) = animation_graph.get_mut(transition.old_node) {
+                    old_node.weight = remaining_weight;
+                }
+                continue;
+            }
 
             if let Some(old_node) = animation_graph.get_mut(transition.old_node) {
                 old_node.weight = transition.weight * remaining_weight;
@@ -148,12 +154,6 @@ pub fn handle_node_transition(
 /// [`AnimationTransitions`] object.
 pub fn expire_completed_transitions(mut query: Query<&mut AnimationTransitions>) {
     for mut animation_transitions in query.iter_mut() {
-        animation_transitions.retain(|transition| {
-            let keep = transition.weight > 0.0;
-            if !keep {
-                info!("Remove");
-            }
-            keep
-        });
+        animation_transitions.retain(|transition| transition.weight > 0.0);
     }
 }
diff --git a/examples/animation/animated_mesh_events.rs b/examples/animation/animated_mesh_events.rs
index 4a8135baaa4c2..6e1e85a7d5fa9 100644
--- a/examples/animation/animated_mesh_events.rs
+++ b/examples/animation/animated_mesh_events.rs
@@ -173,10 +173,7 @@ fn setup_scene_once_loaded(
         // Boot up your transition flows
         let mut transitions = AnimationTransitions::new(1);
 
-        // Make sure to start the animation via the `AnimationTransitions`
-        // component. The `AnimationTransitions` component wants to manage all
-        // the animations and will get confused if the animations are started
-        // directly via the `AnimationPlayer`.
+        // Make sure to play your new animation!
         transitions.transition_flows(
             graph_handle.clone_weak(),
             animations.index,
diff --git a/examples/testbed/3d.rs b/examples/testbed/3d.rs
index 6a07f6fae9cb2..d237ce33d6824 100644
--- a/examples/testbed/3d.rs
+++ b/examples/testbed/3d.rs
@@ -288,11 +288,17 @@ mod animation {
     ) {
         for child in children.iter_descendants(trigger.target()) {
             if let Ok((entity, mut player)) = players.get_mut(child) {
-                let mut transitions = AnimationTransitions::new();
-                transitions
-                    .play(&mut player, animation.animation, Duration::ZERO)
-                    .seek_to(0.5)
-                    .pause();
+                let mut transitions = AnimationTransitions::new(1);
+                let graph = animation.graph.clone();
+
+                transitions.transition_flows(
+                    graph,
+                    animation.animation,
+                    0,
+                    Duration::from_millis(200),
+                );
+
+                player.play(animation.animation).seek_to(0.5).pause();
 
                 commands
                     .entity(entity)

From 8d9af1ffbf66647f17b9e32894538e80c0001f49 Mon Sep 17 00:00:00 2001
From: Sirmadeira <nicolaumori@gmail.com>
Date: Tue, 29 Apr 2025 14:38:34 -0300
Subject: [PATCH 09/25] Final commit

---
 crates/bevy_animation/src/transition.rs     | 21 ++++++++++-----------
 examples/animation/animated_mesh_control.rs |  7 +------
 2 files changed, 11 insertions(+), 17 deletions(-)

diff --git a/crates/bevy_animation/src/transition.rs b/crates/bevy_animation/src/transition.rs
index 1fde0e8a972c0..f49f087b23d44 100644
--- a/crates/bevy_animation/src/transition.rs
+++ b/crates/bevy_animation/src/transition.rs
@@ -11,7 +11,7 @@ use bevy_ecs::{
 };
 use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 use bevy_time::Time;
-use core::time::Duration;
+use core::{f32, time::Duration};
 use tracing::warn;
 
 /// Component responsible for managing transitions between multiple nodes or states.
@@ -43,7 +43,7 @@ pub struct AnimationTransitions {
 #[derive(Debug, Reflect, Clone)]
 pub struct AnimationTransition {
     /// How much weight we will decrease according to the given user value
-    weight_decline: f32,
+    duration: Duration,
     /// Node to transition from
     old_node: AnimationNodeIndex,
     /// Node to transition into
@@ -76,7 +76,7 @@ impl AnimationTransitions {
         duration: Duration,
     ) {
         self.push(AnimationTransition {
-            weight_decline: 1. / duration.as_secs_f32(),
+            duration,
             old_node,
             new_node,
             graph,
@@ -99,7 +99,7 @@ impl AnimationTransitions {
         if let Some(old_node) = self.flows.get_mut(flow_position) {
             let previous_node = old_node.unwrap_or(new_node);
             self.transitions.push(AnimationTransition {
-                weight_decline: 1. / duration.as_secs_f32(),
+                duration,
                 old_node: previous_node,
                 new_node,
                 graph,
@@ -123,19 +123,18 @@ pub fn handle_node_transition(
         for transition in animation_transitions.iter_mut() {
             let Some(animation_graph) = assets_graph.get_mut(&transition.graph) else {
                 warn!(
-                    "You have no graph yet, added an animation transition! How could you do that?"
+                    "You have no graph yet added an animation transition! How could you do that?"
                 );
                 continue;
             };
+
             // How much to transition per tick!
             transition.weight =
-                (transition.weight - transition.weight_decline * time.delta_secs()).max(0.0);
+                (transition.weight - 1./transition.duration.as_secs_f32() * time.delta_secs()).max(0.0);
 
-            if transition.old_node.eq(&transition.new_node) {
-                if let Some(old_node) = animation_graph.get_mut(transition.old_node) {
-                    old_node.weight = remaining_weight;
-                }
-                continue;
+            // Handles edge case when duration is zero
+            if transition.duration == Duration::ZERO{
+                transition.weight = 0.0;
             }
 
             if let Some(old_node) = animation_graph.get_mut(transition.old_node) {
diff --git a/examples/animation/animated_mesh_control.rs b/examples/animation/animated_mesh_control.rs
index bbc0251f8541c..ec4777480c22b 100644
--- a/examples/animation/animated_mesh_control.rs
+++ b/examples/animation/animated_mesh_control.rs
@@ -111,12 +111,7 @@ fn setup_scene_once_loaded(
         let graph = animations.graph_handle.clone();
 
         // Make sure to still utilize animation player to control your animations
-        transitions.transition_flows(
-            graph.clone(),
-            animations.animations[0],
-            0,
-            Duration::from_millis(200),
-        );
+        transitions.transition_flows(graph.clone(), animations.animations[0], 0, Duration::ZERO);
         player.play(animations.animations[0]).repeat();
 
         commands

From e3a67ad3d5f12a8c1c82222af669b13a95f9d3be Mon Sep 17 00:00:00 2001
From: Sirmadeira <nicolaumori@gmail.com>
Date: Tue, 29 Apr 2025 14:40:46 -0300
Subject: [PATCH 10/25] Fmt

---
 crates/bevy_animation/src/transition.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_animation/src/transition.rs b/crates/bevy_animation/src/transition.rs
index f49f087b23d44..bd1869701cad1 100644
--- a/crates/bevy_animation/src/transition.rs
+++ b/crates/bevy_animation/src/transition.rs
@@ -129,11 +129,12 @@ pub fn handle_node_transition(
             };
 
             // How much to transition per tick!
-            transition.weight =
-                (transition.weight - 1./transition.duration.as_secs_f32() * time.delta_secs()).max(0.0);
+            transition.weight = (transition.weight
+                - 1. / transition.duration.as_secs_f32() * time.delta_secs())
+            .max(0.0);
 
             // Handles edge case when duration is zero
-            if transition.duration == Duration::ZERO{
+            if transition.duration == Duration::ZERO {
                 transition.weight = 0.0;
             }
 

From 3822d5873c1c8500e6d83b3ad95277b885cc7d56 Mon Sep 17 00:00:00 2001
From: Sirmadeira <nicolaumori@gmail.com>
Date: Tue, 29 Apr 2025 15:39:07 -0300
Subject: [PATCH 11/25] Doc fix

---
 crates/bevy_animation/src/transition.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_animation/src/transition.rs b/crates/bevy_animation/src/transition.rs
index bd1869701cad1..162da8df373e9 100644
--- a/crates/bevy_animation/src/transition.rs
+++ b/crates/bevy_animation/src/transition.rs
@@ -48,7 +48,7 @@ pub struct AnimationTransition {
     old_node: AnimationNodeIndex,
     /// Node to transition into
     new_node: AnimationNodeIndex,
-    /// Handle pointer to required component [`AnimationGraphHandle`](crate::AnimationGraphHandle). needed to grab nodes current weights
+    /// Handle pointer to required component [`AnimationGraphHandle]. needed to grab nodes current weights
     graph: Handle<AnimationGraph>,
     /// Acts similarly to a local variable, tracks how far into the transition are we, should start from 1. and go to 0
     weight: f32,

From 99bb73b91f8e697d33cc2ab673359ae2b1e51eca Mon Sep 17 00:00:00 2001
From: Sirmadeira <nicolaumori@gmail.com>
Date: Tue, 29 Apr 2025 15:40:20 -0300
Subject: [PATCH 12/25] More docs

---
 crates/bevy_animation/src/transition.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_animation/src/transition.rs b/crates/bevy_animation/src/transition.rs
index 162da8df373e9..30ccd0717805b 100644
--- a/crates/bevy_animation/src/transition.rs
+++ b/crates/bevy_animation/src/transition.rs
@@ -1,5 +1,5 @@
 //! Animation Transitioning logic goes here!
-//! Acts quite similar to a pseudo state machine and it can actually support multi-state machines
+//! This struct should in the later run be responsible for handling multi-state Animation Graph nodes.
 
 use crate::graph::{AnimationGraph, AnimationGraphHandle, AnimationNodeIndex};
 use bevy_asset::{Assets, Handle};

From cc996c55d1d41ece1bf385adc2589c42f3f483b6 Mon Sep 17 00:00:00 2001
From: Sirmadeira <nicolaumori@gmail.com>
Date: Tue, 29 Apr 2025 20:39:47 -0300
Subject: [PATCH 13/25] Backtick

---
 crates/bevy_animation/src/transition.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_animation/src/transition.rs b/crates/bevy_animation/src/transition.rs
index 30ccd0717805b..3857ce4849801 100644
--- a/crates/bevy_animation/src/transition.rs
+++ b/crates/bevy_animation/src/transition.rs
@@ -48,7 +48,7 @@ pub struct AnimationTransition {
     old_node: AnimationNodeIndex,
     /// Node to transition into
     new_node: AnimationNodeIndex,
-    /// Handle pointer to required component [`AnimationGraphHandle]. needed to grab nodes current weights
+    /// Handle pointer to required component [`AnimationGraphHandle`]. needed to grab nodes current weights
     graph: Handle<AnimationGraph>,
     /// Acts similarly to a local variable, tracks how far into the transition are we, should start from 1. and go to 0
     weight: f32,

From 1b700f79dd21b8c700f73f76495dc3e592e1bf07 Mon Sep 17 00:00:00 2001
From: Sirmadeira <nicolaumori@gmail.com>
Date: Sat, 3 May 2025 11:14:48 -0300
Subject: [PATCH 14/25] Handling edge case first flow

---
 crates/bevy_animation/src/transition.rs | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/crates/bevy_animation/src/transition.rs b/crates/bevy_animation/src/transition.rs
index 3857ce4849801..59f69c0de6782 100644
--- a/crates/bevy_animation/src/transition.rs
+++ b/crates/bevy_animation/src/transition.rs
@@ -138,6 +138,15 @@ pub fn handle_node_transition(
                 transition.weight = 0.0;
             }
 
+            // Handles edge case first flow
+            if transition.old_node.eq(&transition.new_node) {
+                if let Some(old_node) = animation_graph.get_mut(transition.old_node) {
+                    remaining_weight -= transition.weight * remaining_weight;
+                    old_node.weight = remaining_weight;
+                }
+                continue;
+            }
+
             if let Some(old_node) = animation_graph.get_mut(transition.old_node) {
                 old_node.weight = transition.weight * remaining_weight;
                 remaining_weight -= old_node.weight;

From 2e088ae11400c4e2f02806085d0c30278ecdd281 Mon Sep 17 00:00:00 2001
From: Sirmadeira <nicolaumori@gmail.com>
Date: Sat, 3 May 2025 11:30:34 -0300
Subject: [PATCH 15/25] Add slight note doc for animation graph default values

---
 crates/bevy_animation/src/graph.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/bevy_animation/src/graph.rs b/crates/bevy_animation/src/graph.rs
index aa6d252fee94f..f3727b2772892 100644
--- a/crates/bevy_animation/src/graph.rs
+++ b/crates/bevy_animation/src/graph.rs
@@ -81,6 +81,7 @@ use crate::{AnimationClip, AnimationTargetId};
 /// mask corresponds to a *mask group*, which is a set of animation targets
 /// (bones). An animation target can belong to any number of mask groups within
 /// the context of an animation graph.
+/// Note - Avoid using 0 as a *mask* as that is the default mask for non masked nodes.
 ///
 /// When the appropriate bit is set in a node's mask, neither the node nor its
 /// descendants will animate any animation targets belonging to that mask group.

From e014103857fe8b8ab425cd13a4b7439d04a1b99b Mon Sep 17 00:00:00 2001
From: Sirmadeira <nicolaumori@gmail.com>
Date: Sun, 4 May 2025 14:30:24 -0300
Subject: [PATCH 16/25] Feat: Make it so animation transition is based on
 animation player, we cant be based on graph due to reduplication of clips

---
 crates/bevy_animation/src/transition.rs     | 92 ++++++++++-----------
 examples/animation/animated_mesh_control.rs | 32 +++----
 examples/animation/animated_mesh_events.rs  |  8 +-
 examples/stress_tests/many_foxes.rs         | 23 ++----
 examples/testbed/3d.rs                      |  8 +-
 5 files changed, 69 insertions(+), 94 deletions(-)

diff --git a/crates/bevy_animation/src/transition.rs b/crates/bevy_animation/src/transition.rs
index 59f69c0de6782..a3554c4ef5221 100644
--- a/crates/bevy_animation/src/transition.rs
+++ b/crates/bevy_animation/src/transition.rs
@@ -1,18 +1,19 @@
 //! Animation Transitioning logic goes here!
 //! This struct should in the later run be responsible for handling multi-state Animation Graph nodes.
 
-use crate::graph::{AnimationGraph, AnimationGraphHandle, AnimationNodeIndex};
-use bevy_asset::{Assets, Handle};
+use crate::{
+    graph::{AnimationGraphHandle, AnimationNodeIndex},
+    ActiveAnimation, AnimationPlayer,
+};
 use bevy_derive::{Deref, DerefMut};
 use bevy_ecs::{
     component::Component,
     reflect::ReflectComponent,
-    system::{Query, Res, ResMut},
+    system::{Query, Res},
 };
 use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 use bevy_time::Time;
 use core::{f32, time::Duration};
-use tracing::warn;
 
 /// Component responsible for managing transitions between multiple nodes or states.
 ///
@@ -23,13 +24,16 @@ use tracing::warn;
 /// However, if multiple state machines or simultaneous animations are needed, `flow_amount`
 /// should be increased accordingly.
 ///
+/// Is worth mentioning, that when using AnimationTransitions, you should avoid messing around with player!
+/// As he will do the heavy lifting for you! All you need to worry about is transitioning your flows!
+///
 /// It is also the user's responsibility to track which flow they are currently operating on
 /// when triggering transitions.
 /// Ex: Flow 0 - Plays idle,walks and so on. Affect whole body
 /// Flow 1 - Plays close hands - Affects only hand bones.
 #[derive(Component, Default, Reflect, Deref, DerefMut)]
 #[reflect(Component, Default)]
-#[require(AnimationGraphHandle)]
+#[require(AnimationGraphHandle, AnimationPlayer)]
 pub struct AnimationTransitions {
     #[deref]
     transitions: Vec<AnimationTransition>,
@@ -48,8 +52,6 @@ pub struct AnimationTransition {
     old_node: AnimationNodeIndex,
     /// Node to transition into
     new_node: AnimationNodeIndex,
-    /// Handle pointer to required component [`AnimationGraphHandle`]. needed to grab nodes current weights
-    graph: Handle<AnimationGraph>,
     /// Acts similarly to a local variable, tracks how far into the transition are we, should start from 1. and go to 0
     weight: f32,
 }
@@ -63,71 +65,51 @@ impl AnimationTransitions {
         }
     }
 
-    /// Transitions between two nodes in an animation graph over a given duration.
-    ///
-    /// This is a lower-level method that bypasses flow management.
-    /// It is intended for cases where the user wants direct control over node transitions,
-    /// without tracking flow state or history.
-    pub fn transition_nodes(
-        &mut self,
-        graph: Handle<AnimationGraph>,
-        old_node: AnimationNodeIndex,
-        new_node: AnimationNodeIndex,
-        duration: Duration,
-    ) {
-        self.push(AnimationTransition {
-            duration,
-            old_node,
-            new_node,
-            graph,
-            weight: 1.0,
-        });
-    }
     /// Transitions the specified flow from its current node to a new node over a given duration.
     ///
     /// This method manages transitions within a specific flow, allowing multiple independent
     /// state machines or animation layers to transition separately. If the flow has no previous node,
     /// it will treat the `new_node` as both the old and new node during the transition.
-    pub fn transition_flows(
+    ///
+    /// The logic here goes as follows: Check if you have a history,
+    /// if not old_node eq new_node.
+    /// Queues a transition, make old_node eq new_node, after queuing transition
+    /// Put in active animation new_node
+    pub fn transition_flows<'p>(
         &mut self,
-        graph: Handle<AnimationGraph>,
+        player: &'p mut AnimationPlayer,
         new_node: AnimationNodeIndex,
         flow_position: usize,
         duration: Duration,
-    ) {
+    ) -> &'p mut ActiveAnimation {
         // Check if flow exists
         if let Some(old_node) = self.flows.get_mut(flow_position) {
+            // If is first time playing, just say old node equals new node
             let previous_node = old_node.unwrap_or(new_node);
             self.transitions.push(AnimationTransition {
                 duration,
                 old_node: previous_node,
                 new_node,
-                graph,
                 weight: 1.0,
             });
             *old_node = Some(new_node);
+
+            // Starts new animation, note we wont clear AnimationPlayer active animation hashmap here!
+            player.start(new_node)
         } else {
-            warn!("Flow position {flow_position} is out of bounds!");
+            panic!("Flow position {flow_position} is out of bounds!");
         }
     }
 }
 
 /// System responsible for handling [`AnimationTransitions`] transitioning nodes among each other. According to the pacing defined by user.
 pub fn handle_node_transition(
-    mut query: Query<&mut AnimationTransitions>,
-    mut assets_graph: ResMut<Assets<AnimationGraph>>,
+    mut query: Query<(&mut AnimationTransitions, &mut AnimationPlayer)>,
     time: Res<Time>,
 ) {
-    for mut animation_transitions in query.iter_mut() {
+    for (mut animation_transitions, mut animation_player) in query.iter_mut() {
         let mut remaining_weight = 1.0;
         for transition in animation_transitions.iter_mut() {
-            let Some(animation_graph) = assets_graph.get_mut(&transition.graph) else {
-                warn!(
-                    "You have no graph yet added an animation transition! How could you do that?"
-                );
-                continue;
-            };
-
             // How much to transition per tick!
             transition.weight = (transition.weight
                 - 1. / transition.duration.as_secs_f32() * time.delta_secs())
@@ -140,19 +122,19 @@ pub fn handle_node_transition(
 
             // Handles edge case first flow
             if transition.old_node.eq(&transition.new_node) {
-                if let Some(old_node) = animation_graph.get_mut(transition.old_node) {
+                if let Some(old_node) = animation_player.animation_mut(transition.old_node) {
                     remaining_weight -= transition.weight * remaining_weight;
                     old_node.weight = remaining_weight;
                 }
                 continue;
             }
 
-            if let Some(old_node) = animation_graph.get_mut(transition.old_node) {
+            if let Some(old_node) = animation_player.animation_mut(transition.old_node) {
                 old_node.weight = transition.weight * remaining_weight;
                 remaining_weight -= old_node.weight;
             }
 
-            if let Some(new_node) = animation_graph.get_mut(transition.new_node) {
+            if let Some(new_node) = animation_player.animation_mut(transition.new_node) {
                 new_node.weight = remaining_weight;
             }
         }
@@ -161,8 +143,22 @@ pub fn handle_node_transition(
 
 /// A system that removes transitions that have completed from the
 /// [`AnimationTransitions`] object.
-pub fn expire_completed_transitions(mut query: Query<&mut AnimationTransitions>) {
-    for mut animation_transitions in query.iter_mut() {
-        animation_transitions.retain(|transition| transition.weight > 0.0);
+pub fn expire_completed_transitions(
+    mut query: Query<(&mut AnimationTransitions, &mut AnimationPlayer)>,
+) {
+    for (mut animation_transitions, mut animation_player) in query.iter_mut() {
+        animation_transitions.retain(|transition| {
+            let should_expire = transition.weight <= 0.0;
+            let first_init = transition.new_node.eq(&transition.old_node);
+            //We need to handle the edge case of first initialization, we shouldnt stop in that case!
+            if should_expire && !first_init {
+                animation_player.stop(transition.old_node);
+                false
+            } else if should_expire && first_init {
+                false
+            } else {
+                true
+            }
+        });
     }
 }
diff --git a/examples/animation/animated_mesh_control.rs b/examples/animation/animated_mesh_control.rs
index ec4777480c22b..cc5fbd3c94315 100644
--- a/examples/animation/animated_mesh_control.rs
+++ b/examples/animation/animated_mesh_control.rs
@@ -108,11 +108,11 @@ fn setup_scene_once_loaded(
 ) {
     for (entity, mut player) in &mut players {
         let mut transitions = AnimationTransitions::new(1);
-        let graph = animations.graph_handle.clone();
 
-        // Make sure to still utilize animation player to control your animations
-        transitions.transition_flows(graph.clone(), animations.animations[0], 0, Duration::ZERO);
-        player.play(animations.animations[0]).repeat();
+        // Use only transitions to control your animation player!
+        transitions
+            .transition_flows(&mut player, animations.animations[0], 0, Duration::ZERO)
+            .repeat();
 
         commands
             .entity(entity)
@@ -123,15 +123,11 @@ fn setup_scene_once_loaded(
 
 fn keyboard_control(
     keyboard_input: Res<ButtonInput<KeyCode>>,
-    mut animation_players: Query<(
-        &mut AnimationPlayer,
-        &AnimationGraphHandle,
-        &mut AnimationTransitions,
-    )>,
+    mut animation_players: Query<(&mut AnimationPlayer, &mut AnimationTransitions)>,
     animations: Res<Animations>,
     mut current_animation: Local<usize>,
 ) {
-    for (mut player, graph, mut transitions) in &mut animation_players {
+    for (mut player, mut transitions) in &mut animation_players {
         let Some((&playing_animation_index, _)) = player.playing_animations().next() else {
             continue;
         };
@@ -172,15 +168,13 @@ fn keyboard_control(
         if keyboard_input.just_pressed(KeyCode::Enter) {
             *current_animation = (*current_animation + 1) % animations.animations.len();
 
-            transitions.transition_flows(
-                graph.clone_weak(),
-                animations.animations[*current_animation],
-                0,
-                Duration::from_millis(200),
-            );
-
-            player
-                .play(animations.animations[*current_animation])
+            transitions
+                .transition_flows(
+                    &mut player,
+                    animations.animations[*current_animation],
+                    0,
+                    Duration::from_millis(200),
+                )
                 .repeat();
         }
 
diff --git a/examples/animation/animated_mesh_events.rs b/examples/animation/animated_mesh_events.rs
index 6e1e85a7d5fa9..ca17d5ed4b32d 100644
--- a/examples/animation/animated_mesh_events.rs
+++ b/examples/animation/animated_mesh_events.rs
@@ -159,7 +159,6 @@ fn setup_scene_once_loaded(
         // Send `OnStep` events once the fox feet hits the ground in the running animation.
 
         let graph = graphs.get(&animations.graph_handle).unwrap();
-        let graph_handle = AnimationGraphHandle(animations.graph_handle.clone());
         let running_animation = get_clip(animations.index, graph, &mut clips);
 
         // You can determine the time an event should trigger if you know witch frame it occurs and
@@ -174,12 +173,7 @@ fn setup_scene_once_loaded(
         let mut transitions = AnimationTransitions::new(1);
 
         // Make sure to play your new animation!
-        transitions.transition_flows(
-            graph_handle.clone_weak(),
-            animations.index,
-            0,
-            Duration::ZERO,
-        );
+        transitions.transition_flows(&mut player, animations.index, 0, Duration::ZERO);
 
         player.play(animations.index).repeat();
 
diff --git a/examples/stress_tests/many_foxes.rs b/examples/stress_tests/many_foxes.rs
index 6582fb6e47c25..749b03d94bb85 100644
--- a/examples/stress_tests/many_foxes.rs
+++ b/examples/stress_tests/many_foxes.rs
@@ -270,11 +270,7 @@ fn update_fox_rings(
 
 fn keyboard_animation_control(
     keyboard_input: Res<ButtonInput<KeyCode>>,
-    mut animation_player: Query<(
-        &mut AnimationPlayer,
-        &mut AnimationTransitions,
-        &AnimationGraphHandle,
-    )>,
+    mut animation_player: Query<(&mut AnimationPlayer, &mut AnimationTransitions)>,
     animations: Res<Animations>,
     mut current_animation: Local<usize>,
     mut foxes: ResMut<Foxes>,
@@ -295,7 +291,7 @@ fn keyboard_animation_control(
         *current_animation = (*current_animation + 1) % animations.node_indices.len();
     }
 
-    for (mut player, mut transitions, graph_handle) in &mut animation_player {
+    for (mut player, mut transitions) in &mut animation_player {
         if keyboard_input.just_pressed(KeyCode::Space) {
             if player.all_paused() {
                 player.resume_all();
@@ -321,14 +317,13 @@ fn keyboard_animation_control(
         }
 
         if keyboard_input.just_pressed(KeyCode::Enter) {
-            transitions.transition_flows(
-                graph_handle.clone_weak(),
-                animations.node_indices[*current_animation],
-                0,
-                Duration::from_millis(250),
-            );
-            player
-                .play(animations.node_indices[*current_animation])
+            transitions
+                .transition_flows(
+                    &mut player,
+                    animations.node_indices[*current_animation],
+                    0,
+                    Duration::from_millis(250),
+                )
                 .repeat();
         }
     }
diff --git a/examples/testbed/3d.rs b/examples/testbed/3d.rs
index d237ce33d6824..9380f9f8a9dce 100644
--- a/examples/testbed/3d.rs
+++ b/examples/testbed/3d.rs
@@ -289,16 +289,12 @@ mod animation {
         for child in children.iter_descendants(trigger.target()) {
             if let Ok((entity, mut player)) = players.get_mut(child) {
                 let mut transitions = AnimationTransitions::new(1);
-                let graph = animation.graph.clone();
-
                 transitions.transition_flows(
-                    graph,
+                    &mut player,
                     animation.animation,
                     0,
                     Duration::from_millis(200),
-                );
-
-                player.play(animation.animation).seek_to(0.5).pause();
+                ).seek_to(0.5).pause();
 
                 commands
                     .entity(entity)

From 67413bd1c1e4b147ddbe0c8a2977c5c8417986f6 Mon Sep 17 00:00:00 2001
From: Sirmadeira <nicolaumori@gmail.com>
Date: Sun, 4 May 2025 14:34:02 -0300
Subject: [PATCH 17/25] Chore: Docs + Format

---
 crates/bevy_animation/src/transition.rs |  5 +++--
 examples/testbed/3d.rs                  | 15 +++++++++------
 2 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/crates/bevy_animation/src/transition.rs b/crates/bevy_animation/src/transition.rs
index a3554c4ef5221..47b6c7ca8836b 100644
--- a/crates/bevy_animation/src/transition.rs
+++ b/crates/bevy_animation/src/transition.rs
@@ -26,6 +26,7 @@ use core::{f32, time::Duration};
 ///
 /// Is worth mentioning, that when using AnimationTransitions, you should avoid messing around with player!
 /// As he will do the heavy lifting for you! All you need to worry about is transitioning your flows!
+/// If you do play an additional animation directly via player  this WILL BREAK!
 ///
 /// It is also the user's responsibility to track which flow they are currently operating on
 /// when triggering transitions.
@@ -39,11 +40,11 @@ pub struct AnimationTransitions {
     transitions: Vec<AnimationTransition>,
     /// Flows represent sequences of animation states.
     /// For example, in cases such as masked or additive animation scenarios, a user can easily define transitions between previous and new states.
-    /// This concept is similar to "main" animations but is designed to scale across multiple animation layers or parts.
+    /// This concept is similar to "main" animations, but instead of one sole ActiveAnimation, we might have multiple active animation nodes being controlled!
     flows: Vec<Option<AnimationNodeIndex>>,
 }
 
-/// An animation node that is being faded out as part of a transition, note this does not control animation playing!
+/// An animation node that is being faded out as part of a transition, note this controls the animations being played!
 #[derive(Debug, Reflect, Clone)]
 pub struct AnimationTransition {
     /// How much weight we will decrease according to the given user value
diff --git a/examples/testbed/3d.rs b/examples/testbed/3d.rs
index 9380f9f8a9dce..a7b7fba245cd2 100644
--- a/examples/testbed/3d.rs
+++ b/examples/testbed/3d.rs
@@ -289,12 +289,15 @@ mod animation {
         for child in children.iter_descendants(trigger.target()) {
             if let Ok((entity, mut player)) = players.get_mut(child) {
                 let mut transitions = AnimationTransitions::new(1);
-                transitions.transition_flows(
-                    &mut player,
-                    animation.animation,
-                    0,
-                    Duration::from_millis(200),
-                ).seek_to(0.5).pause();
+                transitions
+                    .transition_flows(
+                        &mut player,
+                        animation.animation,
+                        0,
+                        Duration::from_millis(200),
+                    )
+                    .seek_to(0.5)
+                    .pause();
 
                 commands
                     .entity(entity)

From 70a10774d0e95b558d6f50cafa78463991abf285 Mon Sep 17 00:00:00 2001
From: Sirmadeira <nicolaumori@gmail.com>
Date: Sun, 4 May 2025 14:39:23 -0300
Subject: [PATCH 18/25] Chore: Fix docs

---
 crates/bevy_animation/src/transition.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_animation/src/transition.rs b/crates/bevy_animation/src/transition.rs
index 47b6c7ca8836b..dee3f35257056 100644
--- a/crates/bevy_animation/src/transition.rs
+++ b/crates/bevy_animation/src/transition.rs
@@ -40,7 +40,7 @@ pub struct AnimationTransitions {
     transitions: Vec<AnimationTransition>,
     /// Flows represent sequences of animation states.
     /// For example, in cases such as masked or additive animation scenarios, a user can easily define transitions between previous and new states.
-    /// This concept is similar to "main" animations, but instead of one sole ActiveAnimation, we might have multiple active animation nodes being controlled!
+    /// This concept is similar to "main" animations, but instead of one sole  `ActiveAnimation`, we might have multiple active animation being controlled!
     flows: Vec<Option<AnimationNodeIndex>>,
 }
 

From f023cef360af59460f448671a8ea6220c5866a66 Mon Sep 17 00:00:00 2001
From: Sirmadeira <nicolaumori@gmail.com>
Date: Sun, 4 May 2025 14:42:55 -0300
Subject: [PATCH 19/25] Chore: Doc fixes + shortening if statement

---
 crates/bevy_animation/.vscode/extensions.json |  9 +++++++++
 crates/bevy_animation/.vscode/settings.json   | 12 ++++++++++++
 crates/bevy_animation/src/transition.rs       | 13 +++----------
 3 files changed, 24 insertions(+), 10 deletions(-)
 create mode 100644 crates/bevy_animation/.vscode/extensions.json
 create mode 100644 crates/bevy_animation/.vscode/settings.json

diff --git a/crates/bevy_animation/.vscode/extensions.json b/crates/bevy_animation/.vscode/extensions.json
new file mode 100644
index 0000000000000..86f86dcce2b9f
--- /dev/null
+++ b/crates/bevy_animation/.vscode/extensions.json
@@ -0,0 +1,9 @@
+{
+    "recommendations": [
+        "rust-lang.rust-analyzer",
+        "tamasfe.even-better-toml",
+        "usernamehw.errorlens",
+        "pixl-garden.bongocat",
+        "wilfriedago.vscode-symbols-icon-theme"
+    ]
+}
\ No newline at end of file
diff --git a/crates/bevy_animation/.vscode/settings.json b/crates/bevy_animation/.vscode/settings.json
new file mode 100644
index 0000000000000..380a44046679c
--- /dev/null
+++ b/crates/bevy_animation/.vscode/settings.json
@@ -0,0 +1,12 @@
+{
+    // Allow `rust-analyzer` and `cargo` to run simultaneously.
+    // This uses extra storage space, so consider commenting it out.
+    "rust-analyzer.linkedProjects": [
+        "./Cargo.toml",
+    ],
+    "rust-analyzer.check.command": "clippy",
+    "[rust]": {
+        "editor.defaultFormatter": "rust-lang.rust-analyzer",
+        "editor.formatOnSave": true
+    }
+}
\ No newline at end of file
diff --git a/crates/bevy_animation/src/transition.rs b/crates/bevy_animation/src/transition.rs
index dee3f35257056..b87300e04ed94 100644
--- a/crates/bevy_animation/src/transition.rs
+++ b/crates/bevy_animation/src/transition.rs
@@ -24,7 +24,7 @@ use core::{f32, time::Duration};
 /// However, if multiple state machines or simultaneous animations are needed, `flow_amount`
 /// should be increased accordingly.
 ///
-/// Is worth mentioning, that when using AnimationTransitions, you should avoid messing around with player!
+/// Is worth mentioning, that when using `AnimationTransitions`, you should avoid messing around with player!
 /// As he will do the heavy lifting for you! All you need to worry about is transitioning your flows!
 /// If you do play an additional animation directly via player  this WILL BREAK!
 ///
@@ -40,7 +40,7 @@ pub struct AnimationTransitions {
     transitions: Vec<AnimationTransition>,
     /// Flows represent sequences of animation states.
     /// For example, in cases such as masked or additive animation scenarios, a user can easily define transitions between previous and new states.
-    /// This concept is similar to "main" animations, but instead of one sole  `ActiveAnimation`, we might have multiple active animation being controlled!
+    /// This concept is similar to "main" animations, but instead of one sole `ActiveAnimation`, we might have multiple active animation being controlled!
     flows: Vec<Option<AnimationNodeIndex>>,
 }
 
@@ -71,11 +71,6 @@ impl AnimationTransitions {
     /// This method manages transitions within a specific flow, allowing multiple independent
     /// state machines or animation layers to transition separately. If the flow has no previous node,
     /// it will treat the `new_node` as both the old and new node during the transition.
-    ///
-    /// The logic here goes as follows: Check if you have a history,
-    /// if not old_node eq new_node.
-    /// Queues a transition, make old_node eq new_node, after queuing transition
-    /// Put in active animation new_node
     pub fn transition_flows<'p>(
         &mut self,
         player: &'p mut AnimationPlayer,
@@ -155,10 +150,8 @@ pub fn expire_completed_transitions(
             if should_expire && !first_init {
                 animation_player.stop(transition.old_node);
                 false
-            } else if should_expire && first_init {
-                false
             } else {
-                true
+                !(should_expire && first_init)
             }
         });
     }

From 6ec828b12115713cc9d19540b022b1ef4a19a692 Mon Sep 17 00:00:00 2001
From: Sirmadeira <nicolaumori@gmail.com>
Date: Sun, 4 May 2025 14:44:45 -0300
Subject: [PATCH 20/25] Chore: Remove vscode file

---
 crates/bevy_animation/.vscode/extensions.json |  9 ---------
 crates/bevy_animation/.vscode/settings.json   | 12 ------------
 2 files changed, 21 deletions(-)
 delete mode 100644 crates/bevy_animation/.vscode/extensions.json
 delete mode 100644 crates/bevy_animation/.vscode/settings.json

diff --git a/crates/bevy_animation/.vscode/extensions.json b/crates/bevy_animation/.vscode/extensions.json
deleted file mode 100644
index 86f86dcce2b9f..0000000000000
--- a/crates/bevy_animation/.vscode/extensions.json
+++ /dev/null
@@ -1,9 +0,0 @@
-{
-    "recommendations": [
-        "rust-lang.rust-analyzer",
-        "tamasfe.even-better-toml",
-        "usernamehw.errorlens",
-        "pixl-garden.bongocat",
-        "wilfriedago.vscode-symbols-icon-theme"
-    ]
-}
\ No newline at end of file
diff --git a/crates/bevy_animation/.vscode/settings.json b/crates/bevy_animation/.vscode/settings.json
deleted file mode 100644
index 380a44046679c..0000000000000
--- a/crates/bevy_animation/.vscode/settings.json
+++ /dev/null
@@ -1,12 +0,0 @@
-{
-    // Allow `rust-analyzer` and `cargo` to run simultaneously.
-    // This uses extra storage space, so consider commenting it out.
-    "rust-analyzer.linkedProjects": [
-        "./Cargo.toml",
-    ],
-    "rust-analyzer.check.command": "clippy",
-    "[rust]": {
-        "editor.defaultFormatter": "rust-lang.rust-analyzer",
-        "editor.formatOnSave": true
-    }
-}
\ No newline at end of file

From d712ec7355245d5f25a6c941a09bb642c6a5e832 Mon Sep 17 00:00:00 2001
From: Sirmadeira <nicolaumori@gmail.com>
Date: Wed, 11 Jun 2025 14:29:45 -0300
Subject: [PATCH 21/25] Feat: Backward compatibility

---
 crates/bevy_animation/src/lib.rs            |  1 -
 crates/bevy_animation/src/transition.rs     | 39 +++++++++++++++++++--
 examples/animation/animated_mesh_control.rs |  4 +--
 examples/animation/animated_mesh_events.rs  |  2 +-
 examples/stress_tests/many_foxes.rs         |  5 ++-
 examples/testbed/3d.rs                      |  2 +-
 6 files changed, 43 insertions(+), 10 deletions(-)

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index c9d47a8739a52..8a16923d663f6 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -107,7 +107,6 @@ impl Plugin for AnimationPlugin {
     }
 }
 
-
 /// The [UUID namespace] of animation targets (e.g. bones).
 ///
 /// [UUID namespace]: https://en.wikipedia.org/wiki/Universally_unique_identifier#Versions_3_and_5_(namespace_name-based)
diff --git a/crates/bevy_animation/src/transition.rs b/crates/bevy_animation/src/transition.rs
index b87300e04ed94..a13ec3a6a775a 100644
--- a/crates/bevy_animation/src/transition.rs
+++ b/crates/bevy_animation/src/transition.rs
@@ -57,8 +57,16 @@ pub struct AnimationTransition {
     weight: f32,
 }
 impl AnimationTransitions {
-    /// Define your flow amount and initializes your component!
-    pub fn new(flow_amount: usize) -> Self {
+    /// Initializes the [`AnimationTransitions`] component, with ONE SINGLE flow meaning. It is expected to play only one animation at once.
+    pub fn new() -> Self {
+        Self {
+            flows: vec![None; 1 as usize],
+            transitions: Vec::new(),
+        }
+    }
+
+    /// Define your flow amount and initializes your component, renember flow_amount is the amount of animation you want to be playing at onces
+    pub fn new_with_flow(flow_amount: usize) -> Self {
         Self {
             flows: vec![None; flow_amount],
             // Default transitions are instantaniously cleared
@@ -66,6 +74,33 @@ impl AnimationTransitions {
         }
     }
 
+    /// Transitions the specified flow from its current node to a new node over a given duration.
+    ///
+    /// This method manages transitions within one single flow.
+    pub fn transition<'p>(
+        &mut self,
+        player: &'p mut AnimationPlayer,
+        new_node: AnimationNodeIndex,
+        duration: Duration,
+    ) -> &'p mut ActiveAnimation {
+        if let Some(old_node) = self.flows.get_mut(0) {
+            // If is first time playing, just say old node equals new node
+            let previous_node = old_node.unwrap_or(new_node);
+            self.transitions.push(AnimationTransition {
+                duration,
+                old_node: previous_node,
+                new_node,
+                weight: 1.0,
+            });
+            *old_node = Some(new_node);
+
+            // Starts new animation, note we wont clear AnimationPlayer active animation hashmap here!
+            player.start(new_node)
+        } else {
+            panic!("Flow position 0 is out of bounds!");
+        }
+    }
+
     /// Transitions the specified flow from its current node to a new node over a given duration.
     ///
     /// This method manages transitions within a specific flow, allowing multiple independent
diff --git a/examples/animation/animated_mesh_control.rs b/examples/animation/animated_mesh_control.rs
index cc5fbd3c94315..7bd97941a41da 100644
--- a/examples/animation/animated_mesh_control.rs
+++ b/examples/animation/animated_mesh_control.rs
@@ -107,11 +107,11 @@ fn setup_scene_once_loaded(
     mut players: Query<(Entity, &mut AnimationPlayer), Added<AnimationPlayer>>,
 ) {
     for (entity, mut player) in &mut players {
-        let mut transitions = AnimationTransitions::new(1);
+        let mut transitions = AnimationTransitions::new();
 
         // Use only transitions to control your animation player!
         transitions
-            .transition_flows(&mut player, animations.animations[0], 0, Duration::ZERO)
+            .transition(&mut player, animations.animations[0], Duration::ZERO)
             .repeat();
 
         commands
diff --git a/examples/animation/animated_mesh_events.rs b/examples/animation/animated_mesh_events.rs
index e5ef3f94dd794..8cd1b1c09e599 100644
--- a/examples/animation/animated_mesh_events.rs
+++ b/examples/animation/animated_mesh_events.rs
@@ -173,7 +173,7 @@ fn setup_scene_once_loaded(
         running_animation.add_event_to_target(feet.back_right, 0.125, OnStep);
 
         // Boot up your transition flows
-        let mut transitions = AnimationTransitions::new(1);
+        let mut transitions = AnimationTransitions::new();
 
         // Make sure to play your new animation!
         transitions.transition_flows(&mut player, animations.index, 0, Duration::ZERO);
diff --git a/examples/stress_tests/many_foxes.rs b/examples/stress_tests/many_foxes.rs
index 749b03d94bb85..f60d935718983 100644
--- a/examples/stress_tests/many_foxes.rs
+++ b/examples/stress_tests/many_foxes.rs
@@ -241,7 +241,7 @@ fn setup_scene_once_loaded(
             commands
                 .entity(entity)
                 .insert(AnimationGraphHandle(animations.graph.clone()))
-                .insert(AnimationTransitions::new(1));
+                .insert(AnimationTransitions::new());
 
             let playing_animation = player.play(animations.node_indices[0]).repeat();
             if !foxes.sync {
@@ -318,10 +318,9 @@ fn keyboard_animation_control(
 
         if keyboard_input.just_pressed(KeyCode::Enter) {
             transitions
-                .transition_flows(
+                .transition(
                     &mut player,
                     animations.node_indices[*current_animation],
-                    0,
                     Duration::from_millis(250),
                 )
                 .repeat();
diff --git a/examples/testbed/3d.rs b/examples/testbed/3d.rs
index 0b2835512e303..6cea2f9f9999c 100644
--- a/examples/testbed/3d.rs
+++ b/examples/testbed/3d.rs
@@ -283,7 +283,7 @@ mod animation {
     ) {
         for child in children.iter_descendants(trigger.target().unwrap()) {
             if let Ok((entity, mut player)) = players.get_mut(child) {
-                let mut transitions = AnimationTransitions::new(1);
+                let mut transitions = AnimationTransitions::new();
                 transitions
                     .transition_flows(
                         &mut player,

From 2ffb5474486a0369676b4e0eebe6d1b14c8b2625 Mon Sep 17 00:00:00 2001
From: Sirmadeira <nicolaumori@gmail.com>
Date: Wed, 11 Jun 2025 14:30:59 -0300
Subject: [PATCH 22/25] Testbed adjustment

---
 examples/testbed/3d.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/examples/testbed/3d.rs b/examples/testbed/3d.rs
index 6cea2f9f9999c..51bc199045600 100644
--- a/examples/testbed/3d.rs
+++ b/examples/testbed/3d.rs
@@ -285,10 +285,9 @@ mod animation {
             if let Ok((entity, mut player)) = players.get_mut(child) {
                 let mut transitions = AnimationTransitions::new();
                 transitions
-                    .transition_flows(
+                    .transition(
                         &mut player,
                         animation.animation,
-                        0,
                         Duration::from_millis(200),
                     )
                     .seek_to(0.5)

From fadc07dcfa014c482d6738f59843a0681050b3ba Mon Sep 17 00:00:00 2001
From: Sirmadeira <nicolaumori@gmail.com>
Date: Wed, 11 Jun 2025 14:32:25 -0300
Subject: [PATCH 23/25] Cargo fmt

---
 examples/testbed/3d.rs | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/examples/testbed/3d.rs b/examples/testbed/3d.rs
index 51bc199045600..9e7c859e0ff81 100644
--- a/examples/testbed/3d.rs
+++ b/examples/testbed/3d.rs
@@ -285,11 +285,7 @@ mod animation {
             if let Ok((entity, mut player)) = players.get_mut(child) {
                 let mut transitions = AnimationTransitions::new();
                 transitions
-                    .transition(
-                        &mut player,
-                        animation.animation,
-                        Duration::from_millis(200),
-                    )
+                    .transition(&mut player, animation.animation, Duration::from_millis(200))
                     .seek_to(0.5)
                     .pause();
 

From c5dc465254ccb20467ad2b8d355aa60cd8b7d855 Mon Sep 17 00:00:00 2001
From: Sirmadeira <nicolaumori@gmail.com>
Date: Wed, 11 Jun 2025 14:33:59 -0300
Subject: [PATCH 24/25] Typos -w

---
 crates/bevy_animation/src/transition.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_animation/src/transition.rs b/crates/bevy_animation/src/transition.rs
index a13ec3a6a775a..2091afd196d67 100644
--- a/crates/bevy_animation/src/transition.rs
+++ b/crates/bevy_animation/src/transition.rs
@@ -57,7 +57,7 @@ pub struct AnimationTransition {
     weight: f32,
 }
 impl AnimationTransitions {
-    /// Initializes the [`AnimationTransitions`] component, with ONE SINGLE flow meaning. It is expected to play only one animation at once.
+    /// Initializes the [`AnimationTransitions`] component, with ONE SINGLE flow meaning. It is expected to play only one animation at once
     pub fn new() -> Self {
         Self {
             flows: vec![None; 1 as usize],
@@ -65,7 +65,7 @@ impl AnimationTransitions {
         }
     }
 
-    /// Define your flow amount and initializes your component, renember flow_amount is the amount of animation you want to be playing at onces
+    /// Define your flow amount and initializes your component, renember flow_amount is the amount of animation you want to be playing at once
     pub fn new_with_flow(flow_amount: usize) -> Self {
         Self {
             flows: vec![None; flow_amount],

From 9a6186f02a57039b3fd587f3408e2314b789445c Mon Sep 17 00:00:00 2001
From: Sirmadeira <nicolaumori@gmail.com>
Date: Thu, 12 Jun 2025 10:49:40 -0300
Subject: [PATCH 25/25] Doc fix

---
 crates/bevy_animation/src/transition.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_animation/src/transition.rs b/crates/bevy_animation/src/transition.rs
index 2091afd196d67..bd1ab8dc30999 100644
--- a/crates/bevy_animation/src/transition.rs
+++ b/crates/bevy_animation/src/transition.rs
@@ -60,12 +60,12 @@ impl AnimationTransitions {
     /// Initializes the [`AnimationTransitions`] component, with ONE SINGLE flow meaning. It is expected to play only one animation at once
     pub fn new() -> Self {
         Self {
-            flows: vec![None; 1 as usize],
+            flows: vec![None; 1_usize],
             transitions: Vec::new(),
         }
     }
 
-    /// Define your flow amount and initializes your component, renember flow_amount is the amount of animation you want to be playing at once
+    /// Define your flow amount and initializes your component, renember `flow_amount` is the amount of animation you want to be playing at once
     pub fn new_with_flow(flow_amount: usize) -> Self {
         Self {
             flows: vec![None; flow_amount],