From f5bfb0e97e6a4331ff8c572724d635f77938f82e Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Mon, 30 Sep 2024 13:07:45 +0200
Subject: [PATCH 01/89] example init

---
 Cargo.toml                               | 11 +++++++++++
 examples/animation/animation_triggers.rs | 15 +++++++++++++++
 2 files changed, 26 insertions(+)
 create mode 100644 examples/animation/animation_triggers.rs

diff --git a/Cargo.toml b/Cargo.toml
index f7420664260fa..9a114f47040ec 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1170,6 +1170,17 @@ doc-scrape-examples = true
 hidden = true
 
 # Animation
+[[examples]]
+name = "animation_triggers"
+path = "examples/animation/animation_triggers.rs"
+doc-scrape-examples = true
+
+[package.metadata.example.animation_triggers]
+name = "Animation Triggers"
+description = "blablabla"
+category = "Animation"
+wasm = true
+
 [[example]]
 name = "animated_fox"
 path = "examples/animation/animated_fox.rs"
diff --git a/examples/animation/animation_triggers.rs b/examples/animation/animation_triggers.rs
new file mode 100644
index 0000000000000..e37df7ad0f4e6
--- /dev/null
+++ b/examples/animation/animation_triggers.rs
@@ -0,0 +1,15 @@
+use bevy::prelude::*;
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_systems(Startup, setup)
+        .add_systems(Update, update)
+        .run();
+}
+
+fn setup() {
+    println!("HI!");
+}
+
+fn update() {}

From fa01cd15cade1867c727e6cfb9bfad504479a9c2 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Mon, 30 Sep 2024 13:19:51 +0200
Subject: [PATCH 02/89] Update Cargo.toml

---
 Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index 9a114f47040ec..6c8b6f6394c07 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1170,7 +1170,7 @@ doc-scrape-examples = true
 hidden = true
 
 # Animation
-[[examples]]
+[[example]]
 name = "animation_triggers"
 path = "examples/animation/animation_triggers.rs"
 doc-scrape-examples = true

From f970677c09c75074fdb33b7872b4fc10456d8185 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Mon, 30 Sep 2024 15:04:44 +0200
Subject: [PATCH 03/89] implement animation triggers

---
 crates/bevy_animation/src/lib.rs            |  70 +++++-
 crates/bevy_animation/src/triggers.rs       | 252 ++++++++++++++++++++
 crates/bevy_internal/src/default_plugins.rs |   2 +-
 examples/animation/animated_fox.rs          |   7 +-
 examples/animation/animation_graph.rs       |   7 +-
 examples/animation/animation_triggers.rs    |  53 +++-
 6 files changed, 376 insertions(+), 15 deletions(-)
 create mode 100644 crates/bevy_animation/src/triggers.rs

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 0b1339d2fb3d9..3b0217f74b4ca 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -13,6 +13,7 @@ pub mod animatable;
 pub mod graph;
 pub mod keyframes;
 pub mod transition;
+pub mod triggers;
 mod util;
 
 use alloc::collections::BTreeMap;
@@ -23,6 +24,7 @@ use core::{
     hash::{Hash, Hasher},
     iter,
 };
+use triggers::{trigger_animation_event, AnimationEvent, AnimationTriggerData};
 
 use bevy_app::{App, Plugin, PostUpdate};
 use bevy_asset::{Asset, AssetApp, Assets, Handle};
@@ -30,7 +32,7 @@ use bevy_core::Name;
 use bevy_ecs::{
     entity::MapEntities, prelude::*, reflect::ReflectMapEntities, world::EntityMutExcept,
 };
-use bevy_math::FloatExt;
+use bevy_math::{FloatExt, FloatOrd};
 use bevy_reflect::{
     prelude::ReflectDefault, utility::NonGenericTypeInfoCell, ApplyError, DynamicStruct, FieldIter,
     FromReflect, FromType, GetTypeRegistration, NamedField, PartialReflect, Reflect,
@@ -468,9 +470,12 @@ pub enum Interpolation {
 #[derive(Asset, Reflect, Clone, Debug, Default)]
 pub struct AnimationClip {
     curves: AnimationCurves,
+    triggers: AnimationTriggers,
     duration: f32,
 }
 
+pub(crate) type AnimationTriggers = HashMap<AnimationTargetId, Vec<(f32, AnimationTriggerData)>>;
+
 /// A mapping from [`AnimationTargetId`] (e.g. bone in a skinned mesh) to the
 /// animation curves.
 pub type AnimationCurves = HashMap<AnimationTargetId, Vec<VariableCurve>, NoOpHash>;
@@ -599,6 +604,21 @@ impl AnimationClip {
             .max(*curve.keyframe_timestamps.last().unwrap_or(&0.0));
         self.curves.entry(target_id).or_default().push(curve);
     }
+
+    /// Add an [`AnimationTrigger`] to an [`AnimationTarget`] named by an [`AnimationTargetId`].
+    ///
+    /// The `event` will trigger on the entity matching the target once the `time` is reached in the animation.
+    pub fn add_trigger(
+        &mut self,
+        target_id: AnimationTargetId,
+        time: f32,
+        event: impl AnimationEvent,
+    ) {
+        self.duration = self.duration.max(time);
+        let triggers = self.triggers.entry(target_id).or_default();
+        triggers.push((time, AnimationTriggerData::new(event)));
+        triggers.sort_by_key(|(k, _)| FloatOrd(*k));
+    }
 }
 
 /// Repetition behavior of an animation.
@@ -660,9 +680,11 @@ pub struct ActiveAnimation {
     ///
     /// Note: This will always be in the range [0.0, animation clip duration]
     seek_time: f32,
+    last_seek_time: Option<f32>,
     /// Number of times the animation has completed.
     /// If the animation is playing in reverse, this increments when the animation passes the start.
     completions: u32,
+    just_completed: bool,
     paused: bool,
 }
 
@@ -676,7 +698,9 @@ impl Default for ActiveAnimation {
             speed: 1.0,
             elapsed: 0.0,
             seek_time: 0.0,
+            last_seek_time: None,
             completions: 0,
+            just_completed: false,
             paused: false,
         }
     }
@@ -702,6 +726,9 @@ impl ActiveAnimation {
             return;
         }
 
+        self.just_completed = false;
+        self.last_seek_time = Some(self.seek_time);
+
         self.elapsed += delta;
         self.seek_time += delta * self.speed;
 
@@ -709,6 +736,7 @@ impl ActiveAnimation {
         let under_time = self.speed < 0.0 && self.seek_time < 0.0;
 
         if over_time || under_time {
+            self.just_completed = true;
             self.completions += 1;
 
             if self.is_finished() {
@@ -1107,16 +1135,24 @@ pub type AnimationEntityMut<'w> = EntityMutExcept<
 
 /// A system that modifies animation targets (e.g. bones in a skinned mesh)
 /// according to the currently-playing animations.
-pub fn animate_targets(
+///
+/// Also triggers animation events.
+pub fn animate_targets_and_trigger_events(
+    par_commands: ParallelCommands,
     clips: Res<Assets<AnimationClip>>,
     graphs: Res<Assets<AnimationGraph>>,
     players: Query<(&AnimationPlayer, &Handle<AnimationGraph>)>,
-    mut targets: Query<(&AnimationTarget, Option<&mut Transform>, AnimationEntityMut)>,
+    mut targets: Query<(
+        Entity,
+        &AnimationTarget,
+        Option<&mut Transform>,
+        AnimationEntityMut,
+    )>,
 ) {
     // Evaluate all animation targets in parallel.
     targets
         .par_iter_mut()
-        .for_each(|(target, mut transform, mut entity_mut)| {
+        .for_each(|(entity, target, mut transform, mut entity_mut)| {
             let &AnimationTarget {
                 id: target_id,
                 player: player_id,
@@ -1184,6 +1220,30 @@ pub fn animate_targets(
                     continue;
                 };
 
+                for (_time, event) in clip
+                    .triggers
+                    .get(&target_id)
+                    .iter()
+                    .flat_map(|t| t.iter())
+                    .filter(|(t, _)| match active_animation.is_playback_reversed() {
+                        true => {
+                            *t >= active_animation.seek_time
+                                && (active_animation.just_completed
+                                    || Some(*t) < active_animation.last_seek_time)
+                        }
+                        false => {
+                            Some(*t) > active_animation.last_seek_time
+                                && (active_animation.just_completed
+                                    || *t <= active_animation.seek_time)
+                        }
+                    })
+                {
+                    dbg!(active_animation.seek_time);
+                    par_commands.command_scope(|mut commands| {
+                        commands.queue(trigger_animation_event(event.0.clone_value(), entity));
+                    })
+                }
+
                 let Some(curves) = clip.curves_for_target(target_id) else {
                     continue;
                 };
@@ -1259,7 +1319,7 @@ impl Plugin for AnimationPlugin {
                     // it to its own system set after `Update` but before
                     // `PostUpdate`. For now, we just disable ambiguity testing
                     // for this system.
-                    animate_targets
+                    animate_targets_and_trigger_events
                         .after(bevy_render::mesh::morph::inherit_weights)
                         .ambiguous_with_all(),
                     expire_completed_transitions,
diff --git a/crates/bevy_animation/src/triggers.rs b/crates/bevy_animation/src/triggers.rs
new file mode 100644
index 0000000000000..e75ce613df76f
--- /dev/null
+++ b/crates/bevy_animation/src/triggers.rs
@@ -0,0 +1,252 @@
+use std::any::{Any, TypeId};
+
+use bevy_ecs::prelude::*;
+use bevy_reflect::{
+    prelude::*, utility::NonGenericTypeInfoCell, ApplyError, DynamicTupleStruct, FromType,
+    GetTypeRegistration, ReflectFromPtr, ReflectKind, ReflectMut, ReflectOwned, ReflectRef,
+    TupleStructFieldIter, TupleStructInfo, TypeInfo, TypeRegistration, Typed, UnnamedField,
+};
+
+pub(crate) fn trigger_animation_event(
+    event: Box<dyn PartialReflect>,
+    entity: Entity,
+) -> impl Command {
+    move |world: &mut World| {
+        let (from_reflect, animation_event) = {
+            let registry = world
+                .get_resource::<AppTypeRegistry>()
+                .expect("Missing resource `AppTypeRegistry`");
+            let lock = registry.read();
+            let type_info = event.get_represented_type_info().unwrap(); // FIXME: when would this fail?
+            let registration = lock
+                .get_with_type_path(type_info.type_path())
+                .unwrap_or_else(|| {
+                    panic!(
+                        "Missing type registration for type: `{}`",
+                        type_info.type_path()
+                    )
+                });
+            (
+                registration
+                    .data::<ReflectFromReflect>()
+                    .cloned()
+                    .unwrap_or_else(|| {
+                        panic!(
+                            "Type `{}` is not registered with data: `ReflectFromReflect`",
+                            type_info.type_path()
+                        )
+                    }),
+                registration
+                    .data::<ReflectAnimationEvent>()
+                    .cloned()
+                    .unwrap_or_else(|| {
+                        panic!(
+                            "Type `{}` is not registered with data: `ReflectAnimationEvent`",
+                            type_info.type_path()
+                        )
+                    }),
+            )
+        };
+        let event = from_reflect.from_reflect(event.as_ref()).unwrap(); // FIXME: when would this fail?
+        animation_event.trigger(event.as_ref(), entity, world);
+    }
+}
+
+pub trait AnimationEvent: Event + Reflect + Clone {}
+
+#[derive(Clone)]
+pub struct ReflectAnimationEvent {
+    trigger: fn(&dyn Reflect, Entity, &mut World),
+}
+
+impl ReflectAnimationEvent {
+    /// # Panics
+    ///
+    /// Panics if the underlying type of `event` does not match the type this `ReflectAnimationEvent` was constructed for.
+    pub(crate) fn trigger(&self, event: &dyn Reflect, entity: Entity, world: &mut World) {
+        (self.trigger)(event, entity, world)
+    }
+}
+
+impl<T: AnimationEvent> FromType<T> for ReflectAnimationEvent {
+    fn from_type() -> Self {
+        Self {
+            trigger: |value, entity, world| {
+                let event = value.downcast_ref::<T>().unwrap().clone();
+                world.entity_mut(entity).trigger(event);
+            },
+        }
+    }
+}
+
+#[derive(TypePath, Debug)]
+pub(crate) struct AnimationTriggerData(pub(crate) Box<dyn PartialReflect>);
+
+impl AnimationTriggerData {
+    pub(crate) fn new(event: impl Event + PartialReflect) -> Self {
+        Self(Box::new(event))
+    }
+}
+
+impl Clone for AnimationTriggerData {
+    fn clone(&self) -> Self {
+        Self(self.0.clone_value())
+    }
+}
+
+impl GetTypeRegistration for AnimationTriggerData {
+    fn get_type_registration() -> TypeRegistration {
+        let mut registration = TypeRegistration::of::<Self>();
+        registration.insert::<ReflectFromPtr>(FromType::<Self>::from_type());
+        registration
+    }
+}
+
+impl Typed for AnimationTriggerData {
+    fn type_info() -> &'static TypeInfo {
+        static CELL: NonGenericTypeInfoCell = NonGenericTypeInfoCell::new();
+        CELL.get_or_set(|| {
+            TypeInfo::TupleStruct(TupleStructInfo::new::<Self>(&[UnnamedField::new::<()>(0)]))
+        })
+    }
+}
+
+impl TupleStruct for AnimationTriggerData {
+    fn field(&self, index: usize) -> Option<&dyn PartialReflect> {
+        match index {
+            0 => Some(self.0.as_partial_reflect()),
+            _ => None,
+        }
+    }
+
+    fn field_mut(&mut self, index: usize) -> Option<&mut dyn PartialReflect> {
+        match index {
+            0 => Some(self.0.as_partial_reflect_mut()),
+            _ => None,
+        }
+    }
+
+    fn field_len(&self) -> usize {
+        1
+    }
+
+    fn iter_fields(&self) -> TupleStructFieldIter {
+        TupleStructFieldIter::new(self)
+    }
+
+    fn clone_dynamic(&self) -> DynamicTupleStruct {
+        DynamicTupleStruct::from_iter([PartialReflect::clone_value(&*self.0)])
+    }
+}
+
+impl PartialReflect for AnimationTriggerData {
+    #[inline]
+    fn get_represented_type_info(&self) -> Option<&'static TypeInfo> {
+        Some(<Self as Typed>::type_info())
+    }
+
+    #[inline]
+    fn into_partial_reflect(self: Box<Self>) -> Box<dyn PartialReflect> {
+        self
+    }
+
+    #[inline]
+    fn as_partial_reflect(&self) -> &dyn PartialReflect {
+        self
+    }
+
+    #[inline]
+    fn as_partial_reflect_mut(&mut self) -> &mut dyn PartialReflect {
+        self
+    }
+
+    fn try_into_reflect(self: Box<Self>) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>> {
+        Ok(self)
+    }
+
+    #[inline]
+    fn try_as_reflect(&self) -> Option<&dyn Reflect> {
+        Some(self)
+    }
+
+    #[inline]
+    fn try_as_reflect_mut(&mut self) -> Option<&mut dyn Reflect> {
+        Some(self)
+    }
+
+    fn try_apply(&mut self, value: &dyn PartialReflect) -> Result<(), ApplyError> {
+        if let ReflectRef::TupleStruct(struct_value) = value.reflect_ref() {
+            for (i, value) in struct_value.iter_fields().enumerate() {
+                if let Some(v) = self.field_mut(i) {
+                    v.try_apply(value)?;
+                }
+            }
+        } else {
+            return Err(ApplyError::MismatchedKinds {
+                from_kind: value.reflect_kind(),
+                to_kind: ReflectKind::TupleStruct,
+            });
+        }
+        Ok(())
+    }
+
+    fn reflect_ref(&self) -> ReflectRef {
+        ReflectRef::TupleStruct(self)
+    }
+
+    fn reflect_mut(&mut self) -> ReflectMut {
+        ReflectMut::TupleStruct(self)
+    }
+
+    fn reflect_owned(self: Box<Self>) -> ReflectOwned {
+        ReflectOwned::TupleStruct(self)
+    }
+
+    fn clone_value(&self) -> Box<dyn PartialReflect> {
+        Box::new(Clone::clone(self))
+    }
+}
+
+impl Reflect for AnimationTriggerData {
+    #[inline]
+    fn into_any(self: Box<Self>) -> Box<dyn Any> {
+        self
+    }
+
+    #[inline]
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    #[inline]
+    fn as_any_mut(&mut self) -> &mut dyn Any {
+        self
+    }
+
+    #[inline]
+    fn into_reflect(self: Box<Self>) -> Box<dyn Reflect> {
+        self
+    }
+
+    #[inline]
+    fn as_reflect(&self) -> &dyn Reflect {
+        self
+    }
+
+    #[inline]
+    fn as_reflect_mut(&mut self) -> &mut dyn Reflect {
+        self
+    }
+
+    #[inline]
+    fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>> {
+        *self = value.take()?;
+        Ok(())
+    }
+}
+
+impl FromReflect for AnimationTriggerData {
+    fn from_reflect(reflect: &dyn PartialReflect) -> Option<Self> {
+        Some(reflect.try_downcast_ref::<AnimationTriggerData>()?.clone())
+    }
+}
diff --git a/crates/bevy_internal/src/default_plugins.rs b/crates/bevy_internal/src/default_plugins.rs
index 74008dafafcc8..84721cfbf38e0 100644
--- a/crates/bevy_internal/src/default_plugins.rs
+++ b/crates/bevy_internal/src/default_plugins.rs
@@ -141,7 +141,7 @@ impl Plugin for IgnoreAmbiguitiesPlugin {
             );
             app.ignore_ambiguity(
                 bevy_app::PostUpdate,
-                bevy_animation::animate_targets,
+                bevy_animation::animate_targets_and_trigger_events,
                 bevy_ui::ui_layout_system,
             );
         }
diff --git a/examples/animation/animated_fox.rs b/examples/animation/animated_fox.rs
index f10e2b66ee1f3..06fd14ee3c2bc 100644
--- a/examples/animation/animated_fox.rs
+++ b/examples/animation/animated_fox.rs
@@ -3,7 +3,7 @@
 use std::{f32::consts::PI, time::Duration};
 
 use bevy::{
-    animation::{animate_targets, RepeatAnimation},
+    animation::{animate_targets_and_trigger_events, RepeatAnimation},
     pbr::CascadeShadowConfigBuilder,
     prelude::*,
 };
@@ -18,7 +18,10 @@ fn main() {
         })
         .add_plugins(DefaultPlugins)
         .add_systems(Startup, setup)
-        .add_systems(Update, setup_scene_once_loaded.before(animate_targets))
+        .add_systems(
+            Update,
+            setup_scene_once_loaded.before(animate_targets_and_trigger_events),
+        )
         .add_systems(Update, keyboard_animation_control)
         .run();
 }
diff --git a/examples/animation/animation_graph.rs b/examples/animation/animation_graph.rs
index 94b9a2e52295e..2654ad3ac0438 100644
--- a/examples/animation/animation_graph.rs
+++ b/examples/animation/animation_graph.rs
@@ -4,7 +4,7 @@
 //! playing animations by clicking and dragging left or right within the nodes.
 
 use bevy::{
-    animation::animate_targets,
+    animation::animate_targets_and_trigger_events,
     color::palettes::{
         basic::WHITE,
         css::{ANTIQUE_WHITE, DARK_GREEN},
@@ -83,7 +83,10 @@ fn main() {
             ..default()
         }))
         .add_systems(Startup, (setup_assets, setup_scene, setup_ui))
-        .add_systems(Update, init_animations.before(animate_targets))
+        .add_systems(
+            Update,
+            init_animations.before(animate_targets_and_trigger_events),
+        )
         .add_systems(
             Update,
             (handle_weight_drag, update_ui, sync_weights).chain(),
diff --git a/examples/animation/animation_triggers.rs b/examples/animation/animation_triggers.rs
index e37df7ad0f4e6..006e7bdb57873 100644
--- a/examples/animation/animation_triggers.rs
+++ b/examples/animation/animation_triggers.rs
@@ -1,15 +1,58 @@
-use bevy::prelude::*;
+//! blabla
+
+use bevy::{
+    animation::{
+        triggers::{AnimationEvent, ReflectAnimationEvent},
+        AnimationTarget, AnimationTargetId,
+    },
+    prelude::*,
+};
 
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
         .add_systems(Startup, setup)
-        .add_systems(Update, update)
+        .register_type::<Say>()
+        .observe(Say::observer)
         .run();
 }
 
-fn setup() {
-    println!("HI!");
+#[derive(Event, Reflect, Clone)]
+#[reflect(AnimationEvent)]
+enum Say {
+    Hello,
+    Bye,
+}
+
+impl Say {
+    fn observer(trigger: Trigger<Self>) {
+        match trigger.event() {
+            Say::Hello => println!("HELLO!"),
+            Say::Bye => println!("BYE!"),
+        }
+    }
 }
 
-fn update() {}
+impl AnimationEvent for Say {}
+
+fn setup(
+    mut commands: Commands,
+    mut animations: ResMut<Assets<AnimationClip>>,
+    mut graphs: ResMut<Assets<AnimationGraph>>,
+) {
+    let mut animation = AnimationClip::default();
+
+    let name = Name::new("abc");
+    let id = AnimationTargetId::from(&name);
+    animation.add_trigger(id, 1.0, Say::Hello);
+    animation.add_trigger(id, 2.0, Say::Bye);
+
+    let (graph, animation_index) = AnimationGraph::from_clip(animations.add(animation));
+    let mut player = AnimationPlayer::default();
+    player.play(animation_index).repeat();
+
+    let player = commands.spawn((name, graphs.add(graph), player)).id();
+    commands
+        .entity(player)
+        .insert(AnimationTarget { id, player });
+}

From 3d067ccce8fe20ac88884e03b4592c525b09670e Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Mon, 30 Sep 2024 15:56:32 +0200
Subject: [PATCH 04/89] make target_id optional + rename example

---
 Cargo.toml                                    | 10 +--
 crates/bevy_animation/src/lib.rs              | 80 ++++++++++++++-----
 crates/bevy_animation/src/triggers.rs         |  2 +-
 ...mation_triggers.rs => animation_events.rs} |  6 +-
 4 files changed, 67 insertions(+), 31 deletions(-)
 rename examples/animation/{animation_triggers.rs => animation_events.rs} (89%)

diff --git a/Cargo.toml b/Cargo.toml
index 6c8b6f6394c07..636305407d88c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1171,13 +1171,13 @@ hidden = true
 
 # Animation
 [[example]]
-name = "animation_triggers"
-path = "examples/animation/animation_triggers.rs"
+name = "animation_events"
+path = "examples/animation/animation_events.rs"
 doc-scrape-examples = true
 
-[package.metadata.example.animation_triggers]
-name = "Animation Triggers"
-description = "blablabla"
+[package.metadata.example.animation_events]
+name = "Animation Events"
+description = "TODO: add description"
 category = "Animation"
 wasm = true
 
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 3b0217f74b4ca..54c8cf2656d3c 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -474,7 +474,8 @@ pub struct AnimationClip {
     duration: f32,
 }
 
-pub(crate) type AnimationTriggers = HashMap<AnimationTargetId, Vec<(f32, AnimationTriggerData)>>;
+pub(crate) type AnimationTriggers =
+    HashMap<Option<AnimationTargetId>, Vec<(f32, AnimationTriggerData)>>;
 
 /// A mapping from [`AnimationTargetId`] (e.g. bone in a skinned mesh) to the
 /// animation curves.
@@ -610,7 +611,7 @@ impl AnimationClip {
     /// The `event` will trigger on the entity matching the target once the `time` is reached in the animation.
     pub fn add_trigger(
         &mut self,
-        target_id: AnimationTargetId,
+        target_id: Option<AnimationTargetId>,
         time: f32,
         event: impl AnimationEvent,
     ) {
@@ -1133,6 +1134,57 @@ pub type AnimationEntityMut<'w> = EntityMutExcept<
     ),
 >;
 
+fn for_each_animation_event<'a, 'b>(
+    target_id: Option<AnimationTargetId>,
+    clip: &'a AnimationClip,
+    animation: &ActiveAnimation,
+    mut f: impl FnMut(f32, Box<dyn PartialReflect>),
+) {
+    for (t, e) in clip
+        .triggers
+        .get(&target_id)
+        .iter()
+        .flat_map(|t| t.iter())
+        .filter(|(t, _)| match animation.is_playback_reversed() {
+            true => {
+                *t >= animation.seek_time
+                    && (animation.just_completed || Some(*t) < animation.last_seek_time)
+            }
+            false => {
+                Some(*t) > animation.last_seek_time
+                    && (animation.just_completed || *t <= animation.seek_time)
+            }
+        })
+    {
+        f(*t, e.0.clone_value())
+    }
+}
+
+fn trigger_untargeted_animation_events(
+    mut commands: Commands,
+    clips: Res<Assets<AnimationClip>>,
+    graphs: Res<Assets<AnimationGraph>>,
+    players: Query<(Entity, &AnimationPlayer, &Handle<AnimationGraph>)>,
+) {
+    for (entity, player, graph_id) in &players {
+        // The graph might not have loaded yet. Safely bail.
+        let Some(graph) = graphs.get(graph_id) else {
+            return;
+        };
+
+        for (index, animation) in player.active_animations.iter() {
+            let Some(clip_id) = graph.get(*index).unwrap().clip.as_ref() else {
+                continue;
+            };
+            let clip = clips.get(clip_id).unwrap();
+            for_each_animation_event(None, clip, animation, |_, event| {
+                dbg!(animation.seek_time);
+                commands.queue(trigger_animation_event(event, entity));
+            });
+        }
+    }
+}
+
 /// A system that modifies animation targets (e.g. bones in a skinned mesh)
 /// according to the currently-playing animations.
 ///
@@ -1220,29 +1272,12 @@ pub fn animate_targets_and_trigger_events(
                     continue;
                 };
 
-                for (_time, event) in clip
-                    .triggers
-                    .get(&target_id)
-                    .iter()
-                    .flat_map(|t| t.iter())
-                    .filter(|(t, _)| match active_animation.is_playback_reversed() {
-                        true => {
-                            *t >= active_animation.seek_time
-                                && (active_animation.just_completed
-                                    || Some(*t) < active_animation.last_seek_time)
-                        }
-                        false => {
-                            Some(*t) > active_animation.last_seek_time
-                                && (active_animation.just_completed
-                                    || *t <= active_animation.seek_time)
-                        }
-                    })
-                {
+                for_each_animation_event(Some(target_id), clip, active_animation, |_, event| {
                     dbg!(active_animation.seek_time);
                     par_commands.command_scope(|mut commands| {
-                        commands.queue(trigger_animation_event(event.0.clone_value(), entity));
+                        commands.queue(trigger_animation_event(event, entity));
                     })
-                }
+                });
 
                 let Some(curves) = clip.curves_for_target(target_id) else {
                     continue;
@@ -1313,6 +1348,7 @@ impl Plugin for AnimationPlugin {
                 (
                     advance_transitions,
                     advance_animations,
+                    trigger_untargeted_animation_events,
                     // TODO: `animate_targets` can animate anything, so
                     // ambiguity testing currently considers it ambiguous with
                     // every other system in `PostUpdate`. We may want to move
diff --git a/crates/bevy_animation/src/triggers.rs b/crates/bevy_animation/src/triggers.rs
index e75ce613df76f..ebca48da32b37 100644
--- a/crates/bevy_animation/src/triggers.rs
+++ b/crates/bevy_animation/src/triggers.rs
@@ -1,4 +1,4 @@
-use std::any::{Any, TypeId};
+use std::any::Any;
 
 use bevy_ecs::prelude::*;
 use bevy_reflect::{
diff --git a/examples/animation/animation_triggers.rs b/examples/animation/animation_events.rs
similarity index 89%
rename from examples/animation/animation_triggers.rs
rename to examples/animation/animation_events.rs
index 006e7bdb57873..559385efc5746 100644
--- a/examples/animation/animation_triggers.rs
+++ b/examples/animation/animation_events.rs
@@ -1,4 +1,4 @@
-//! blabla
+// TODO: rename to animation_events
 
 use bevy::{
     animation::{
@@ -44,8 +44,8 @@ fn setup(
 
     let name = Name::new("abc");
     let id = AnimationTargetId::from(&name);
-    animation.add_trigger(id, 1.0, Say::Hello);
-    animation.add_trigger(id, 2.0, Say::Bye);
+    animation.add_trigger(Some(id), 1.0, Say::Hello);
+    animation.add_trigger(Some(id), 2.0, Say::Bye);
 
     let (graph, animation_index) = AnimationGraph::from_clip(animations.add(animation));
     let mut player = AnimationPlayer::default();

From a34e47a19cf698fb9220ebd0601fb30f0c4b5dd1 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Mon, 30 Sep 2024 15:57:01 +0200
Subject: [PATCH 05/89] add animation events to animated_fox

---
 examples/animation/animated_fox.rs | 30 +++++++++++++++++++++++++++++-
 1 file changed, 29 insertions(+), 1 deletion(-)

diff --git a/examples/animation/animated_fox.rs b/examples/animation/animated_fox.rs
index 06fd14ee3c2bc..81ba89e2b0513 100644
--- a/examples/animation/animated_fox.rs
+++ b/examples/animation/animated_fox.rs
@@ -3,7 +3,11 @@
 use std::{f32::consts::PI, time::Duration};
 
 use bevy::{
-    animation::{animate_targets_and_trigger_events, RepeatAnimation},
+    animation::{
+        animate_targets_and_trigger_events,
+        triggers::{AnimationEvent, ReflectAnimationEvent},
+        AnimationTargetId, RepeatAnimation,
+    },
     pbr::CascadeShadowConfigBuilder,
     prelude::*,
 };
@@ -23,6 +27,8 @@ fn main() {
             setup_scene_once_loaded.before(animate_targets_and_trigger_events),
         )
         .add_systems(Update, keyboard_animation_control)
+        .observe(FoxStep::observer)
+        .register_type::<FoxStep>()
         .run();
 }
 
@@ -99,14 +105,36 @@ fn setup(
     println!("  - return: change animation");
 }
 
+#[derive(Event, Reflect, Clone)]
+#[reflect(AnimationEvent)]
+struct FoxStep;
+
+impl FoxStep {
+    fn observer(_: Trigger<Self>) {
+        println!("STEP!!!");
+    }
+}
+
+impl AnimationEvent for FoxStep {}
+
 // An `AnimationPlayer` is automatically added to the scene when it's ready.
 // When the player is added, start the animation.
 fn setup_scene_once_loaded(
     mut commands: Commands,
     animations: Res<Animations>,
+    mut clips: ResMut<Assets<AnimationClip>>,
+    graphs: Res<Assets<AnimationGraph>>,
     mut players: Query<(Entity, &mut AnimationPlayer), Added<AnimationPlayer>>,
 ) {
     for (entity, mut player) in &mut players {
+        let graph = graphs.get(&animations.graph).unwrap();
+        let node = graph.get(animations.animations[0]).unwrap();
+        let clip = clips.get_mut(node.clip.as_ref().unwrap()).unwrap();
+        clip.add_trigger(None, 0.46, FoxStep);
+        clip.add_trigger(None, 0.64, FoxStep);
+        clip.add_trigger(None, 0.02, FoxStep);
+        clip.add_trigger(None, 0.14, FoxStep);
+
         let mut transitions = AnimationTransitions::new();
 
         // Make sure to start the animation via the `AnimationTransitions`

From 6df2bf7b95a374b02fb93f74fed073056e0f297b Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Mon, 30 Sep 2024 15:59:51 +0200
Subject: [PATCH 06/89] new add_trigger method variant

---
 crates/bevy_animation/src/lib.rs       | 16 +++++++++++++---
 examples/animation/animated_fox.rs     |  8 ++++----
 examples/animation/animation_events.rs |  4 ++--
 3 files changed, 19 insertions(+), 9 deletions(-)

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 54c8cf2656d3c..5dea4a5827969 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -609,14 +609,24 @@ impl AnimationClip {
     /// Add an [`AnimationTrigger`] to an [`AnimationTarget`] named by an [`AnimationTargetId`].
     ///
     /// The `event` will trigger on the entity matching the target once the `time` is reached in the animation.
-    pub fn add_trigger(
+    pub fn add_trigger_with_id(
         &mut self,
-        target_id: Option<AnimationTargetId>,
+        target_id: AnimationTargetId,
         time: f32,
         event: impl AnimationEvent,
     ) {
         self.duration = self.duration.max(time);
-        let triggers = self.triggers.entry(target_id).or_default();
+        let triggers = self.triggers.entry(Some(target_id)).or_default();
+        triggers.push((time, AnimationTriggerData::new(event)));
+        triggers.sort_by_key(|(k, _)| FloatOrd(*k));
+    }
+
+    /// Add an [`AnimationTrigger`] to an [`AnimationTarget`] named by an [`AnimationTargetId`].
+    ///
+    /// The `event` will trigger on the entity matching the target once the `time` is reached in the animation.
+    pub fn add_trigger(&mut self, time: f32, event: impl AnimationEvent) {
+        self.duration = self.duration.max(time);
+        let triggers = self.triggers.entry(None).or_default();
         triggers.push((time, AnimationTriggerData::new(event)));
         triggers.sort_by_key(|(k, _)| FloatOrd(*k));
     }
diff --git a/examples/animation/animated_fox.rs b/examples/animation/animated_fox.rs
index 81ba89e2b0513..32cfdd2e4f0c5 100644
--- a/examples/animation/animated_fox.rs
+++ b/examples/animation/animated_fox.rs
@@ -130,10 +130,10 @@ fn setup_scene_once_loaded(
         let graph = graphs.get(&animations.graph).unwrap();
         let node = graph.get(animations.animations[0]).unwrap();
         let clip = clips.get_mut(node.clip.as_ref().unwrap()).unwrap();
-        clip.add_trigger(None, 0.46, FoxStep);
-        clip.add_trigger(None, 0.64, FoxStep);
-        clip.add_trigger(None, 0.02, FoxStep);
-        clip.add_trigger(None, 0.14, FoxStep);
+        clip.add_trigger(0.46, FoxStep);
+        clip.add_trigger(0.64, FoxStep);
+        clip.add_trigger(0.02, FoxStep);
+        clip.add_trigger(0.14, FoxStep);
 
         let mut transitions = AnimationTransitions::new();
 
diff --git a/examples/animation/animation_events.rs b/examples/animation/animation_events.rs
index 559385efc5746..40f179479c5cd 100644
--- a/examples/animation/animation_events.rs
+++ b/examples/animation/animation_events.rs
@@ -44,8 +44,8 @@ fn setup(
 
     let name = Name::new("abc");
     let id = AnimationTargetId::from(&name);
-    animation.add_trigger(Some(id), 1.0, Say::Hello);
-    animation.add_trigger(Some(id), 2.0, Say::Bye);
+    animation.add_trigger_with_id(id, 1.0, Say::Hello);
+    animation.add_trigger_with_id(id, 2.0, Say::Bye);
 
     let (graph, animation_index) = AnimationGraph::from_clip(animations.add(animation));
     let mut player = AnimationPlayer::default();

From 44a228fb83ea3d184e66d3383fe4b868886bb205 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Mon, 30 Sep 2024 16:07:01 +0200
Subject: [PATCH 07/89] rename trigger -> event

---
 .../src/{triggers.rs => events.rs}            | 20 +++++++++----------
 crates/bevy_animation/src/lib.rs              | 14 ++++++-------
 examples/animation/animated_fox.rs            | 10 +++++-----
 examples/animation/animation_events.rs        |  6 +++---
 4 files changed, 25 insertions(+), 25 deletions(-)
 rename crates/bevy_animation/src/{triggers.rs => events.rs} (93%)

diff --git a/crates/bevy_animation/src/triggers.rs b/crates/bevy_animation/src/events.rs
similarity index 93%
rename from crates/bevy_animation/src/triggers.rs
rename to crates/bevy_animation/src/events.rs
index ebca48da32b37..66f02a9fc9470 100644
--- a/crates/bevy_animation/src/triggers.rs
+++ b/crates/bevy_animation/src/events.rs
@@ -80,21 +80,21 @@ impl<T: AnimationEvent> FromType<T> for ReflectAnimationEvent {
 }
 
 #[derive(TypePath, Debug)]
-pub(crate) struct AnimationTriggerData(pub(crate) Box<dyn PartialReflect>);
+pub(crate) struct AnimationEventData(pub(crate) Box<dyn PartialReflect>);
 
-impl AnimationTriggerData {
+impl AnimationEventData {
     pub(crate) fn new(event: impl Event + PartialReflect) -> Self {
         Self(Box::new(event))
     }
 }
 
-impl Clone for AnimationTriggerData {
+impl Clone for AnimationEventData {
     fn clone(&self) -> Self {
         Self(self.0.clone_value())
     }
 }
 
-impl GetTypeRegistration for AnimationTriggerData {
+impl GetTypeRegistration for AnimationEventData {
     fn get_type_registration() -> TypeRegistration {
         let mut registration = TypeRegistration::of::<Self>();
         registration.insert::<ReflectFromPtr>(FromType::<Self>::from_type());
@@ -102,7 +102,7 @@ impl GetTypeRegistration for AnimationTriggerData {
     }
 }
 
-impl Typed for AnimationTriggerData {
+impl Typed for AnimationEventData {
     fn type_info() -> &'static TypeInfo {
         static CELL: NonGenericTypeInfoCell = NonGenericTypeInfoCell::new();
         CELL.get_or_set(|| {
@@ -111,7 +111,7 @@ impl Typed for AnimationTriggerData {
     }
 }
 
-impl TupleStruct for AnimationTriggerData {
+impl TupleStruct for AnimationEventData {
     fn field(&self, index: usize) -> Option<&dyn PartialReflect> {
         match index {
             0 => Some(self.0.as_partial_reflect()),
@@ -139,7 +139,7 @@ impl TupleStruct for AnimationTriggerData {
     }
 }
 
-impl PartialReflect for AnimationTriggerData {
+impl PartialReflect for AnimationEventData {
     #[inline]
     fn get_represented_type_info(&self) -> Option<&'static TypeInfo> {
         Some(<Self as Typed>::type_info())
@@ -207,7 +207,7 @@ impl PartialReflect for AnimationTriggerData {
     }
 }
 
-impl Reflect for AnimationTriggerData {
+impl Reflect for AnimationEventData {
     #[inline]
     fn into_any(self: Box<Self>) -> Box<dyn Any> {
         self
@@ -245,8 +245,8 @@ impl Reflect for AnimationTriggerData {
     }
 }
 
-impl FromReflect for AnimationTriggerData {
+impl FromReflect for AnimationEventData {
     fn from_reflect(reflect: &dyn PartialReflect) -> Option<Self> {
-        Some(reflect.try_downcast_ref::<AnimationTriggerData>()?.clone())
+        Some(reflect.try_downcast_ref::<AnimationEventData>()?.clone())
     }
 }
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 5dea4a5827969..79b94b3b99880 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -10,10 +10,10 @@
 extern crate alloc;
 
 pub mod animatable;
+pub mod events;
 pub mod graph;
 pub mod keyframes;
 pub mod transition;
-pub mod triggers;
 mod util;
 
 use alloc::collections::BTreeMap;
@@ -24,7 +24,7 @@ use core::{
     hash::{Hash, Hasher},
     iter,
 };
-use triggers::{trigger_animation_event, AnimationEvent, AnimationTriggerData};
+use events::{trigger_animation_event, AnimationEvent, AnimationEventData};
 
 use bevy_app::{App, Plugin, PostUpdate};
 use bevy_asset::{Asset, AssetApp, Assets, Handle};
@@ -475,7 +475,7 @@ pub struct AnimationClip {
 }
 
 pub(crate) type AnimationTriggers =
-    HashMap<Option<AnimationTargetId>, Vec<(f32, AnimationTriggerData)>>;
+    HashMap<Option<AnimationTargetId>, Vec<(f32, AnimationEventData)>>;
 
 /// A mapping from [`AnimationTargetId`] (e.g. bone in a skinned mesh) to the
 /// animation curves.
@@ -609,7 +609,7 @@ impl AnimationClip {
     /// Add an [`AnimationTrigger`] to an [`AnimationTarget`] named by an [`AnimationTargetId`].
     ///
     /// The `event` will trigger on the entity matching the target once the `time` is reached in the animation.
-    pub fn add_trigger_with_id(
+    pub fn add_event_with_id(
         &mut self,
         target_id: AnimationTargetId,
         time: f32,
@@ -617,17 +617,17 @@ impl AnimationClip {
     ) {
         self.duration = self.duration.max(time);
         let triggers = self.triggers.entry(Some(target_id)).or_default();
-        triggers.push((time, AnimationTriggerData::new(event)));
+        triggers.push((time, AnimationEventData::new(event)));
         triggers.sort_by_key(|(k, _)| FloatOrd(*k));
     }
 
     /// Add an [`AnimationTrigger`] to an [`AnimationTarget`] named by an [`AnimationTargetId`].
     ///
     /// The `event` will trigger on the entity matching the target once the `time` is reached in the animation.
-    pub fn add_trigger(&mut self, time: f32, event: impl AnimationEvent) {
+    pub fn add_event(&mut self, time: f32, event: impl AnimationEvent) {
         self.duration = self.duration.max(time);
         let triggers = self.triggers.entry(None).or_default();
-        triggers.push((time, AnimationTriggerData::new(event)));
+        triggers.push((time, AnimationEventData::new(event)));
         triggers.sort_by_key(|(k, _)| FloatOrd(*k));
     }
 }
diff --git a/examples/animation/animated_fox.rs b/examples/animation/animated_fox.rs
index 32cfdd2e4f0c5..8868f0220ac2e 100644
--- a/examples/animation/animated_fox.rs
+++ b/examples/animation/animated_fox.rs
@@ -5,7 +5,7 @@ use std::{f32::consts::PI, time::Duration};
 use bevy::{
     animation::{
         animate_targets_and_trigger_events,
-        triggers::{AnimationEvent, ReflectAnimationEvent},
+        events::{AnimationEvent, ReflectAnimationEvent},
         AnimationTargetId, RepeatAnimation,
     },
     pbr::CascadeShadowConfigBuilder,
@@ -130,10 +130,10 @@ fn setup_scene_once_loaded(
         let graph = graphs.get(&animations.graph).unwrap();
         let node = graph.get(animations.animations[0]).unwrap();
         let clip = clips.get_mut(node.clip.as_ref().unwrap()).unwrap();
-        clip.add_trigger(0.46, FoxStep);
-        clip.add_trigger(0.64, FoxStep);
-        clip.add_trigger(0.02, FoxStep);
-        clip.add_trigger(0.14, FoxStep);
+        clip.add_event(0.46, FoxStep);
+        clip.add_event(0.64, FoxStep);
+        clip.add_event(0.02, FoxStep);
+        clip.add_event(0.14, FoxStep);
 
         let mut transitions = AnimationTransitions::new();
 
diff --git a/examples/animation/animation_events.rs b/examples/animation/animation_events.rs
index 40f179479c5cd..6f85e35390ec6 100644
--- a/examples/animation/animation_events.rs
+++ b/examples/animation/animation_events.rs
@@ -2,7 +2,7 @@
 
 use bevy::{
     animation::{
-        triggers::{AnimationEvent, ReflectAnimationEvent},
+        events::{AnimationEvent, ReflectAnimationEvent},
         AnimationTarget, AnimationTargetId,
     },
     prelude::*,
@@ -44,8 +44,8 @@ fn setup(
 
     let name = Name::new("abc");
     let id = AnimationTargetId::from(&name);
-    animation.add_trigger_with_id(id, 1.0, Say::Hello);
-    animation.add_trigger_with_id(id, 2.0, Say::Bye);
+    animation.add_event_with_id(id, 1.0, Say::Hello);
+    animation.add_event_with_id(id, 2.0, Say::Bye);
 
     let (graph, animation_index) = AnimationGraph::from_clip(animations.add(animation));
     let mut player = AnimationPlayer::default();

From 578f5792bf58b4d91b6e21811da47c3ef3915ee0 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Mon, 30 Sep 2024 16:39:47 +0200
Subject: [PATCH 08/89] add some docs

---
 Cargo.toml                             | 2 +-
 crates/bevy_animation/src/events.rs    | 3 +++
 crates/bevy_animation/src/lib.rs       | 8 +++++---
 examples/animation/animation_events.rs | 2 +-
 4 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 636305407d88c..dbea9ec30b57b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1177,7 +1177,7 @@ doc-scrape-examples = true
 
 [package.metadata.example.animation_events]
 name = "Animation Events"
-description = "TODO: add description"
+description = "Demonstrate how to use animation events"
 category = "Animation"
 wasm = true
 
diff --git a/crates/bevy_animation/src/events.rs b/crates/bevy_animation/src/events.rs
index 66f02a9fc9470..e7a41a9502fe9 100644
--- a/crates/bevy_animation/src/events.rs
+++ b/crates/bevy_animation/src/events.rs
@@ -7,6 +7,7 @@ use bevy_reflect::{
     TupleStructFieldIter, TupleStructInfo, TypeInfo, TypeRegistration, Typed, UnnamedField,
 };
 
+// TODO: make a struct
 pub(crate) fn trigger_animation_event(
     event: Box<dyn PartialReflect>,
     entity: Entity,
@@ -52,6 +53,7 @@ pub(crate) fn trigger_animation_event(
     }
 }
 
+/// An event that can be used with animations.
 pub trait AnimationEvent: Event + Reflect + Clone {}
 
 #[derive(Clone)]
@@ -79,6 +81,7 @@ impl<T: AnimationEvent> FromType<T> for ReflectAnimationEvent {
     }
 }
 
+/// The data that will be used to trigger an animation event.
 #[derive(TypePath, Debug)]
 pub(crate) struct AnimationEventData(pub(crate) Box<dyn PartialReflect>);
 
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 79b94b3b99880..2b30b84820bc3 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -606,7 +606,7 @@ impl AnimationClip {
         self.curves.entry(target_id).or_default().push(curve);
     }
 
-    /// Add an [`AnimationTrigger`] to an [`AnimationTarget`] named by an [`AnimationTargetId`].
+    /// Add an [`AnimationEvent`] to an [`AnimationTarget`] named by an [`AnimationTargetId`].
     ///
     /// The `event` will trigger on the entity matching the target once the `time` is reached in the animation.
     pub fn add_event_with_id(
@@ -621,9 +621,9 @@ impl AnimationClip {
         triggers.sort_by_key(|(k, _)| FloatOrd(*k));
     }
 
-    /// Add an [`AnimationTrigger`] to an [`AnimationTarget`] named by an [`AnimationTargetId`].
+    /// Add a untargeted [`AnimationEvent`] to this [`AnimationClip`].
     ///
-    /// The `event` will trigger on the entity matching the target once the `time` is reached in the animation.
+    /// The `event` will trigger on the [`AnimationPlayer`] entity once the `time` is reached in the animation.
     pub fn add_event(&mut self, time: f32, event: impl AnimationEvent) {
         self.duration = self.duration.max(time);
         let triggers = self.triggers.entry(None).or_default();
@@ -1144,6 +1144,7 @@ pub type AnimationEntityMut<'w> = EntityMutExcept<
     ),
 >;
 
+///
 fn for_each_animation_event<'a, 'b>(
     target_id: Option<AnimationTargetId>,
     clip: &'a AnimationClip,
@@ -1170,6 +1171,7 @@ fn for_each_animation_event<'a, 'b>(
     }
 }
 
+/// A system that triggers untargeted animation events for the currently-playing animations.
 fn trigger_untargeted_animation_events(
     mut commands: Commands,
     clips: Res<Assets<AnimationClip>>,
diff --git a/examples/animation/animation_events.rs b/examples/animation/animation_events.rs
index 6f85e35390ec6..b22eaa9736277 100644
--- a/examples/animation/animation_events.rs
+++ b/examples/animation/animation_events.rs
@@ -1,4 +1,4 @@
-// TODO: rename to animation_events
+//! Demonstrate how to use animation events.
 
 use bevy::{
     animation::{

From e9c5af1cc174877df660ce0221fed6cc6d49b915 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Mon, 30 Sep 2024 16:54:40 +0200
Subject: [PATCH 09/89] update examples readme

---
 examples/README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/examples/README.md b/examples/README.md
index 96b7c577a4417..83d463b4eca8f 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -189,6 +189,7 @@ Example | Description
 [Animated Fox](../examples/animation/animated_fox.rs) | Plays an animation from a skinned glTF
 [Animated Transform](../examples/animation/animated_transform.rs) | Create and play an animation defined by code that operates on the `Transform` component
 [Animated UI](../examples/animation/animated_ui.rs) | Shows how to use animation clips to animate UI properties
+[Animation Events](../examples/animation/animation_events.rs) | Demonstrate how to use animation events
 [Animation Graph](../examples/animation/animation_graph.rs) | Blends multiple animations together with a graph
 [Animation Masks](../examples/animation/animation_masks.rs) | Demonstrates animation masks
 [Color animation](../examples/animation/color_animation.rs) | Demonstrates how to animate colors using mixing and splines in different color spaces

From 463a3b02169fcf007599359421c2e34ce941e22f Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Mon, 30 Sep 2024 17:28:07 +0200
Subject: [PATCH 10/89] edit comments

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

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 2b30b84820bc3..c430a51e906d0 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -1144,7 +1144,6 @@ pub type AnimationEntityMut<'w> = EntityMutExcept<
     ),
 >;
 
-///
 fn for_each_animation_event<'a, 'b>(
     target_id: Option<AnimationTargetId>,
     clip: &'a AnimationClip,
@@ -1156,6 +1155,7 @@ fn for_each_animation_event<'a, 'b>(
         .get(&target_id)
         .iter()
         .flat_map(|t| t.iter())
+        // filter out events that did not occur this tick
         .filter(|(t, _)| match animation.is_playback_reversed() {
             true => {
                 *t >= animation.seek_time

From 841e5171f718768eff0cf8e9f2d61fe27bad93b0 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Mon, 30 Sep 2024 20:36:29 +0200
Subject: [PATCH 11/89] use Box<dyn AnimationEvent>

---
 crates/bevy_animation/src/events.rs    | 89 +++++++-------------------
 crates/bevy_animation/src/lib.rs       | 10 +--
 examples/animation/animated_fox.rs     | 10 ++-
 examples/animation/animation_events.rs | 10 ++-
 4 files changed, 45 insertions(+), 74 deletions(-)

diff --git a/crates/bevy_animation/src/events.rs b/crates/bevy_animation/src/events.rs
index e7a41a9502fe9..f164ee9f58425 100644
--- a/crates/bevy_animation/src/events.rs
+++ b/crates/bevy_animation/src/events.rs
@@ -1,4 +1,4 @@
-use std::any::Any;
+use std::{any::Any, fmt::Debug};
 
 use bevy_ecs::prelude::*;
 use bevy_reflect::{
@@ -7,93 +7,47 @@ use bevy_reflect::{
     TupleStructFieldIter, TupleStructInfo, TypeInfo, TypeRegistration, Typed, UnnamedField,
 };
 
-// TODO: make a struct
 pub(crate) fn trigger_animation_event(
-    event: Box<dyn PartialReflect>,
+    event: Box<dyn AnimationEvent>,
     entity: Entity,
 ) -> impl Command {
     move |world: &mut World| {
-        let (from_reflect, animation_event) = {
-            let registry = world
-                .get_resource::<AppTypeRegistry>()
-                .expect("Missing resource `AppTypeRegistry`");
-            let lock = registry.read();
-            let type_info = event.get_represented_type_info().unwrap(); // FIXME: when would this fail?
-            let registration = lock
-                .get_with_type_path(type_info.type_path())
-                .unwrap_or_else(|| {
-                    panic!(
-                        "Missing type registration for type: `{}`",
-                        type_info.type_path()
-                    )
-                });
-            (
-                registration
-                    .data::<ReflectFromReflect>()
-                    .cloned()
-                    .unwrap_or_else(|| {
-                        panic!(
-                            "Type `{}` is not registered with data: `ReflectFromReflect`",
-                            type_info.type_path()
-                        )
-                    }),
-                registration
-                    .data::<ReflectAnimationEvent>()
-                    .cloned()
-                    .unwrap_or_else(|| {
-                        panic!(
-                            "Type `{}` is not registered with data: `ReflectAnimationEvent`",
-                            type_info.type_path()
-                        )
-                    }),
-            )
-        };
-        let event = from_reflect.from_reflect(event.as_ref()).unwrap(); // FIXME: when would this fail?
-        animation_event.trigger(event.as_ref(), entity, world);
+        event.trigger(entity, world);
     }
 }
 
 /// An event that can be used with animations.
-pub trait AnimationEvent: Event + Reflect + Clone {}
+#[reflect_trait]
+pub trait AnimationEvent: Reflect + Send + Sync {
+    /// Trigger the event, targeting `entity`.
+    fn trigger(&self, entity: Entity, world: &mut World);
 
-#[derive(Clone)]
-pub struct ReflectAnimationEvent {
-    trigger: fn(&dyn Reflect, Entity, &mut World),
+    /// Clone this value into a new `Box<dyn AnimationEvent>`
+    fn clone_value(&self) -> Box<dyn AnimationEvent>;
 }
 
-impl ReflectAnimationEvent {
-    /// # Panics
-    ///
-    /// Panics if the underlying type of `event` does not match the type this `ReflectAnimationEvent` was constructed for.
-    pub(crate) fn trigger(&self, event: &dyn Reflect, entity: Entity, world: &mut World) {
-        (self.trigger)(event, entity, world)
-    }
-}
-
-impl<T: AnimationEvent> FromType<T> for ReflectAnimationEvent {
-    fn from_type() -> Self {
-        Self {
-            trigger: |value, entity, world| {
-                let event = value.downcast_ref::<T>().unwrap().clone();
-                world.entity_mut(entity).trigger(event);
-            },
-        }
+/// The data that will be used to trigger an animation event.
+#[derive(TypePath)]
+pub(crate) struct AnimationEventData(pub(crate) Box<dyn AnimationEvent>);
+
+impl Debug for AnimationEventData {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str("AnimationEventData(")?;
+        PartialReflect::debug(self.0.as_ref(), f)?;
+        f.write_str(")")?;
+        Ok(())
     }
 }
 
-/// The data that will be used to trigger an animation event.
-#[derive(TypePath, Debug)]
-pub(crate) struct AnimationEventData(pub(crate) Box<dyn PartialReflect>);
-
 impl AnimationEventData {
-    pub(crate) fn new(event: impl Event + PartialReflect) -> Self {
+    pub(crate) fn new(event: impl AnimationEvent) -> Self {
         Self(Box::new(event))
     }
 }
 
 impl Clone for AnimationEventData {
     fn clone(&self) -> Self {
-        Self(self.0.clone_value())
+        Self(AnimationEvent::clone_value(self.0.as_ref()))
     }
 }
 
@@ -101,6 +55,7 @@ impl GetTypeRegistration for AnimationEventData {
     fn get_type_registration() -> TypeRegistration {
         let mut registration = TypeRegistration::of::<Self>();
         registration.insert::<ReflectFromPtr>(FromType::<Self>::from_type());
+        registration.insert::<ReflectFromReflect>(FromType::<Self>::from_type());
         registration
     }
 }
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index c430a51e906d0..8518deb0ac6f0 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -1144,11 +1144,11 @@ pub type AnimationEntityMut<'w> = EntityMutExcept<
     ),
 >;
 
-fn for_each_animation_event<'a, 'b>(
+fn for_each_animation_event(
     target_id: Option<AnimationTargetId>,
-    clip: &'a AnimationClip,
+    clip: &AnimationClip,
     animation: &ActiveAnimation,
-    mut f: impl FnMut(f32, Box<dyn PartialReflect>),
+    mut f: impl FnMut(f32, Box<dyn AnimationEvent>),
 ) {
     for (t, e) in clip
         .triggers
@@ -1167,7 +1167,7 @@ fn for_each_animation_event<'a, 'b>(
             }
         })
     {
-        f(*t, e.0.clone_value())
+        f(*t, e.clone().0);
     }
 }
 
@@ -1288,7 +1288,7 @@ pub fn animate_targets_and_trigger_events(
                     dbg!(active_animation.seek_time);
                     par_commands.command_scope(|mut commands| {
                         commands.queue(trigger_animation_event(event, entity));
-                    })
+                    });
                 });
 
                 let Some(curves) = clip.curves_for_target(target_id) else {
diff --git a/examples/animation/animated_fox.rs b/examples/animation/animated_fox.rs
index 8868f0220ac2e..5744634007f86 100644
--- a/examples/animation/animated_fox.rs
+++ b/examples/animation/animated_fox.rs
@@ -115,7 +115,15 @@ impl FoxStep {
     }
 }
 
-impl AnimationEvent for FoxStep {}
+impl AnimationEvent for FoxStep {
+    fn trigger(&self, entity: Entity, world: &mut World) {
+        world.entity_mut(entity).trigger(self.clone());
+    }
+
+    fn clone_value(&self) -> Box<dyn AnimationEvent> {
+        Box::new(self.clone())
+    }
+}
 
 // An `AnimationPlayer` is automatically added to the scene when it's ready.
 // When the player is added, start the animation.
diff --git a/examples/animation/animation_events.rs b/examples/animation/animation_events.rs
index b22eaa9736277..82bf4d24f7803 100644
--- a/examples/animation/animation_events.rs
+++ b/examples/animation/animation_events.rs
@@ -33,7 +33,15 @@ impl Say {
     }
 }
 
-impl AnimationEvent for Say {}
+impl AnimationEvent for Say {
+    fn trigger(&self, entity: Entity, world: &mut World) {
+        world.entity_mut(entity).trigger(self.clone());
+    }
+
+    fn clone_value(&self) -> Box<dyn AnimationEvent> {
+        Box::new(self.clone())
+    }
+}
 
 fn setup(
     mut commands: Commands,

From fce8da260b832b1484c9c6094d49f1f62b998884 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Mon, 30 Sep 2024 20:40:37 +0200
Subject: [PATCH 12/89] module doc

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

diff --git a/crates/bevy_animation/src/events.rs b/crates/bevy_animation/src/events.rs
index f164ee9f58425..a01fd360b75ed 100644
--- a/crates/bevy_animation/src/events.rs
+++ b/crates/bevy_animation/src/events.rs
@@ -1,4 +1,5 @@
 use std::{any::Any, fmt::Debug};
+//! Traits and types for triggering events from animations.
 
 use bevy_ecs::prelude::*;
 use bevy_reflect::{

From c29234339a59cc7115237f437216f7e78c02035d Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Mon, 30 Sep 2024 20:40:46 +0200
Subject: [PATCH 13/89] use core instead of std

---
 crates/bevy_animation/src/events.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/crates/bevy_animation/src/events.rs b/crates/bevy_animation/src/events.rs
index a01fd360b75ed..873c5c25ed5dd 100644
--- a/crates/bevy_animation/src/events.rs
+++ b/crates/bevy_animation/src/events.rs
@@ -1,6 +1,7 @@
-use std::{any::Any, fmt::Debug};
 //! Traits and types for triggering events from animations.
 
+use core::{any::Any, fmt::Debug};
+
 use bevy_ecs::prelude::*;
 use bevy_reflect::{
     prelude::*, utility::NonGenericTypeInfoCell, ApplyError, DynamicTupleStruct, FromType,

From 6dee939cec2cc6d6656ecdfdb4f8ac474d86083c Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Mon, 30 Sep 2024 20:45:47 +0200
Subject: [PATCH 14/89] use core instead of std (again)

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

diff --git a/crates/bevy_animation/src/events.rs b/crates/bevy_animation/src/events.rs
index 873c5c25ed5dd..838d622fced56 100644
--- a/crates/bevy_animation/src/events.rs
+++ b/crates/bevy_animation/src/events.rs
@@ -33,7 +33,7 @@ pub trait AnimationEvent: Reflect + Send + Sync {
 pub(crate) struct AnimationEventData(pub(crate) Box<dyn AnimationEvent>);
 
 impl Debug for AnimationEventData {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.write_str("AnimationEventData(")?;
         PartialReflect::debug(self.0.as_ref(), f)?;
         f.write_str(")")?;

From 8a6aabf9f12f97830eeeb53501be2d26d945389c Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Mon, 30 Sep 2024 22:15:11 +0200
Subject: [PATCH 15/89] add `AnimationTargetId::from_str`

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

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 8518deb0ac6f0..5bf8ff092b601 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -1380,6 +1380,20 @@ impl Plugin for AnimationPlugin {
 }
 
 impl AnimationTargetId {
+    ///Creates a new [`AnimationTargetId`] by hashing a string seperated by `/`.
+    ///
+    /// Typically, this will be the path from the animation root to the
+    /// animation target (e.g. bone) that is to be animated.
+    pub fn from_str(path: impl AsRef<str>) -> Self {
+        let mut blake3 = blake3::Hasher::new();
+        blake3.update(ANIMATION_TARGET_NAMESPACE.as_bytes());
+        for str in path.as_ref().split('/') {
+            blake3.update(str.as_bytes());
+        }
+        let hash = blake3.finalize().as_bytes()[0..16].try_into().unwrap();
+        Self(*uuid::Builder::from_sha1_bytes(hash).as_uuid())
+    }
+
     /// Creates a new [`AnimationTargetId`] by hashing a list of names.
     ///
     /// Typically, this will be the path from the animation root to the

From c544f7a8b6072859964a6763041b673710275d97 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Mon, 30 Sep 2024 22:15:18 +0200
Subject: [PATCH 16/89] remove dbg

---
 crates/bevy_animation/src/lib.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 5bf8ff092b601..28188a166aa3e 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -1190,7 +1190,6 @@ fn trigger_untargeted_animation_events(
             };
             let clip = clips.get(clip_id).unwrap();
             for_each_animation_event(None, clip, animation, |_, event| {
-                dbg!(animation.seek_time);
                 commands.queue(trigger_animation_event(event, entity));
             });
         }
@@ -1285,7 +1284,6 @@ pub fn animate_targets_and_trigger_events(
                 };
 
                 for_each_animation_event(Some(target_id), clip, active_animation, |_, event| {
-                    dbg!(active_animation.seek_time);
                     par_commands.command_scope(|mut commands| {
                         commands.queue(trigger_animation_event(event, entity));
                     });

From c0e6d11b58b824b024709eba437dd9c6d8c0d637 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Mon, 30 Sep 2024 22:15:31 +0200
Subject: [PATCH 17/89] update examples

---
 examples/animation/animated_fox.rs     | 122 ++++++++++++++++++++-----
 examples/animation/animation_events.rs |  16 +---
 2 files changed, 102 insertions(+), 36 deletions(-)

diff --git a/examples/animation/animated_fox.rs b/examples/animation/animated_fox.rs
index 5744634007f86..9cd171d624bf1 100644
--- a/examples/animation/animated_fox.rs
+++ b/examples/animation/animated_fox.rs
@@ -8,6 +8,7 @@ use bevy::{
         events::{AnimationEvent, ReflectAnimationEvent},
         AnimationTargetId, RepeatAnimation,
     },
+    color::palettes::css::WHITE,
     pbr::CascadeShadowConfigBuilder,
     prelude::*,
 };
@@ -21,12 +22,15 @@ fn main() {
             brightness: 2000.,
         })
         .add_plugins(DefaultPlugins)
+        .init_resource::<FoxFeetIds>()
+        .init_resource::<FoxStep>()
         .add_systems(Startup, setup)
         .add_systems(
             Update,
             setup_scene_once_loaded.before(animate_targets_and_trigger_events),
         )
         .add_systems(Update, keyboard_animation_control)
+        .add_systems(Update, update_particle)
         .observe(FoxStep::observer)
         .register_type::<FoxStep>()
         .run();
@@ -39,6 +43,81 @@ struct Animations {
     graph: Handle<AnimationGraph>,
 }
 
+#[derive(Resource)]
+struct FoxFeetIds {
+    forward_right: AnimationTargetId,
+    forward_left: AnimationTargetId,
+    back_right: AnimationTargetId,
+    back_left: AnimationTargetId,
+}
+
+impl Default for FoxFeetIds {
+    fn default() -> Self {
+        Self {
+            forward_right: AnimationTargetId::from_str("root/_rootJoint/b_Root_00/b_Hip_01/b_Spine01_02/b_Spine02_03/b_RightUpperArm_06/b_RightForeArm_07/b_RightHand_08"),
+            forward_left: AnimationTargetId::from_str("root/_rootJoint/b_Root_00/b_Hip_01/b_Spine01_02/b_Spine02_03/b_LeftUpperArm_09/b_LeftForeArm_010/b_LeftHand_011"),
+            back_right: AnimationTargetId::from_str("root/_rootJoint/b_Root_00/b_Hip_01/b_RightLeg01_019/b_RightLeg02_020/b_RightFoot01_021/b_RightFoot02_022"),
+            back_left: AnimationTargetId::from_str("root/_rootJoint/b_Root_00/b_Hip_01/b_LeftLeg01_015/b_LeftLeg02_016/b_LeftFoot01_017/b_LeftFoot02_018"),
+        }
+    }
+}
+
+#[derive(Component, Debug)]
+struct Particle {
+    size: f32,
+    lifetime: Timer,
+}
+
+#[derive(Resource, Event, Reflect, Clone)]
+#[reflect(AnimationEvent)]
+struct FoxStep {
+    mesh: Handle<Mesh>,
+    material: Handle<StandardMaterial>,
+}
+
+impl FromWorld for FoxStep {
+    fn from_world(world: &mut World) -> Self {
+        let mesh = world.resource_mut::<Assets<Mesh>>().add(Sphere::new(10.0));
+        let material = world
+            .resource_mut::<Assets<StandardMaterial>>()
+            .add(StandardMaterial::from_color(WHITE));
+        Self { mesh, material }
+    }
+}
+
+impl FoxStep {
+    fn observer(trigger: Trigger<Self>, query: Query<&GlobalTransform>, mut commands: Commands) {
+        let transform = query.get(trigger.entity()).unwrap().compute_transform();
+        commands.spawn((
+            Particle {
+                lifetime: Timer::from_seconds(1.0, TimerMode::Once),
+                size: 1.0,
+            },
+            MaterialMeshBundle {
+                mesh: trigger.event().mesh.clone(),
+                material: trigger.event().material.clone(),
+                transform: Transform {
+                    translation: transform.translation.reject_from(Vec3::Y),
+                    scale: Vec3::splat(1.0),
+                    ..Default::default()
+                },
+                ..Default::default()
+            },
+        ));
+        // println!("STEP: {}", transform.translation);
+    }
+}
+
+impl AnimationEvent for FoxStep {
+    fn trigger(&self, entity: Entity, world: &mut World) {
+        world.entity_mut(entity).trigger(self.clone());
+    }
+
+    fn clone_value(&self) -> Box<dyn AnimationEvent> {
+        Box::new(self.clone())
+    }
+}
+
 fn setup(
     mut commands: Commands,
     asset_server: Res<AssetServer>,
@@ -105,31 +184,13 @@ fn setup(
     println!("  - return: change animation");
 }
 
-#[derive(Event, Reflect, Clone)]
-#[reflect(AnimationEvent)]
-struct FoxStep;
-
-impl FoxStep {
-    fn observer(_: Trigger<Self>) {
-        println!("STEP!!!");
-    }
-}
-
-impl AnimationEvent for FoxStep {
-    fn trigger(&self, entity: Entity, world: &mut World) {
-        world.entity_mut(entity).trigger(self.clone());
-    }
-
-    fn clone_value(&self) -> Box<dyn AnimationEvent> {
-        Box::new(self.clone())
-    }
-}
-
 // An `AnimationPlayer` is automatically added to the scene when it's ready.
 // When the player is added, start the animation.
 fn setup_scene_once_loaded(
     mut commands: Commands,
     animations: Res<Animations>,
+    feet: Res<FoxFeetIds>,
+    step: Res<FoxStep>,
     mut clips: ResMut<Assets<AnimationClip>>,
     graphs: Res<Assets<AnimationGraph>>,
     mut players: Query<(Entity, &mut AnimationPlayer), Added<AnimationPlayer>>,
@@ -138,10 +199,10 @@ fn setup_scene_once_loaded(
         let graph = graphs.get(&animations.graph).unwrap();
         let node = graph.get(animations.animations[0]).unwrap();
         let clip = clips.get_mut(node.clip.as_ref().unwrap()).unwrap();
-        clip.add_event(0.46, FoxStep);
-        clip.add_event(0.64, FoxStep);
-        clip.add_event(0.02, FoxStep);
-        clip.add_event(0.14, FoxStep);
+        clip.add_event_with_id(feet.forward_right, 0.46, step.clone());
+        clip.add_event_with_id(feet.forward_left, 0.64, step.clone());
+        clip.add_event_with_id(feet.back_right, 0.14, step.clone());
+        clip.add_event_with_id(feet.back_left, 0.02, step.clone());
 
         let mut transitions = AnimationTransitions::new();
 
@@ -243,3 +304,16 @@ fn keyboard_animation_control(
         }
     }
 }
+
+fn update_particle(
+    mut commands: Commands,
+    mut query: Query<(Entity, &mut Particle, &mut Transform)>,
+    time: Res<Time>,
+) {
+    for (entity, mut particle, mut transform) in &mut query {
+        if particle.lifetime.tick(time.delta()).just_finished() {
+            commands.entity(entity).despawn();
+        }
+        transform.scale = Vec3::ONE * particle.size.lerp(0.0, particle.lifetime.fraction());
+    }
+}
diff --git a/examples/animation/animation_events.rs b/examples/animation/animation_events.rs
index 82bf4d24f7803..f77b6acc0c1b6 100644
--- a/examples/animation/animation_events.rs
+++ b/examples/animation/animation_events.rs
@@ -1,10 +1,7 @@
 //! Demonstrate how to use animation events.
 
 use bevy::{
-    animation::{
-        events::{AnimationEvent, ReflectAnimationEvent},
-        AnimationTarget, AnimationTargetId,
-    },
+    animation::events::{AnimationEvent, ReflectAnimationEvent},
     prelude::*,
 };
 
@@ -50,17 +47,12 @@ fn setup(
 ) {
     let mut animation = AnimationClip::default();
 
-    let name = Name::new("abc");
-    let id = AnimationTargetId::from(&name);
-    animation.add_event_with_id(id, 1.0, Say::Hello);
-    animation.add_event_with_id(id, 2.0, Say::Bye);
+    animation.add_event(1.0, Say::Hello);
+    animation.add_event(2.0, Say::Bye);
 
     let (graph, animation_index) = AnimationGraph::from_clip(animations.add(animation));
     let mut player = AnimationPlayer::default();
     player.play(animation_index).repeat();
 
-    let player = commands.spawn((name, graphs.add(graph), player)).id();
-    commands
-        .entity(player)
-        .insert(AnimationTarget { id, player });
+    commands.spawn((graphs.add(graph), player));
 }

From d2f1848bc50e8761f56b788b85a29ba383df561b Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Mon, 30 Sep 2024 22:38:51 +0200
Subject: [PATCH 18/89] cleanup use

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

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index bbf7e375d5870..d2d8016cc2a0c 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -10,8 +10,8 @@
 extern crate alloc;
 
 pub mod animatable;
-pub mod events;
 pub mod animation_curves;
+pub mod events;
 pub mod gltf_curves;
 pub mod graph;
 pub mod transition;
@@ -36,7 +36,7 @@ use bevy_ecs::{
     reflect::{ReflectMapEntities, ReflectVisitEntities, ReflectVisitEntitiesMut},
     world::EntityMutExcept,
 };
-use bevy_math::{FloatExt, FloatOrd};
+use bevy_math::FloatOrd;
 use bevy_reflect::{
     prelude::ReflectDefault, utility::NonGenericTypeInfoCell, ApplyError, DynamicTupleStruct,
     FromReflect, FromType, GetTypeRegistration, PartialReflect, Reflect, ReflectFromPtr,

From 1ff5b5402b5aa6d66e3d033965f048584a510807 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Mon, 30 Sep 2024 22:39:38 +0200
Subject: [PATCH 19/89] fix typo

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

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index d2d8016cc2a0c..e35a5951d295d 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -1181,7 +1181,7 @@ impl Plugin for AnimationPlugin {
 }
 
 impl AnimationTargetId {
-    ///Creates a new [`AnimationTargetId`] by hashing a string seperated by `/`.
+    ///Creates a new [`AnimationTargetId`] by hashing a string separated by `/`.
     ///
     /// Typically, this will be the path from the animation root to the
     /// animation target (e.g. bone) that is to be animated.

From 305deb81a1961987eea69a0bc5d05fc02f455527 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Mon, 30 Sep 2024 22:45:08 +0200
Subject: [PATCH 20/89] rename events -> animation_events

rename events -> animation_events

rename events -> animation_events
---
 crates/bevy_animation/src/{events.rs => animation_events.rs} | 0
 crates/bevy_animation/src/lib.rs                             | 4 ++--
 examples/animation/animated_fox.rs                           | 2 +-
 examples/animation/animation_events.rs                       | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)
 rename crates/bevy_animation/src/{events.rs => animation_events.rs} (100%)

diff --git a/crates/bevy_animation/src/events.rs b/crates/bevy_animation/src/animation_events.rs
similarity index 100%
rename from crates/bevy_animation/src/events.rs
rename to crates/bevy_animation/src/animation_events.rs
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index e35a5951d295d..69805dd1dd0c7 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -11,13 +11,14 @@ extern crate alloc;
 
 pub mod animatable;
 pub mod animation_curves;
-pub mod events;
+pub mod animation_events;
 pub mod gltf_curves;
 pub mod graph;
 pub mod transition;
 mod util;
 
 use alloc::collections::BTreeMap;
+use animation_events::{trigger_animation_event, AnimationEvent, AnimationEventData};
 use core::{
     any::{Any, TypeId},
     cell::RefCell,
@@ -25,7 +26,6 @@ use core::{
     hash::{Hash, Hasher},
     iter,
 };
-use events::{trigger_animation_event, AnimationEvent, AnimationEventData};
 
 use bevy_app::{App, Plugin, PostUpdate};
 use bevy_asset::{Asset, AssetApp, Assets, Handle};
diff --git a/examples/animation/animated_fox.rs b/examples/animation/animated_fox.rs
index 9cd171d624bf1..5bdfd2f60fba9 100644
--- a/examples/animation/animated_fox.rs
+++ b/examples/animation/animated_fox.rs
@@ -5,7 +5,7 @@ use std::{f32::consts::PI, time::Duration};
 use bevy::{
     animation::{
         animate_targets_and_trigger_events,
-        events::{AnimationEvent, ReflectAnimationEvent},
+        animation_events::{AnimationEvent, ReflectAnimationEvent},
         AnimationTargetId, RepeatAnimation,
     },
     color::palettes::css::WHITE,
diff --git a/examples/animation/animation_events.rs b/examples/animation/animation_events.rs
index f77b6acc0c1b6..6d711a90b2c4a 100644
--- a/examples/animation/animation_events.rs
+++ b/examples/animation/animation_events.rs
@@ -1,7 +1,7 @@
 //! Demonstrate how to use animation events.
 
 use bevy::{
-    animation::events::{AnimationEvent, ReflectAnimationEvent},
+    animation::animation_events::{AnimationEvent, ReflectAnimationEvent},
     prelude::*,
 };
 

From ba14f36afe5f8388f70c8e06f3f7ca0c7eb74fee Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Mon, 30 Sep 2024 23:00:02 +0200
Subject: [PATCH 21/89] from_str -> from_iter

---
 crates/bevy_animation/src/lib.rs   | 28 +++++++++---------
 examples/animation/animated_fox.rs | 46 +++++++++++++++++++++++++++---
 2 files changed, 57 insertions(+), 17 deletions(-)

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 69805dd1dd0c7..2a62aba4dab9c 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -1181,38 +1181,40 @@ impl Plugin for AnimationPlugin {
 }
 
 impl AnimationTargetId {
-    ///Creates a new [`AnimationTargetId`] by hashing a string separated by `/`.
+    /// Creates a new [`AnimationTargetId`] by hashing a list of names.
     ///
     /// Typically, this will be the path from the animation root to the
     /// animation target (e.g. bone) that is to be animated.
-    pub fn from_str(path: impl AsRef<str>) -> Self {
+    pub fn from_names<'a>(names: impl Iterator<Item = &'a Name>) -> Self {
         let mut blake3 = blake3::Hasher::new();
         blake3.update(ANIMATION_TARGET_NAMESPACE.as_bytes());
-        for str in path.as_ref().split('/') {
-            blake3.update(str.as_bytes());
+        for name in names {
+            blake3.update(name.as_bytes());
         }
         let hash = blake3.finalize().as_bytes()[0..16].try_into().unwrap();
         Self(*uuid::Builder::from_sha1_bytes(hash).as_uuid())
     }
 
-    /// Creates a new [`AnimationTargetId`] by hashing a list of names.
+    /// Creates a new [`AnimationTargetId`] by hashing a single name.
+    pub fn from_name(name: &Name) -> Self {
+        Self::from_names(iter::once(name))
+    }
+}
+
+impl<T: AsRef<str>> FromIterator<T> for AnimationTargetId {
+    /// Creates a new [`AnimationTargetId`] by hashing a list of strings.
     ///
     /// Typically, this will be the path from the animation root to the
     /// animation target (e.g. bone) that is to be animated.
-    pub fn from_names<'a>(names: impl Iterator<Item = &'a Name>) -> Self {
+    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
         let mut blake3 = blake3::Hasher::new();
         blake3.update(ANIMATION_TARGET_NAMESPACE.as_bytes());
-        for name in names {
-            blake3.update(name.as_bytes());
+        for str in iter {
+            blake3.update(str.as_ref().as_bytes());
         }
         let hash = blake3.finalize().as_bytes()[0..16].try_into().unwrap();
         Self(*uuid::Builder::from_sha1_bytes(hash).as_uuid())
     }
-
-    /// Creates a new [`AnimationTargetId`] by hashing a single name.
-    pub fn from_name(name: &Name) -> Self {
-        Self::from_names(iter::once(name))
-    }
 }
 
 impl From<&Name> for AnimationTargetId {
diff --git a/examples/animation/animated_fox.rs b/examples/animation/animated_fox.rs
index 5bdfd2f60fba9..fa4e5dbdc35cf 100644
--- a/examples/animation/animated_fox.rs
+++ b/examples/animation/animated_fox.rs
@@ -54,10 +54,48 @@ struct FoxFeetIds {
 impl Default for FoxFeetIds {
     fn default() -> Self {
         Self {
-            forward_right: AnimationTargetId::from_str("root/_rootJoint/b_Root_00/b_Hip_01/b_Spine01_02/b_Spine02_03/b_RightUpperArm_06/b_RightForeArm_07/b_RightHand_08"),
-            forward_left: AnimationTargetId::from_str("root/_rootJoint/b_Root_00/b_Hip_01/b_Spine01_02/b_Spine02_03/b_LeftUpperArm_09/b_LeftForeArm_010/b_LeftHand_011"),
-            back_right: AnimationTargetId::from_str("root/_rootJoint/b_Root_00/b_Hip_01/b_RightLeg01_019/b_RightLeg02_020/b_RightFoot01_021/b_RightFoot02_022"),
-            back_left: AnimationTargetId::from_str("root/_rootJoint/b_Root_00/b_Hip_01/b_LeftLeg01_015/b_LeftLeg02_016/b_LeftFoot01_017/b_LeftFoot02_018"),
+            forward_right: AnimationTargetId::from_iter([
+                "root",
+                "_rootJoint",
+                "b_Root_00",
+                "b_Hip_01",
+                "b_Spine01_02",
+                "b_Spine02_03",
+                "b_RightUpperArm_06",
+                "b_RightForeArm_07",
+                "b_RightHand_08",
+            ]),
+            forward_left: AnimationTargetId::from_iter([
+                "root",
+                "_rootJoint",
+                "b_Root_00",
+                "b_Hip_01",
+                "b_Spine01_02",
+                "b_Spine02_03",
+                "b_LeftUpperArm_09",
+                "b_LeftForeArm_010",
+                "b_LeftHand_011",
+            ]),
+            back_right: AnimationTargetId::from_iter([
+                "root",
+                "_rootJoint",
+                "b_Root_00",
+                "b_Hip_01",
+                "b_RightLeg01_019",
+                "b_RightLeg02_020",
+                "b_RightFoot01_021",
+                "b_RightFoot02_022",
+            ]),
+            back_left: AnimationTargetId::from_iter([
+                "root",
+                "_rootJoint",
+                "b_Root_00",
+                "b_Hip_01",
+                "b_LeftLeg01_015",
+                "b_LeftLeg02_016",
+                "b_LeftFoot01_017",
+                "b_LeftFoot02_018",
+            ]),
         }
     }
 }

From d2ed656cb1479942c29e2ec5a3a5ebe71e8f7367 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Mon, 30 Sep 2024 23:03:56 +0200
Subject: [PATCH 22/89] rename animation_events -> animation_event

cont
---
 .../src/{animation_events.rs => animation_event.rs}           | 0
 crates/bevy_animation/src/lib.rs                              | 4 ++--
 examples/animation/animated_fox.rs                            | 2 +-
 examples/animation/animation_events.rs                        | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)
 rename crates/bevy_animation/src/{animation_events.rs => animation_event.rs} (100%)

diff --git a/crates/bevy_animation/src/animation_events.rs b/crates/bevy_animation/src/animation_event.rs
similarity index 100%
rename from crates/bevy_animation/src/animation_events.rs
rename to crates/bevy_animation/src/animation_event.rs
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 2a62aba4dab9c..dd8605975536c 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -11,14 +11,14 @@ extern crate alloc;
 
 pub mod animatable;
 pub mod animation_curves;
-pub mod animation_events;
+pub mod animation_event;
 pub mod gltf_curves;
 pub mod graph;
 pub mod transition;
 mod util;
 
 use alloc::collections::BTreeMap;
-use animation_events::{trigger_animation_event, AnimationEvent, AnimationEventData};
+use animation_event::{trigger_animation_event, AnimationEvent, AnimationEventData};
 use core::{
     any::{Any, TypeId},
     cell::RefCell,
diff --git a/examples/animation/animated_fox.rs b/examples/animation/animated_fox.rs
index fa4e5dbdc35cf..c92e83c21e115 100644
--- a/examples/animation/animated_fox.rs
+++ b/examples/animation/animated_fox.rs
@@ -5,7 +5,7 @@ use std::{f32::consts::PI, time::Duration};
 use bevy::{
     animation::{
         animate_targets_and_trigger_events,
-        animation_events::{AnimationEvent, ReflectAnimationEvent},
+        animation_event::{AnimationEvent, ReflectAnimationEvent},
         AnimationTargetId, RepeatAnimation,
     },
     color::palettes::css::WHITE,
diff --git a/examples/animation/animation_events.rs b/examples/animation/animation_events.rs
index 6d711a90b2c4a..94b4a069b3290 100644
--- a/examples/animation/animation_events.rs
+++ b/examples/animation/animation_events.rs
@@ -1,7 +1,7 @@
 //! Demonstrate how to use animation events.
 
 use bevy::{
-    animation::animation_events::{AnimationEvent, ReflectAnimationEvent},
+    animation::animation_event::{AnimationEvent, ReflectAnimationEvent},
     prelude::*,
 };
 

From b5d9a87289b8fcc4812fea7ff2cf15716f8d159a Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Mon, 30 Sep 2024 23:39:44 +0200
Subject: [PATCH 23/89] reflect comments

---
 crates/bevy_animation/src/animation_event.rs | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/crates/bevy_animation/src/animation_event.rs b/crates/bevy_animation/src/animation_event.rs
index 838d622fced56..08940d1c62e1f 100644
--- a/crates/bevy_animation/src/animation_event.rs
+++ b/crates/bevy_animation/src/animation_event.rs
@@ -53,15 +53,18 @@ impl Clone for AnimationEventData {
     }
 }
 
+// We have to implement `GetTypeRegistration` manually because of the embedded
+// `Box<dyn AnimationEvent>`, which can't be automatically derived yet.
 impl GetTypeRegistration for AnimationEventData {
     fn get_type_registration() -> TypeRegistration {
         let mut registration = TypeRegistration::of::<Self>();
         registration.insert::<ReflectFromPtr>(FromType::<Self>::from_type());
-        registration.insert::<ReflectFromReflect>(FromType::<Self>::from_type());
         registration
     }
 }
 
+// We have to implement `Typed` manually because of the embedded
+// `Box<dyn AnimationEvent>`, which can't be automatically derived yet.
 impl Typed for AnimationEventData {
     fn type_info() -> &'static TypeInfo {
         static CELL: NonGenericTypeInfoCell = NonGenericTypeInfoCell::new();
@@ -71,6 +74,8 @@ impl Typed for AnimationEventData {
     }
 }
 
+// We have to implement `TupleStruct` manually because of the embedded
+// `Box<dyn AnimationEvent>`, which can't be automatically derived yet.
 impl TupleStruct for AnimationEventData {
     fn field(&self, index: usize) -> Option<&dyn PartialReflect> {
         match index {
@@ -99,6 +104,8 @@ impl TupleStruct for AnimationEventData {
     }
 }
 
+// We have to implement `PartialReflect` manually because of the embedded
+// `Box<dyn AnimationEvent>`, which can't be automatically derived yet.
 impl PartialReflect for AnimationEventData {
     #[inline]
     fn get_represented_type_info(&self) -> Option<&'static TypeInfo> {
@@ -167,6 +174,8 @@ impl PartialReflect for AnimationEventData {
     }
 }
 
+// We have to implement `Reflect` manually because of the embedded
+// `Box<dyn AnimationEvent>`, which can't be automatically derived yet.
 impl Reflect for AnimationEventData {
     #[inline]
     fn into_any(self: Box<Self>) -> Box<dyn Any> {
@@ -205,6 +214,8 @@ impl Reflect for AnimationEventData {
     }
 }
 
+// We have to implement `FromReflect` manually because of the embedded
+// `Box<dyn AnimationEvent>`, which can't be automatically derived yet.
 impl FromReflect for AnimationEventData {
     fn from_reflect(reflect: &dyn PartialReflect) -> Option<Self> {
         Some(reflect.try_downcast_ref::<AnimationEventData>()?.clone())

From 1e2ea516c67d55f375f3b7eee771e9d1ab5d17bd Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Tue, 1 Oct 2024 00:31:38 +0200
Subject: [PATCH 24/89] reverse animation

---
 examples/animation/animated_fox.rs | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/examples/animation/animated_fox.rs b/examples/animation/animated_fox.rs
index c92e83c21e115..3c4c9134c6f25 100644
--- a/examples/animation/animated_fox.rs
+++ b/examples/animation/animated_fox.rs
@@ -220,6 +220,7 @@ fn setup(
     println!("  - digit 1 / 3 / 5: play the animation <digit> times");
     println!("  - L: loop the animation forever");
     println!("  - return: change animation");
+    println!("  - R: reverse animation");
 }
 
 // An `AnimationPlayer` is automatically added to the scene when it's ready.
@@ -303,6 +304,12 @@ fn keyboard_animation_control(
             playing_animation.seek_to(elapsed + 0.1);
         }
 
+        if keyboard_input.just_pressed(KeyCode::KeyR) {
+            let playing_animation = player.animation_mut(playing_animation_index).unwrap();
+            let speed = playing_animation.speed();
+            playing_animation.set_speed(-speed);
+        }
+
         if keyboard_input.just_pressed(KeyCode::Enter) {
             *current_animation = (*current_animation + 1) % animations.animations.len();
 

From a02cd8c0f1d0fce59f584bcfbb8db2e92d44b261 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Tue, 1 Oct 2024 00:41:29 +0200
Subject: [PATCH 25/89] example comments

---
 examples/animation/animated_fox.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/examples/animation/animated_fox.rs b/examples/animation/animated_fox.rs
index 3c4c9134c6f25..8844f1f16aa5a 100644
--- a/examples/animation/animated_fox.rs
+++ b/examples/animation/animated_fox.rs
@@ -54,6 +54,7 @@ struct FoxFeetIds {
 impl Default for FoxFeetIds {
     fn default() -> Self {
         Self {
+            // This is the hierarchy of nodes pointing to the feet, as defined in `Fox.glb`
             forward_right: AnimationTargetId::from_iter([
                 "root",
                 "_rootJoint",
@@ -106,6 +107,8 @@ struct Particle {
     lifetime: Timer,
 }
 
+// The event that will be fired once the fox feets hits the ground in the running animation.
+// It's also a resource to make it easier to re-use the asset handles for the mesh/material.
 #[derive(Resource, Event, Reflect, Clone)]
 #[reflect(AnimationEvent)]
 struct FoxStep {
@@ -142,7 +145,6 @@ impl FoxStep {
                 ..Default::default()
             },
         ));
-        // println!("STEP: {}", transform.translation);
     }
 }
 
@@ -238,6 +240,8 @@ fn setup_scene_once_loaded(
         let graph = graphs.get(&animations.graph).unwrap();
         let node = graph.get(animations.animations[0]).unwrap();
         let clip = clips.get_mut(node.clip.as_ref().unwrap()).unwrap();
+
+        // Fire the `FoxStep` event at certain times in the animation, targeting the different feets.
         clip.add_event_with_id(feet.forward_right, 0.46, step.clone());
         clip.add_event_with_id(feet.forward_left, 0.64, step.clone());
         clip.add_event_with_id(feet.back_right, 0.14, step.clone());

From ebb29f50aef483451ac1fb0d7f28997518de1e03 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Tue, 1 Oct 2024 00:44:09 +0200
Subject: [PATCH 26/89] fix typo

---
 examples/animation/animated_fox.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/examples/animation/animated_fox.rs b/examples/animation/animated_fox.rs
index 8844f1f16aa5a..6cf6c4d6081b4 100644
--- a/examples/animation/animated_fox.rs
+++ b/examples/animation/animated_fox.rs
@@ -107,7 +107,7 @@ struct Particle {
     lifetime: Timer,
 }
 
-// The event that will be fired once the fox feets hits the ground in the running animation.
+// The event that will be fired once the fox feet hits the ground in the running animation.
 // It's also a resource to make it easier to re-use the asset handles for the mesh/material.
 #[derive(Resource, Event, Reflect, Clone)]
 #[reflect(AnimationEvent)]
@@ -241,7 +241,7 @@ fn setup_scene_once_loaded(
         let node = graph.get(animations.animations[0]).unwrap();
         let clip = clips.get_mut(node.clip.as_ref().unwrap()).unwrap();
 
-        // Fire the `FoxStep` event at certain times in the animation, targeting the different feets.
+        // Fire the `FoxStep` event at certain times in the animation, targeting the different feet.
         clip.add_event_with_id(feet.forward_right, 0.46, step.clone());
         clip.add_event_with_id(feet.forward_left, 0.64, step.clone());
         clip.add_event_with_id(feet.back_right, 0.14, step.clone());

From 06535ff8a94603c699ee2eb136fe157c6ebbdbf2 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Tue, 1 Oct 2024 00:53:53 +0200
Subject: [PATCH 27/89] rename add_event_with_id -> add_event_to_target

---
 crates/bevy_animation/src/lib.rs   | 4 +++-
 examples/animation/animated_fox.rs | 8 ++++----
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index dd8605975536c..a27f971213fba 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -446,7 +446,7 @@ impl AnimationClip {
     /// Add an [`AnimationEvent`] to an [`AnimationTarget`] named by an [`AnimationTargetId`].
     ///
     /// The `event` will trigger on the entity matching the target once the `time` is reached in the animation.
-    pub fn add_event_with_id(
+    pub fn add_event_to_target(
         &mut self,
         target_id: AnimationTargetId,
         time: f32,
@@ -519,10 +519,12 @@ pub struct ActiveAnimation {
     ///
     /// Note: This will always be in the range [0.0, animation clip duration]
     seek_time: f32,
+    /// The `seek_time` of the previous tick, if any.
     last_seek_time: Option<f32>,
     /// Number of times the animation has completed.
     /// If the animation is playing in reverse, this increments when the animation passes the start.
     completions: u32,
+    /// `true` if the animation was completed at least once this tick.
     just_completed: bool,
     paused: bool,
 }
diff --git a/examples/animation/animated_fox.rs b/examples/animation/animated_fox.rs
index 6cf6c4d6081b4..82fa371b9d6cf 100644
--- a/examples/animation/animated_fox.rs
+++ b/examples/animation/animated_fox.rs
@@ -242,10 +242,10 @@ fn setup_scene_once_loaded(
         let clip = clips.get_mut(node.clip.as_ref().unwrap()).unwrap();
 
         // Fire the `FoxStep` event at certain times in the animation, targeting the different feet.
-        clip.add_event_with_id(feet.forward_right, 0.46, step.clone());
-        clip.add_event_with_id(feet.forward_left, 0.64, step.clone());
-        clip.add_event_with_id(feet.back_right, 0.14, step.clone());
-        clip.add_event_with_id(feet.back_left, 0.02, step.clone());
+        clip.add_event_to_target(feet.forward_right, 0.46, step.clone());
+        clip.add_event_to_target(feet.forward_left, 0.64, step.clone());
+        clip.add_event_to_target(feet.back_right, 0.14, step.clone());
+        clip.add_event_to_target(feet.back_left, 0.02, step.clone());
 
         let mut transitions = AnimationTransitions::new();
 

From a5a564218a31b6a7272e442f9d336cc66917ecca Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Tue, 1 Oct 2024 00:59:49 +0200
Subject: [PATCH 28/89] docs/cleanup add_event

---
 crates/bevy_animation/src/lib.rs | 20 +++++++++++++++-----
 1 file changed, 15 insertions(+), 5 deletions(-)

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index a27f971213fba..d2447e29ff2f1 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -446,24 +446,34 @@ impl AnimationClip {
     /// Add an [`AnimationEvent`] to an [`AnimationTarget`] named by an [`AnimationTargetId`].
     ///
     /// The `event` will trigger on the entity matching the target once the `time` is reached in the animation.
+    ///
+    /// Use [`add_event`](Self::add_event) if you don't have a specific target.
     pub fn add_event_to_target(
         &mut self,
         target_id: AnimationTargetId,
         time: f32,
         event: impl AnimationEvent,
     ) {
-        self.duration = self.duration.max(time);
-        let triggers = self.triggers.entry(Some(target_id)).or_default();
-        triggers.push((time, AnimationEventData::new(event)));
-        triggers.sort_by_key(|(k, _)| FloatOrd(*k));
+        self.add_event_to_target_inner(Some(target_id), time, event);
     }
 
     /// Add a untargeted [`AnimationEvent`] to this [`AnimationClip`].
     ///
     /// The `event` will trigger on the [`AnimationPlayer`] entity once the `time` is reached in the animation.
+    ///
+    /// See also [`add_event_to_target`](Self::add_event_to_target).
     pub fn add_event(&mut self, time: f32, event: impl AnimationEvent) {
+        self.add_event_to_target_inner(None, time, event);
+    }
+
+    fn add_event_to_target_inner(
+        &mut self,
+        target_id: Option<AnimationTargetId>,
+        time: f32,
+        event: impl AnimationEvent,
+    ) {
         self.duration = self.duration.max(time);
-        let triggers = self.triggers.entry(None).or_default();
+        let triggers = self.triggers.entry(target_id).or_default();
         triggers.push((time, AnimationEventData::new(event)));
         triggers.sort_by_key(|(k, _)| FloatOrd(*k));
     }

From db74d8fe957407b75405d65ddfc2fecf3d37bac5 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Tue, 1 Oct 2024 02:39:34 +0200
Subject: [PATCH 29/89] fix logic error

hopefully
---
 crates/bevy_animation/src/lib.rs | 65 ++++++++++++++++++++------------
 1 file changed, 40 insertions(+), 25 deletions(-)

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index d2447e29ff2f1..079544393b700 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -282,8 +282,13 @@ pub struct AnimationClip {
     duration: f32,
 }
 
-pub(crate) type AnimationTriggers =
-    HashMap<Option<AnimationTargetId>, Vec<(f32, AnimationEventData)>>;
+#[derive(Reflect, Debug, Clone)]
+pub(crate) struct AnimationTrigger {
+    time: f32,
+    event: AnimationEventData,
+}
+
+pub(crate) type AnimationTriggers = HashMap<Option<AnimationTargetId>, Vec<AnimationTrigger>>;
 
 /// A mapping from [`AnimationTargetId`] (e.g. bone in a skinned mesh) to the
 /// animation curves.
@@ -474,8 +479,11 @@ impl AnimationClip {
     ) {
         self.duration = self.duration.max(time);
         let triggers = self.triggers.entry(target_id).or_default();
-        triggers.push((time, AnimationEventData::new(event)));
-        triggers.sort_by_key(|(k, _)| FloatOrd(*k));
+        triggers.push(AnimationTrigger {
+            time,
+            event: AnimationEventData::new(event),
+        });
+        triggers.sort_by_key(|k| FloatOrd(k.time));
     }
 }
 
@@ -988,26 +996,33 @@ fn for_each_animation_event(
     target_id: Option<AnimationTargetId>,
     clip: &AnimationClip,
     animation: &ActiveAnimation,
-    mut f: impl FnMut(f32, Box<dyn AnimationEvent>),
+    mut f: impl FnMut(&AnimationTrigger),
 ) {
-    for (t, e) in clip
-        .triggers
-        .get(&target_id)
-        .iter()
-        .flat_map(|t| t.iter())
-        // filter out events that did not occur this tick
-        .filter(|(t, _)| match animation.is_playback_reversed() {
-            true => {
-                *t >= animation.seek_time
-                    && (animation.just_completed || Some(*t) < animation.last_seek_time)
+    let Some(triggers) = clip.triggers.get(&target_id) else {
+        return;
+    };
+
+    for trigger in triggers.iter().filter(|t| {
+        match (animation.is_playback_reversed(), animation.just_completed) {
+            // forward, trigger if `last_seek_time < trigger_time <= seek_time`
+            (false, false) => {
+                Some(t.time) >= animation.last_seek_time && t.time <= animation.seek_time
             }
-            false => {
-                Some(*t) > animation.last_seek_time
-                    && (animation.just_completed || *t <= animation.seek_time)
+            // forward, completed this tick
+            (false, true) => {
+                Some(t.time) >= animation.last_seek_time || t.time <= animation.seek_time
             }
-        })
-    {
-        f(*t, e.clone().0);
+            // reverse, trigger if `seek_time <= trigger_time < last_seek_time`
+            (true, false) => {
+                Some(t.time) <= animation.last_seek_time && t.time >= animation.seek_time
+            }
+            // reverse, completed this tick
+            (true, true) => {
+                Some(t.time) <= animation.last_seek_time || t.time >= animation.seek_time
+            }
+        }
+    }) {
+        f(trigger);
     }
 }
 
@@ -1029,8 +1044,8 @@ fn trigger_untargeted_animation_events(
                 continue;
             };
             let clip = clips.get(clip_id).unwrap();
-            for_each_animation_event(None, clip, animation, |_, event| {
-                commands.queue(trigger_animation_event(event, entity));
+            for_each_animation_event(None, clip, animation, |trigger| {
+                commands.queue(trigger_animation_event(trigger.event.clone().0, entity));
             });
         }
     }
@@ -1123,9 +1138,9 @@ pub fn animate_targets_and_trigger_events(
                     continue;
                 };
 
-                for_each_animation_event(Some(target_id), clip, active_animation, |_, event| {
+                for_each_animation_event(Some(target_id), clip, active_animation, |trigger| {
                     par_commands.command_scope(|mut commands| {
-                        commands.queue(trigger_animation_event(event, entity));
+                        commands.queue(trigger_animation_event(trigger.event.clone().0, entity));
                     });
                 });
 

From ab10ea183c782b248f053a42e554114aadd2daff Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Tue, 1 Oct 2024 02:41:35 +0200
Subject: [PATCH 30/89] Update animation_events.rs

---
 examples/animation/animation_events.rs | 81 +++++++++++++++++++++++---
 1 file changed, 73 insertions(+), 8 deletions(-)

diff --git a/examples/animation/animation_events.rs b/examples/animation/animation_events.rs
index 94b4a069b3290..23199e6cafa3d 100644
--- a/examples/animation/animation_events.rs
+++ b/examples/animation/animation_events.rs
@@ -2,30 +2,51 @@
 
 use bevy::{
     animation::animation_event::{AnimationEvent, ReflectAnimationEvent},
+    color::palettes::css::{ALICE_BLUE, CRIMSON},
     prelude::*,
 };
 
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
-        .add_systems(Startup, setup)
         .register_type::<Say>()
         .observe(Say::observer)
+        .add_systems(Startup, setup)
+        .add_systems(Update, animate_text_opacity)
         .run();
 }
 
 #[derive(Event, Reflect, Clone)]
 #[reflect(AnimationEvent)]
 enum Say {
-    Hello,
-    Bye,
+    Hello(Entity),
+    Bye(Entity),
+}
+
+impl Say {
+    fn entity(&self) -> Entity {
+        match self {
+            Say::Hello(entity) => *entity,
+            Say::Bye(entity) => *entity,
+        }
+    }
 }
 
 impl Say {
-    fn observer(trigger: Trigger<Self>) {
+    fn observer(trigger: Trigger<Self>, mut query: Query<&mut Text>) {
+        let mut text = query.get_mut(trigger.event().entity()).unwrap();
+
         match trigger.event() {
-            Say::Hello => println!("HELLO!"),
-            Say::Bye => println!("BYE!"),
+            Say::Hello(_) => {
+                text.sections[0].style.color = ALICE_BLUE.into();
+                text.sections[0].value = "HELLO".into();
+                println!("HELLO");
+            }
+            Say::Bye(_) => {
+                text.sections[0].style.color = CRIMSON.into();
+                text.sections[0].value = "BYE".into();
+                println!("BYE");
+            }
         }
     }
 }
@@ -45,10 +66,46 @@ fn setup(
     mut animations: ResMut<Assets<AnimationClip>>,
     mut graphs: ResMut<Assets<AnimationGraph>>,
 ) {
+    // Camera
+    commands.spawn(Camera2dBundle::default());
+
+    // A text entity that will have a message printed to it
+    let message = commands
+        .spawn(TextBundle {
+            text: Text::from_section(
+                "",
+                TextStyle {
+                    font_size: 71.0,
+                    color: Color::NONE,
+                    ..Default::default()
+                },
+            ),
+            ..Default::default()
+        })
+        .id();
+
+    // Container node for the message
+    commands
+        .spawn(NodeBundle {
+            style: Style {
+                width: Val::Percent(100.0),
+                height: Val::Percent(100.0),
+                justify_content: JustifyContent::Center,
+                align_items: AlignItems::Center,
+                ..Default::default()
+            },
+            ..Default::default()
+        })
+        .add_child(message);
+
+    // Create a new animation clip
     let mut animation = AnimationClip::default();
+    animation.set_duration(2.0);
 
-    animation.add_event(1.0, Say::Hello);
-    animation.add_event(2.0, Say::Bye);
+    // Add events at the specified time
+    // If `time` is `0.0` it will trigger twice on the first tick for some reason
+    animation.add_event(0.001, Say::Hello(message));
+    animation.add_event(1.0, Say::Bye(message));
 
     let (graph, animation_index) = AnimationGraph::from_clip(animations.add(animation));
     let mut player = AnimationPlayer::default();
@@ -56,3 +113,11 @@ fn setup(
 
     commands.spawn((graphs.add(graph), player));
 }
+
+fn animate_text_opacity(mut query: Query<&mut Text>, time: Res<Time>) {
+    for mut text in &mut query {
+        let color = &mut text.sections[0].style.color;
+        let a = color.alpha();
+        color.set_alpha(a - time.delta_seconds());
+    }
+}

From e4f0ea44798b59b49ccb4bcde8f4a43d323fb84a Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Tue, 1 Oct 2024 02:58:50 +0200
Subject: [PATCH 31/89] create AnimationTriggerIter

cont

Update lib.rs
---
 crates/bevy_animation/src/lib.rs | 109 +++++++++++++++++++------------
 1 file changed, 66 insertions(+), 43 deletions(-)

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 079544393b700..e5453f712d3cc 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -981,48 +981,58 @@ pub fn advance_animations(
         });
 }
 
-/// A type alias for [`EntityMutExcept`] as used in animation.
-pub type AnimationEntityMut<'w> = EntityMutExcept<
-    'w,
-    (
-        AnimationTarget,
-        Transform,
-        AnimationPlayer,
-        Handle<AnimationGraph>,
-    ),
->;
+struct AnimationTriggersIter<'a, 'b> {
+    triggers: core::slice::Iter<'a, AnimationTrigger>,
+    animation: &'b ActiveAnimation,
+}
 
-fn for_each_animation_event(
-    target_id: Option<AnimationTargetId>,
-    clip: &AnimationClip,
-    animation: &ActiveAnimation,
-    mut f: impl FnMut(&AnimationTrigger),
-) {
-    let Some(triggers) = clip.triggers.get(&target_id) else {
-        return;
-    };
+impl<'a, 'b> AnimationTriggersIter<'a, 'b> {
+    fn new(
+        target_id: Option<AnimationTargetId>,
+        clip: &'a AnimationClip,
+        animation: &'b ActiveAnimation,
+    ) -> Option<Self> {
+        Some(Self {
+            triggers: clip.triggers.get(&target_id)?.iter(),
+            animation,
+        })
+    }
+}
 
-    for trigger in triggers.iter().filter(|t| {
-        match (animation.is_playback_reversed(), animation.just_completed) {
-            // forward, trigger if `last_seek_time < trigger_time <= seek_time`
-            (false, false) => {
-                Some(t.time) >= animation.last_seek_time && t.time <= animation.seek_time
-            }
-            // forward, completed this tick
-            (false, true) => {
-                Some(t.time) >= animation.last_seek_time || t.time <= animation.seek_time
-            }
-            // reverse, trigger if `seek_time <= trigger_time < last_seek_time`
-            (true, false) => {
-                Some(t.time) <= animation.last_seek_time && t.time >= animation.seek_time
-            }
-            // reverse, completed this tick
-            (true, true) => {
-                Some(t.time) <= animation.last_seek_time || t.time >= animation.seek_time
+impl<'a, 'b> Iterator for AnimationTriggersIter<'a, 'b> {
+    type Item = &'a AnimationTrigger;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            let trigger = self.triggers.next()?;
+            if match (
+                self.animation.is_playback_reversed(),
+                self.animation.just_completed,
+            ) {
+                // forward, trigger if `last_seek_time < trigger_time <= seek_time`
+                (false, false) => {
+                    Some(trigger.time) >= self.animation.last_seek_time
+                        && trigger.time <= self.animation.seek_time
+                }
+                // forward, completed this tick
+                (false, true) => {
+                    Some(trigger.time) >= self.animation.last_seek_time
+                        || trigger.time <= self.animation.seek_time
+                }
+                // reverse, trigger if `seek_time <= trigger_time < last_seek_time`
+                (true, false) => {
+                    Some(trigger.time) <= self.animation.last_seek_time
+                        && trigger.time >= self.animation.seek_time
+                }
+                // reverse, completed this tick
+                (true, true) => {
+                    Some(trigger.time) <= self.animation.last_seek_time
+                        || trigger.time >= self.animation.seek_time
+                }
+            } {
+                return Some(trigger);
             }
         }
-    }) {
-        f(trigger);
     }
 }
 
@@ -1039,18 +1049,29 @@ fn trigger_untargeted_animation_events(
             return;
         };
 
-        for (index, animation) in player.active_animations.iter() {
+        for (index, active_animation) in player.active_animations.iter() {
             let Some(clip_id) = graph.get(*index).unwrap().clip.as_ref() else {
                 continue;
             };
             let clip = clips.get(clip_id).unwrap();
-            for_each_animation_event(None, clip, animation, |trigger| {
+            for trigger in AnimationTriggersIter::new(None, clip, active_animation).unwrap() {
                 commands.queue(trigger_animation_event(trigger.event.clone().0, entity));
-            });
+            }
         }
     }
 }
 
+/// A type alias for [`EntityMutExcept`] as used in animation.
+pub type AnimationEntityMut<'w> = EntityMutExcept<
+    'w,
+    (
+        AnimationTarget,
+        Transform,
+        AnimationPlayer,
+        Handle<AnimationGraph>,
+    ),
+>;
+
 /// A system that modifies animation targets (e.g. bones in a skinned mesh)
 /// according to the currently-playing animations.
 ///
@@ -1138,11 +1159,13 @@ pub fn animate_targets_and_trigger_events(
                     continue;
                 };
 
-                for_each_animation_event(Some(target_id), clip, active_animation, |trigger| {
+                for trigger in
+                    AnimationTriggersIter::new(Some(target_id), clip, active_animation).unwrap()
+                {
                     par_commands.command_scope(|mut commands| {
                         commands.queue(trigger_animation_event(trigger.event.clone().0, entity));
                     });
-                });
+                }
 
                 let Some(curves) = clip.curves_for_target(target_id) else {
                     continue;

From 49f9692d3d5692d27762deef3431384990ed1024 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Tue, 1 Oct 2024 02:59:18 +0200
Subject: [PATCH 32/89] Update animation_events.rs

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

diff --git a/examples/animation/animation_events.rs b/examples/animation/animation_events.rs
index 23199e6cafa3d..2d762fb405b7b 100644
--- a/examples/animation/animation_events.rs
+++ b/examples/animation/animation_events.rs
@@ -26,8 +26,7 @@ enum Say {
 impl Say {
     fn entity(&self) -> Entity {
         match self {
-            Say::Hello(entity) => *entity,
-            Say::Bye(entity) => *entity,
+            Say::Hello(entity) | Say::Bye(entity) => *entity,
         }
     }
 }

From 7f9766735559da4db7a6dd03e3ae1b830225bd81 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Tue, 1 Oct 2024 12:56:42 +0200
Subject: [PATCH 33/89] remove unwrap

---
 crates/bevy_animation/src/lib.rs | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index e5453f712d3cc..9cf5cf132b2c6 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -982,7 +982,7 @@ pub fn advance_animations(
 }
 
 struct AnimationTriggersIter<'a, 'b> {
-    triggers: core::slice::Iter<'a, AnimationTrigger>,
+    triggers: Option<core::slice::Iter<'a, AnimationTrigger>>,
     animation: &'b ActiveAnimation,
 }
 
@@ -991,11 +991,11 @@ impl<'a, 'b> AnimationTriggersIter<'a, 'b> {
         target_id: Option<AnimationTargetId>,
         clip: &'a AnimationClip,
         animation: &'b ActiveAnimation,
-    ) -> Option<Self> {
-        Some(Self {
-            triggers: clip.triggers.get(&target_id)?.iter(),
+    ) -> Self {
+        Self {
+            triggers: clip.triggers.get(&target_id).map(|v| v.iter()),
             animation,
-        })
+        }
     }
 }
 
@@ -1004,7 +1004,7 @@ impl<'a, 'b> Iterator for AnimationTriggersIter<'a, 'b> {
 
     fn next(&mut self) -> Option<Self::Item> {
         loop {
-            let trigger = self.triggers.next()?;
+            let trigger = self.triggers.as_mut()?.next()?;
             if match (
                 self.animation.is_playback_reversed(),
                 self.animation.just_completed,
@@ -1054,7 +1054,7 @@ fn trigger_untargeted_animation_events(
                 continue;
             };
             let clip = clips.get(clip_id).unwrap();
-            for trigger in AnimationTriggersIter::new(None, clip, active_animation).unwrap() {
+            for trigger in AnimationTriggersIter::new(None, clip, active_animation) {
                 commands.queue(trigger_animation_event(trigger.event.clone().0, entity));
             }
         }
@@ -1159,9 +1159,7 @@ pub fn animate_targets_and_trigger_events(
                     continue;
                 };
 
-                for trigger in
-                    AnimationTriggersIter::new(Some(target_id), clip, active_animation).unwrap()
-                {
+                for trigger in AnimationTriggersIter::new(Some(target_id), clip, active_animation) {
                     par_commands.command_scope(|mut commands| {
                         commands.queue(trigger_animation_event(trigger.event.clone().0, entity));
                     });

From 5a42a67712411b5a147c3d5977b2ccbb82e97482 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Tue, 1 Oct 2024 12:58:41 +0200
Subject: [PATCH 34/89] raname trigger -> events

rename AnimationTriggers -> AnimationEvents
---
 crates/bevy_animation/src/lib.rs | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 9cf5cf132b2c6..87cc80a03eba6 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -278,17 +278,17 @@ impl Typed for VariableCurve {
 #[derive(Asset, Reflect, Clone, Debug, Default)]
 pub struct AnimationClip {
     curves: AnimationCurves,
-    triggers: AnimationTriggers,
+    events: AnimationEvents,
     duration: f32,
 }
 
 #[derive(Reflect, Debug, Clone)]
-pub(crate) struct AnimationTrigger {
+pub(crate) struct AnimationEventKey {
     time: f32,
     event: AnimationEventData,
 }
 
-pub(crate) type AnimationTriggers = HashMap<Option<AnimationTargetId>, Vec<AnimationTrigger>>;
+pub(crate) type AnimationEvents = HashMap<Option<AnimationTargetId>, Vec<AnimationEventKey>>;
 
 /// A mapping from [`AnimationTargetId`] (e.g. bone in a skinned mesh) to the
 /// animation curves.
@@ -478,8 +478,8 @@ impl AnimationClip {
         event: impl AnimationEvent,
     ) {
         self.duration = self.duration.max(time);
-        let triggers = self.triggers.entry(target_id).or_default();
-        triggers.push(AnimationTrigger {
+        let triggers = self.events.entry(target_id).or_default();
+        triggers.push(AnimationEventKey {
             time,
             event: AnimationEventData::new(event),
         });
@@ -982,7 +982,7 @@ pub fn advance_animations(
 }
 
 struct AnimationTriggersIter<'a, 'b> {
-    triggers: Option<core::slice::Iter<'a, AnimationTrigger>>,
+    triggers: Option<core::slice::Iter<'a, AnimationEventKey>>,
     animation: &'b ActiveAnimation,
 }
 
@@ -993,14 +993,14 @@ impl<'a, 'b> AnimationTriggersIter<'a, 'b> {
         animation: &'b ActiveAnimation,
     ) -> Self {
         Self {
-            triggers: clip.triggers.get(&target_id).map(|v| v.iter()),
+            triggers: clip.events.get(&target_id).map(|v| v.iter()),
             animation,
         }
     }
 }
 
 impl<'a, 'b> Iterator for AnimationTriggersIter<'a, 'b> {
-    type Item = &'a AnimationTrigger;
+    type Item = &'a AnimationEventKey;
 
     fn next(&mut self) -> Option<Self::Item> {
         loop {

From 30f146b57c0575638bbda2e55ba6d8bc005305a5 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Tue, 1 Oct 2024 13:09:43 +0200
Subject: [PATCH 35/89] add `time` to `AnimationEvent::trigger`

---
 crates/bevy_animation/src/animation_event.rs | 18 ++++++++++--------
 crates/bevy_animation/src/lib.rs             | 12 ++++++++++--
 2 files changed, 20 insertions(+), 10 deletions(-)

diff --git a/crates/bevy_animation/src/animation_event.rs b/crates/bevy_animation/src/animation_event.rs
index 08940d1c62e1f..26256b496278b 100644
--- a/crates/bevy_animation/src/animation_event.rs
+++ b/crates/bevy_animation/src/animation_event.rs
@@ -10,19 +10,21 @@ use bevy_reflect::{
 };
 
 pub(crate) fn trigger_animation_event(
+    time: f32,
     event: Box<dyn AnimationEvent>,
     entity: Entity,
 ) -> impl Command {
     move |world: &mut World| {
-        event.trigger(entity, world);
+        event.trigger(time, entity, world);
     }
 }
 
+// TODO: this should have a derive macro
 /// An event that can be used with animations.
 #[reflect_trait]
 pub trait AnimationEvent: Reflect + Send + Sync {
     /// Trigger the event, targeting `entity`.
-    fn trigger(&self, entity: Entity, world: &mut World);
+    fn trigger(&self, time: f32, entity: Entity, world: &mut World);
 
     /// Clone this value into a new `Box<dyn AnimationEvent>`
     fn clone_value(&self) -> Box<dyn AnimationEvent>;
@@ -32,6 +34,12 @@ pub trait AnimationEvent: Reflect + Send + Sync {
 #[derive(TypePath)]
 pub(crate) struct AnimationEventData(pub(crate) Box<dyn AnimationEvent>);
 
+impl AnimationEventData {
+    pub(crate) fn new(event: impl AnimationEvent) -> Self {
+        Self(Box::new(event))
+    }
+}
+
 impl Debug for AnimationEventData {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.write_str("AnimationEventData(")?;
@@ -41,12 +49,6 @@ impl Debug for AnimationEventData {
     }
 }
 
-impl AnimationEventData {
-    pub(crate) fn new(event: impl AnimationEvent) -> Self {
-        Self(Box::new(event))
-    }
-}
-
 impl Clone for AnimationEventData {
     fn clone(&self) -> Self {
         Self(AnimationEvent::clone_value(self.0.as_ref()))
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 87cc80a03eba6..adfd2a000df69 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -1055,7 +1055,11 @@ fn trigger_untargeted_animation_events(
             };
             let clip = clips.get(clip_id).unwrap();
             for trigger in AnimationTriggersIter::new(None, clip, active_animation) {
-                commands.queue(trigger_animation_event(trigger.event.clone().0, entity));
+                commands.queue(trigger_animation_event(
+                    trigger.time,
+                    trigger.event.clone().0,
+                    entity,
+                ));
             }
         }
     }
@@ -1161,7 +1165,11 @@ pub fn animate_targets_and_trigger_events(
 
                 for trigger in AnimationTriggersIter::new(Some(target_id), clip, active_animation) {
                     par_commands.command_scope(|mut commands| {
-                        commands.queue(trigger_animation_event(trigger.event.clone().0, entity));
+                        commands.queue(trigger_animation_event(
+                            trigger.time,
+                            trigger.event.clone().0,
+                            entity,
+                        ));
                     });
                 }
 

From 09b68423015a3c96206535d7ec89bd2ada1f4d09 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Tue, 1 Oct 2024 13:52:25 +0200
Subject: [PATCH 36/89] fix examples

---
 examples/animation/animated_fox.rs     | 2 +-
 examples/animation/animation_events.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/examples/animation/animated_fox.rs b/examples/animation/animated_fox.rs
index 82fa371b9d6cf..7094fd106b5d5 100644
--- a/examples/animation/animated_fox.rs
+++ b/examples/animation/animated_fox.rs
@@ -149,7 +149,7 @@ impl FoxStep {
 }
 
 impl AnimationEvent for FoxStep {
-    fn trigger(&self, entity: Entity, world: &mut World) {
+    fn trigger(&self, _time: f32, entity: Entity, world: &mut World) {
         world.entity_mut(entity).trigger(self.clone());
     }
 
diff --git a/examples/animation/animation_events.rs b/examples/animation/animation_events.rs
index 2d762fb405b7b..d4c436964cf5c 100644
--- a/examples/animation/animation_events.rs
+++ b/examples/animation/animation_events.rs
@@ -51,7 +51,7 @@ impl Say {
 }
 
 impl AnimationEvent for Say {
-    fn trigger(&self, entity: Entity, world: &mut World) {
+    fn trigger(&self, _time: f32, entity: Entity, world: &mut World) {
         world.entity_mut(entity).trigger(self.clone());
     }
 

From fd86ce59fc8683f9f1b009a325ceed7c583d1e17 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Tue, 1 Oct 2024 15:42:13 +0200
Subject: [PATCH 37/89] include player entity in `AnimationEvent::trigger`

---
 crates/bevy_animation/src/animation_event.rs | 7 ++++---
 crates/bevy_animation/src/lib.rs             | 2 ++
 examples/animation/animation_events.rs       | 4 ++--
 3 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/crates/bevy_animation/src/animation_event.rs b/crates/bevy_animation/src/animation_event.rs
index 26256b496278b..93be99793a520 100644
--- a/crates/bevy_animation/src/animation_event.rs
+++ b/crates/bevy_animation/src/animation_event.rs
@@ -10,12 +10,13 @@ use bevy_reflect::{
 };
 
 pub(crate) fn trigger_animation_event(
+    player: Entity,
     time: f32,
     event: Box<dyn AnimationEvent>,
-    entity: Entity,
+    target: Entity,
 ) -> impl Command {
     move |world: &mut World| {
-        event.trigger(time, entity, world);
+        event.trigger(player, time, target, world);
     }
 }
 
@@ -24,7 +25,7 @@ pub(crate) fn trigger_animation_event(
 #[reflect_trait]
 pub trait AnimationEvent: Reflect + Send + Sync {
     /// Trigger the event, targeting `entity`.
-    fn trigger(&self, time: f32, entity: Entity, world: &mut World);
+    fn trigger(&self, player: Entity, time: f32, target: Entity, world: &mut World);
 
     /// Clone this value into a new `Box<dyn AnimationEvent>`
     fn clone_value(&self) -> Box<dyn AnimationEvent>;
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index adfd2a000df69..759e58a305320 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -1056,6 +1056,7 @@ fn trigger_untargeted_animation_events(
             let clip = clips.get(clip_id).unwrap();
             for trigger in AnimationTriggersIter::new(None, clip, active_animation) {
                 commands.queue(trigger_animation_event(
+                    entity,
                     trigger.time,
                     trigger.event.clone().0,
                     entity,
@@ -1166,6 +1167,7 @@ pub fn animate_targets_and_trigger_events(
                 for trigger in AnimationTriggersIter::new(Some(target_id), clip, active_animation) {
                     par_commands.command_scope(|mut commands| {
                         commands.queue(trigger_animation_event(
+                            player_id,
                             trigger.time,
                             trigger.event.clone().0,
                             entity,
diff --git a/examples/animation/animation_events.rs b/examples/animation/animation_events.rs
index d4c436964cf5c..11110f668f36f 100644
--- a/examples/animation/animation_events.rs
+++ b/examples/animation/animation_events.rs
@@ -51,8 +51,8 @@ impl Say {
 }
 
 impl AnimationEvent for Say {
-    fn trigger(&self, _time: f32, entity: Entity, world: &mut World) {
-        world.entity_mut(entity).trigger(self.clone());
+    fn trigger(&self, _player: Entity, _time: f32, target: Entity, world: &mut World) {
+        world.entity_mut(target).trigger(self.clone());
     }
 
     fn clone_value(&self) -> Box<dyn AnimationEvent> {

From 45b7b792b3f2c7800946ffc9a02ce9a254ee0fc7 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Tue, 1 Oct 2024 15:59:03 +0200
Subject: [PATCH 38/89] bunny detective example

Update bunny_detective.rs
---
 Cargo.toml                            |  11 ++
 assets/models/animated/buntective.glb | Bin 0 -> 347484 bytes
 examples/README.md                    |   1 +
 examples/animation/bunny_detective.rs | 260 ++++++++++++++++++++++++++
 4 files changed, 272 insertions(+)
 create mode 100644 assets/models/animated/buntective.glb
 create mode 100644 examples/animation/bunny_detective.rs

diff --git a/Cargo.toml b/Cargo.toml
index bca3cafea10cf..93b721b5ffc6a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1181,6 +1181,17 @@ doc-scrape-examples = true
 hidden = true
 
 # Animation
+[[example]]
+name = "bunny_detective"
+path = "examples/animation/bunny_detective.rs"
+doc-scrape-examples = true
+
+[package.metadata.example.bunny_detective]
+name = "Bunny Detective"
+description = "Demonstrate how to use animation events with an animated character"
+category = "Animation"
+wasm = true
+
 [[example]]
 name = "animation_events"
 path = "examples/animation/animation_events.rs"
diff --git a/assets/models/animated/buntective.glb b/assets/models/animated/buntective.glb
new file mode 100644
index 0000000000000000000000000000000000000000..3a78a75b37747688a23f0c55fbe025e8d68b443d
GIT binary patch
literal 347484
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

literal 0
HcmV?d00001

diff --git a/examples/README.md b/examples/README.md
index 5088777e6fd0e..50d0f30e805c3 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -193,6 +193,7 @@ Example | Description
 [Animation Events](../examples/animation/animation_events.rs) | Demonstrate how to use animation events
 [Animation Graph](../examples/animation/animation_graph.rs) | Blends multiple animations together with a graph
 [Animation Masks](../examples/animation/animation_masks.rs) | Demonstrates animation masks
+[Bunny Detective](../examples/animation/bunny_detective.rs) | Demonstrate how to use animation events with animated character
 [Color animation](../examples/animation/color_animation.rs) | Demonstrates how to animate colors using mixing and splines in different color spaces
 [Cubic Curve](../examples/animation/cubic_curve.rs) | Bezier curve example showing a cube following a cubic curve
 [Custom Skinned Mesh](../examples/animation/custom_skinned_mesh.rs) | Skinned mesh example with mesh and joints data defined in code
diff --git a/examples/animation/bunny_detective.rs b/examples/animation/bunny_detective.rs
new file mode 100644
index 0000000000000..d1e3fd98a994c
--- /dev/null
+++ b/examples/animation/bunny_detective.rs
@@ -0,0 +1,260 @@
+//! Demonstrate how to use animation events with an animated character.
+
+use std::{f32::consts::PI, time::Duration};
+
+use bevy::{
+    animation::{
+        animation_event::{AnimationEvent, ReflectAnimationEvent},
+        AnimationTargetId,
+    },
+    color::palettes::css::WHITE,
+    pbr::CascadeShadowConfigBuilder,
+    prelude::*,
+};
+use rand::{thread_rng, Rng};
+
+const DETECTIVE_PATH: &str = "models/animated/buntective.glb";
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .insert_resource(AmbientLight {
+            color: Color::WHITE,
+            brightness: 2000.,
+        })
+        .init_resource::<OnLanded>()
+        .add_systems(Startup, setup)
+        .add_systems(
+            Update,
+            (setup_scene_once_loaded, jump_input, simulate_particles),
+        )
+        .observe(OnLanded::observer)
+        .run();
+}
+
+#[derive(Resource)]
+struct Animations {
+    walk: AnimationNodeIndex,
+    jump: AnimationNodeIndex,
+    graph: Handle<AnimationGraph>,
+}
+
+#[derive(Component)]
+struct Particle {
+    lifeteime: Timer,
+    size: f32,
+    velocity: Vec3,
+}
+
+// The event that will be fired once the detective hits the ground in the jump animation.
+// It's also a resource to make it easier to re-use the asset handles for the mesh and material.
+#[derive(Event, Resource, Reflect, Clone)]
+#[reflect(AnimationEvent)]
+struct OnLanded {
+    mesh: Handle<Mesh>,
+    material: Handle<StandardMaterial>,
+}
+
+impl FromWorld for OnLanded {
+    fn from_world(world: &mut World) -> Self {
+        Self {
+            mesh: world.resource_mut::<Assets<Mesh>>().add(Sphere::new(0.25)),
+            material: world
+                .resource_mut::<Assets<StandardMaterial>>()
+                .add(StandardMaterial {
+                    base_color: WHITE.into(),
+                    ..Default::default()
+                }),
+        }
+    }
+}
+
+impl AnimationEvent for OnLanded {
+    fn trigger(&self, player: Entity, _time: f32, target: Entity, world: &mut World) {
+        println!("LANDED!");
+        world.entity_mut(target).trigger(self.clone());
+        // Trigger the event on the animation player as well in order to transition to the walk animation at the end of the jump.
+        // TODO: there might be better ways of doing this, works fine though
+        world.entity_mut(player).trigger(self.clone());
+    }
+
+    fn clone_value(&self) -> Box<dyn AnimationEvent> {
+        Box::new(self.clone())
+    }
+}
+
+impl OnLanded {
+    // The observer that will run when the detective hits the ground in the jump animation.
+    fn observer(
+        trigger: Trigger<Self>,
+        mut commands: Commands,
+        animations: Res<Animations>,
+        mut players: Query<(&mut AnimationPlayer, &mut AnimationTransitions)>,
+        transforms: Query<&GlobalTransform>,
+    ) {
+        if let Ok((mut player, mut transitions)) = players.get_mut(trigger.entity()) {
+            // If this event was targeted to the animation player, transition to the walk animation.
+            // FIXME: setting the `transition_duration` to `1.0s` results in the `OnLanded` event being triggered many times when the transition ends.
+            // I think it's because the transition duration is then longer than the rest of the jump animation, and that causes the bug somehow.
+            transitions
+                .play(&mut player, animations.walk, Duration::from_secs_f32(0.5))
+                .repeat();
+        } else {
+            // spawn a bunch of particles :3
+            let translation = transforms.get(trigger.entity()).unwrap().translation();
+            let mut rng = thread_rng();
+            for _ in 0..25 {
+                let horizontal = rng.gen::<Dir2>() * rng.gen_range(8.0..12.0);
+                let vertical = rng.gen_range(0.0..4.0);
+                let size = rng.gen_range(0.5..1.0);
+                commands.spawn((
+                    Particle {
+                        lifeteime: Timer::from_seconds(1.0, TimerMode::Once),
+                        size,
+                        velocity: Vec3::new(horizontal.x, vertical, horizontal.y),
+                    },
+                    MaterialMeshBundle {
+                        mesh: trigger.event().mesh.clone(),
+                        material: trigger.event().material.clone(),
+                        transform: Transform {
+                            translation: translation.reject_from(Vec3::Y),
+                            scale: Vec3::splat(size),
+                            ..Default::default()
+                        },
+                        ..Default::default()
+                    },
+                ));
+            }
+        }
+    }
+}
+
+fn setup(
+    mut commands: Commands,
+    asset_server: Res<AssetServer>,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+    mut graphs: ResMut<Assets<AnimationGraph>>,
+) {
+    // Build the animation graph
+    let (graph, node_indices) = AnimationGraph::from_clips([
+        asset_server.load(GltfAssetLabel::Animation(0).from_asset(DETECTIVE_PATH)), // walk animation
+        asset_server.load(GltfAssetLabel::Animation(2).from_asset(DETECTIVE_PATH)), // jump animation
+    ]);
+
+    // Insert a resource with the current scene information
+    let graph_handle = graphs.add(graph);
+    commands.insert_resource(Animations {
+        walk: node_indices[0],
+        jump: node_indices[1],
+        graph: graph_handle,
+    });
+
+    // Camera
+    commands.spawn(Camera3dBundle {
+        transform: Transform::from_xyz(2.0, 3.0, 5.0).looking_at(Vec3::new(0.0, 1.5, 0.0), Vec3::Y),
+        ..default()
+    });
+
+    // Plane
+    commands.spawn(PbrBundle {
+        mesh: meshes.add(Plane3d::default().mesh().size(500000.0, 500000.0)),
+        material: materials.add(Color::srgb(0.3, 0.5, 0.3)),
+        transform: Transform::from_xyz(0.0, -0.075, 0.0),
+        ..default()
+    });
+
+    // Light
+    commands.spawn(DirectionalLightBundle {
+        transform: Transform::from_rotation(Quat::from_euler(EulerRot::ZYX, 0.0, 1.0, -PI / 4.)),
+        directional_light: DirectionalLight {
+            shadows_enabled: true,
+            ..default()
+        },
+        cascade_shadow_config: CascadeShadowConfigBuilder {
+            first_cascade_far_bound: 2.0,
+            maximum_distance: 10.0,
+            ..default()
+        }
+        .into(),
+        ..default()
+    });
+
+    // Bunny Detective
+    commands.spawn(SceneBundle {
+        scene: asset_server.load(GltfAssetLabel::Scene(0).from_asset(DETECTIVE_PATH)),
+        ..default()
+    });
+}
+
+// An `AnimationPlayer` is automatically added to the scene when it's ready.
+// When the player is added, start the `walk` animation and add the `OnLanded` event.
+fn setup_scene_once_loaded(
+    mut commands: Commands,
+    landed: Res<OnLanded>,
+    animations: Res<Animations>,
+    graphs: Res<Assets<AnimationGraph>>,
+    mut clips: ResMut<Assets<AnimationClip>>,
+    mut players: Query<(Entity, &mut AnimationPlayer), Added<AnimationPlayer>>,
+) {
+    for (entity, mut player) in &mut players {
+        let graph = graphs.get(&animations.graph).unwrap();
+        let node = graph.get(animations.jump).unwrap();
+        let clip = node.clip.as_ref().and_then(|id| clips.get_mut(id)).unwrap();
+
+        // Get the id of the "pelvis" bone, this is used to spawn the particles
+        // TODO: this is not necessary in this case but I want to demonstrate the use of `add_event_to_target`
+        let target_id = AnimationTargetId::from_iter(["Armature", "pelvis"]);
+        // Trigger the `OnLanded` event on 0.53s in the jump animation.
+        // The detective hits the ground between frame 8 and 9 and the frame rate is 16 fps.
+        // 8.5 / 16 = 5.3
+        clip.add_event_to_target(target_id, 0.53, landed.clone());
+
+        let mut transitions = AnimationTransitions::new();
+
+        // 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.walk, Duration::ZERO)
+            .repeat();
+
+        commands
+            .entity(entity)
+            .insert(animations.graph.clone())
+            .insert(transitions);
+    }
+}
+
+// Play the `jump` animation when the space bar is pressed.
+fn jump_input(
+    keyboard_input: Res<ButtonInput<KeyCode>>,
+    animations: Res<Animations>,
+    mut players: Query<(&mut AnimationPlayer, &mut AnimationTransitions)>,
+) {
+    for (mut player, mut transitions) in &mut players {
+        if keyboard_input.just_pressed(KeyCode::Space) {
+            transitions.play(&mut player, animations.jump, Duration::from_millis(75));
+        }
+    }
+}
+
+fn simulate_particles(
+    mut commands: Commands,
+    mut query: Query<(Entity, &mut Transform, &mut Particle)>,
+    time: Res<Time>,
+) {
+    for (entity, mut transform, mut particle) in &mut query {
+        if particle.lifeteime.tick(time.delta()).just_finished() {
+            commands.entity(entity).despawn();
+        } else {
+            transform.translation += particle.velocity * time.delta_seconds();
+            transform.scale = Vec3::splat(particle.size.lerp(0.0, particle.lifeteime.fraction()));
+            particle
+                .velocity
+                .smooth_nudge(&Vec3::ZERO, 4.0, time.delta_seconds());
+        }
+        if transform.scale.length_squared() < 0.01 {}
+    }
+}

From 12b0dcc3923c195b83e3f72206003a44b174263d Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Tue, 1 Oct 2024 16:00:23 +0200
Subject: [PATCH 39/89] reset animated fox example

it was too complicated
---
 examples/animation/animated_fox.rs | 174 ++---------------------------
 1 file changed, 7 insertions(+), 167 deletions(-)

diff --git a/examples/animation/animated_fox.rs b/examples/animation/animated_fox.rs
index 7094fd106b5d5..1a22ee2f6c008 100644
--- a/examples/animation/animated_fox.rs
+++ b/examples/animation/animated_fox.rs
@@ -3,12 +3,7 @@
 use std::{f32::consts::PI, time::Duration};
 
 use bevy::{
-    animation::{
-        animate_targets_and_trigger_events,
-        animation_event::{AnimationEvent, ReflectAnimationEvent},
-        AnimationTargetId, RepeatAnimation,
-    },
-    color::palettes::css::WHITE,
+    animation::{animate_targets_and_trigger_events, RepeatAnimation},
     pbr::CascadeShadowConfigBuilder,
     prelude::*,
 };
@@ -22,17 +17,12 @@ fn main() {
             brightness: 2000.,
         })
         .add_plugins(DefaultPlugins)
-        .init_resource::<FoxFeetIds>()
-        .init_resource::<FoxStep>()
         .add_systems(Startup, setup)
         .add_systems(
             Update,
             setup_scene_once_loaded.before(animate_targets_and_trigger_events),
         )
         .add_systems(Update, keyboard_animation_control)
-        .add_systems(Update, update_particle)
-        .observe(FoxStep::observer)
-        .register_type::<FoxStep>()
         .run();
 }
 
@@ -43,121 +33,6 @@ struct Animations {
     graph: Handle<AnimationGraph>,
 }
 
-#[derive(Resource)]
-struct FoxFeetIds {
-    forward_right: AnimationTargetId,
-    forward_left: AnimationTargetId,
-    back_right: AnimationTargetId,
-    back_left: AnimationTargetId,
-}
-
-impl Default for FoxFeetIds {
-    fn default() -> Self {
-        Self {
-            // This is the hierarchy of nodes pointing to the feet, as defined in `Fox.glb`
-            forward_right: AnimationTargetId::from_iter([
-                "root",
-                "_rootJoint",
-                "b_Root_00",
-                "b_Hip_01",
-                "b_Spine01_02",
-                "b_Spine02_03",
-                "b_RightUpperArm_06",
-                "b_RightForeArm_07",
-                "b_RightHand_08",
-            ]),
-            forward_left: AnimationTargetId::from_iter([
-                "root",
-                "_rootJoint",
-                "b_Root_00",
-                "b_Hip_01",
-                "b_Spine01_02",
-                "b_Spine02_03",
-                "b_LeftUpperArm_09",
-                "b_LeftForeArm_010",
-                "b_LeftHand_011",
-            ]),
-            back_right: AnimationTargetId::from_iter([
-                "root",
-                "_rootJoint",
-                "b_Root_00",
-                "b_Hip_01",
-                "b_RightLeg01_019",
-                "b_RightLeg02_020",
-                "b_RightFoot01_021",
-                "b_RightFoot02_022",
-            ]),
-            back_left: AnimationTargetId::from_iter([
-                "root",
-                "_rootJoint",
-                "b_Root_00",
-                "b_Hip_01",
-                "b_LeftLeg01_015",
-                "b_LeftLeg02_016",
-                "b_LeftFoot01_017",
-                "b_LeftFoot02_018",
-            ]),
-        }
-    }
-}
-
-#[derive(Component, Debug)]
-struct Particle {
-    size: f32,
-    lifetime: Timer,
-}
-
-// The event that will be fired once the fox feet hits the ground in the running animation.
-// It's also a resource to make it easier to re-use the asset handles for the mesh/material.
-#[derive(Resource, Event, Reflect, Clone)]
-#[reflect(AnimationEvent)]
-struct FoxStep {
-    mesh: Handle<Mesh>,
-    material: Handle<StandardMaterial>,
-}
-
-impl FromWorld for FoxStep {
-    fn from_world(world: &mut World) -> Self {
-        let mesh = world.resource_mut::<Assets<Mesh>>().add(Sphere::new(10.0));
-        let material = world
-            .resource_mut::<Assets<StandardMaterial>>()
-            .add(StandardMaterial::from_color(WHITE));
-        Self { mesh, material }
-    }
-}
-
-impl FoxStep {
-    fn observer(trigger: Trigger<Self>, query: Query<&GlobalTransform>, mut commands: Commands) {
-        let transform = query.get(trigger.entity()).unwrap().compute_transform();
-        commands.spawn((
-            Particle {
-                lifetime: Timer::from_seconds(1.0, TimerMode::Once),
-                size: 1.0,
-            },
-            MaterialMeshBundle {
-                mesh: trigger.event().mesh.clone(),
-                material: trigger.event().material.clone(),
-                transform: Transform {
-                    translation: transform.translation.reject_from(Vec3::Y),
-                    scale: Vec3::splat(1.0),
-                    ..Default::default()
-                },
-                ..Default::default()
-            },
-        ));
-    }
-}
-
-impl AnimationEvent for FoxStep {
-    fn trigger(&self, _time: f32, entity: Entity, world: &mut World) {
-        world.entity_mut(entity).trigger(self.clone());
-    }
-
-    fn clone_value(&self) -> Box<dyn AnimationEvent> {
-        Box::new(self.clone())
-    }
-}
-
 fn setup(
     mut commands: Commands,
     asset_server: Res<AssetServer>,
@@ -194,20 +69,19 @@ fn setup(
     });
 
     // Light
-    commands.spawn(DirectionalLightBundle {
-        transform: Transform::from_rotation(Quat::from_euler(EulerRot::ZYX, 0.0, 1.0, -PI / 4.)),
-        directional_light: DirectionalLight {
+    commands.spawn((
+        Transform::from_rotation(Quat::from_euler(EulerRot::ZYX, 0.0, 1.0, -PI / 4.)),
+        DirectionalLight {
             shadows_enabled: true,
             ..default()
         },
-        cascade_shadow_config: CascadeShadowConfigBuilder {
+        CascadeShadowConfigBuilder {
             first_cascade_far_bound: 200.0,
             maximum_distance: 400.0,
             ..default()
         }
-        .into(),
-        ..default()
-    });
+        .build(),
+    ));
 
     // Fox
     commands.spawn(SceneBundle {
@@ -222,7 +96,6 @@ fn setup(
     println!("  - digit 1 / 3 / 5: play the animation <digit> times");
     println!("  - L: loop the animation forever");
     println!("  - return: change animation");
-    println!("  - R: reverse animation");
 }
 
 // An `AnimationPlayer` is automatically added to the scene when it's ready.
@@ -230,23 +103,9 @@ fn setup(
 fn setup_scene_once_loaded(
     mut commands: Commands,
     animations: Res<Animations>,
-    feet: Res<FoxFeetIds>,
-    step: Res<FoxStep>,
-    mut clips: ResMut<Assets<AnimationClip>>,
-    graphs: Res<Assets<AnimationGraph>>,
     mut players: Query<(Entity, &mut AnimationPlayer), Added<AnimationPlayer>>,
 ) {
     for (entity, mut player) in &mut players {
-        let graph = graphs.get(&animations.graph).unwrap();
-        let node = graph.get(animations.animations[0]).unwrap();
-        let clip = clips.get_mut(node.clip.as_ref().unwrap()).unwrap();
-
-        // Fire the `FoxStep` event at certain times in the animation, targeting the different feet.
-        clip.add_event_to_target(feet.forward_right, 0.46, step.clone());
-        clip.add_event_to_target(feet.forward_left, 0.64, step.clone());
-        clip.add_event_to_target(feet.back_right, 0.14, step.clone());
-        clip.add_event_to_target(feet.back_left, 0.02, step.clone());
-
         let mut transitions = AnimationTransitions::new();
 
         // Make sure to start the animation via the `AnimationTransitions`
@@ -308,12 +167,6 @@ fn keyboard_animation_control(
             playing_animation.seek_to(elapsed + 0.1);
         }
 
-        if keyboard_input.just_pressed(KeyCode::KeyR) {
-            let playing_animation = player.animation_mut(playing_animation_index).unwrap();
-            let speed = playing_animation.speed();
-            playing_animation.set_speed(-speed);
-        }
-
         if keyboard_input.just_pressed(KeyCode::Enter) {
             *current_animation = (*current_animation + 1) % animations.animations.len();
 
@@ -353,16 +206,3 @@ fn keyboard_animation_control(
         }
     }
 }
-
-fn update_particle(
-    mut commands: Commands,
-    mut query: Query<(Entity, &mut Particle, &mut Transform)>,
-    time: Res<Time>,
-) {
-    for (entity, mut particle, mut transform) in &mut query {
-        if particle.lifetime.tick(time.delta()).just_finished() {
-            commands.entity(entity).despawn();
-        }
-        transform.scale = Vec3::ONE * particle.size.lerp(0.0, particle.lifetime.fraction());
-    }
-}

From 4118846392296f4de242541b7aff94951921e0a9 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Tue, 1 Oct 2024 16:22:21 +0200
Subject: [PATCH 40/89] print example controls

---
 examples/animation/bunny_detective.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/examples/animation/bunny_detective.rs b/examples/animation/bunny_detective.rs
index d1e3fd98a994c..96e4b4dbe0d0c 100644
--- a/examples/animation/bunny_detective.rs
+++ b/examples/animation/bunny_detective.rs
@@ -185,6 +185,9 @@ fn setup(
         scene: asset_server.load(GltfAssetLabel::Scene(0).from_asset(DETECTIVE_PATH)),
         ..default()
     });
+
+    println!("Controls:");
+    println!("  - spacebar: jump");
 }
 
 // An `AnimationPlayer` is automatically added to the scene when it's ready.

From e1cc404143f591b2c739ff79ef8c9d8adf11fe35 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Tue, 1 Oct 2024 16:33:39 +0200
Subject: [PATCH 41/89] don't use deprecated bundle

---
 examples/animation/bunny_detective.rs | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/examples/animation/bunny_detective.rs b/examples/animation/bunny_detective.rs
index 96e4b4dbe0d0c..c9252e37b9cf2 100644
--- a/examples/animation/bunny_detective.rs
+++ b/examples/animation/bunny_detective.rs
@@ -165,20 +165,19 @@ fn setup(
     });
 
     // Light
-    commands.spawn(DirectionalLightBundle {
-        transform: Transform::from_rotation(Quat::from_euler(EulerRot::ZYX, 0.0, 1.0, -PI / 4.)),
-        directional_light: DirectionalLight {
+    commands.spawn((
+        Transform::from_rotation(Quat::from_euler(EulerRot::ZYX, 0.0, 1.0, -PI / 4.)),
+        DirectionalLight {
             shadows_enabled: true,
             ..default()
         },
-        cascade_shadow_config: CascadeShadowConfigBuilder {
+        CascadeShadowConfigBuilder {
             first_cascade_far_bound: 2.0,
             maximum_distance: 10.0,
             ..default()
         }
-        .into(),
-        ..default()
-    });
+        .build(),
+    ));
 
     // Bunny Detective
     commands.spawn(SceneBundle {

From ab599a67aeea56eb0a3cf0206de1d9cdac85b90c Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Tue, 1 Oct 2024 16:34:17 +0200
Subject: [PATCH 42/89] Update README.md

---
 examples/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/README.md b/examples/README.md
index 50d0f30e805c3..d3d1aad22089d 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -193,7 +193,7 @@ Example | Description
 [Animation Events](../examples/animation/animation_events.rs) | Demonstrate how to use animation events
 [Animation Graph](../examples/animation/animation_graph.rs) | Blends multiple animations together with a graph
 [Animation Masks](../examples/animation/animation_masks.rs) | Demonstrates animation masks
-[Bunny Detective](../examples/animation/bunny_detective.rs) | Demonstrate how to use animation events with animated character
+[Bunny Detective](../examples/animation/bunny_detective.rs) | Demonstrate how to use animation events with an animated character
 [Color animation](../examples/animation/color_animation.rs) | Demonstrates how to animate colors using mixing and splines in different color spaces
 [Cubic Curve](../examples/animation/cubic_curve.rs) | Bezier curve example showing a cube following a cubic curve
 [Custom Skinned Mesh](../examples/animation/custom_skinned_mesh.rs) | Skinned mesh example with mesh and joints data defined in code

From d77beabc3675840fd6f29e827fc118299740d8fa Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Tue, 1 Oct 2024 17:41:02 +0200
Subject: [PATCH 43/89] fix bug

---
 crates/bevy_animation/src/lib.rs | 52 +++++++++++++++++---------------
 1 file changed, 27 insertions(+), 25 deletions(-)

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 759e58a305320..75930d5ef410a 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -1005,31 +1005,33 @@ impl<'a, 'b> Iterator for AnimationTriggersIter<'a, 'b> {
     fn next(&mut self) -> Option<Self::Item> {
         loop {
             let trigger = self.triggers.as_mut()?.next()?;
-            if match (
-                self.animation.is_playback_reversed(),
-                self.animation.just_completed,
-            ) {
-                // forward, trigger if `last_seek_time < trigger_time <= seek_time`
-                (false, false) => {
-                    Some(trigger.time) >= self.animation.last_seek_time
-                        && trigger.time <= self.animation.seek_time
-                }
-                // forward, completed this tick
-                (false, true) => {
-                    Some(trigger.time) >= self.animation.last_seek_time
-                        || trigger.time <= self.animation.seek_time
-                }
-                // reverse, trigger if `seek_time <= trigger_time < last_seek_time`
-                (true, false) => {
-                    Some(trigger.time) <= self.animation.last_seek_time
-                        && trigger.time >= self.animation.seek_time
-                }
-                // reverse, completed this tick
-                (true, true) => {
-                    Some(trigger.time) <= self.animation.last_seek_time
-                        || trigger.time >= self.animation.seek_time
+            if !self.animation.is_finished()
+                && match (
+                    self.animation.is_playback_reversed(),
+                    self.animation.just_completed,
+                ) {
+                    // forward, trigger if `last_seek_time < trigger_time <= seek_time`
+                    (false, false) => {
+                        Some(trigger.time) >= self.animation.last_seek_time
+                            && trigger.time <= self.animation.seek_time
+                    }
+                    // forward, completed this tick
+                    (false, true) => {
+                        Some(trigger.time) >= self.animation.last_seek_time
+                            || trigger.time <= self.animation.seek_time
+                    }
+                    // reverse, trigger if `seek_time <= trigger_time < last_seek_time`
+                    (true, false) => {
+                        Some(trigger.time) <= self.animation.last_seek_time
+                            && trigger.time >= self.animation.seek_time
+                    }
+                    // reverse, completed this tick
+                    (true, true) => {
+                        Some(trigger.time) <= self.animation.last_seek_time
+                            || trigger.time >= self.animation.seek_time
+                    }
                 }
-            } {
+            {
                 return Some(trigger);
             }
         }
@@ -1219,7 +1221,6 @@ impl Plugin for AnimationPlugin {
                 (
                     advance_transitions,
                     advance_animations,
-                    trigger_untargeted_animation_events,
                     // TODO: `animate_targets` can animate anything, so
                     // ambiguity testing currently considers it ambiguous with
                     // every other system in `PostUpdate`. We may want to move
@@ -1229,6 +1230,7 @@ impl Plugin for AnimationPlugin {
                     animate_targets_and_trigger_events
                         .after(bevy_render::mesh::morph::inherit_weights)
                         .ambiguous_with_all(),
+                    trigger_untargeted_animation_events,
                     expire_completed_transitions,
                 )
                     .chain()

From c74da72bc39418c3870f3916d6ea166e0ce48672 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Tue, 1 Oct 2024 18:25:39 +0200
Subject: [PATCH 44/89] Update bunny_detective.rs

---
 examples/animation/bunny_detective.rs | 307 +++++++++++++++++++++-----
 1 file changed, 247 insertions(+), 60 deletions(-)

diff --git a/examples/animation/bunny_detective.rs b/examples/animation/bunny_detective.rs
index c9252e37b9cf2..e6a4b39371ec6 100644
--- a/examples/animation/bunny_detective.rs
+++ b/examples/animation/bunny_detective.rs
@@ -7,7 +7,7 @@ use bevy::{
         animation_event::{AnimationEvent, ReflectAnimationEvent},
         AnimationTargetId,
     },
-    color::palettes::css::WHITE,
+    color::palettes::css::{ALICE_BLUE, WHITE},
     pbr::CascadeShadowConfigBuilder,
     prelude::*,
 };
@@ -17,18 +17,22 @@ const DETECTIVE_PATH: &str = "models/animated/buntective.glb";
 
 fn main() {
     App::new()
+        .register_type::<(OnLanded, OnJumped, OnStep)>()
         .add_plugins(DefaultPlugins)
         .insert_resource(AmbientLight {
             color: Color::WHITE,
             brightness: 2000.,
         })
-        .init_resource::<OnLanded>()
+        .init_resource::<ParticleAssets>()
+        .init_resource::<BoneTargets>()
         .add_systems(Startup, setup)
         .add_systems(
             Update,
             (setup_scene_once_loaded, jump_input, simulate_particles),
         )
         .observe(OnLanded::observer)
+        .observe(OnJumped::observer)
+        .observe(OnStep::observer)
         .run();
 }
 
@@ -39,6 +43,35 @@ struct Animations {
     graph: Handle<AnimationGraph>,
 }
 
+#[derive(Resource)]
+struct BoneTargets {
+    root: AnimationTargetId,
+    right_foot: AnimationTargetId,
+    left_foot: AnimationTargetId,
+}
+
+impl Default for BoneTargets {
+    fn default() -> Self {
+        Self {
+            root: AnimationTargetId::from_iter(["Armature"]),
+            right_foot: AnimationTargetId::from_iter([
+                "Armature",
+                "pelvis",
+                "upperleg.r",
+                "lowerleg.r",
+                "foot.r",
+            ]),
+            left_foot: AnimationTargetId::from_iter([
+                "Armature",
+                "pelvis",
+                "upperleg.l",
+                "lowerleg.l",
+                "foot.l",
+            ]),
+        }
+    }
+}
+
 #[derive(Component)]
 struct Particle {
     lifeteime: Timer,
@@ -46,16 +79,13 @@ struct Particle {
     velocity: Vec3,
 }
 
-// The event that will be fired once the detective hits the ground in the jump animation.
-// It's also a resource to make it easier to re-use the asset handles for the mesh and material.
-#[derive(Event, Resource, Reflect, Clone)]
-#[reflect(AnimationEvent)]
-struct OnLanded {
+#[derive(Resource)]
+struct ParticleAssets {
     mesh: Handle<Mesh>,
     material: Handle<StandardMaterial>,
 }
 
-impl FromWorld for OnLanded {
+impl FromWorld for ParticleAssets {
     fn from_world(world: &mut World) -> Self {
         Self {
             mesh: world.resource_mut::<Assets<Mesh>>().add(Sphere::new(0.25)),
@@ -69,62 +99,157 @@ impl FromWorld for OnLanded {
     }
 }
 
+#[derive(Event, Reflect, Clone)]
+#[reflect(AnimationEvent)]
+struct OnJumped;
+
+impl AnimationEvent for OnJumped {
+    fn trigger(&self, _player: Entity, _time: f32, target: Entity, world: &mut World) {
+        world.entity_mut(target).trigger(Self);
+    }
+
+    fn clone_value(&self) -> Box<dyn AnimationEvent> {
+        Box::new(Self)
+    }
+}
+
+impl OnJumped {
+    // Spawn particles once the detective jumps.
+    fn observer(
+        trigger: Trigger<Self>,
+        mut commands: Commands,
+        particle: Res<ParticleAssets>,
+        transforms: Query<&GlobalTransform>,
+    ) {
+        let translation = transforms.get(trigger.entity()).unwrap().translation();
+        let mut rng = thread_rng();
+        // Vertical
+        for _ in 0..5 {
+            let horizontal = rng.gen::<Dir2>() * rng.gen_range(0.0..0.2);
+            let vertical = rng.gen_range(0.0..10.0);
+            let size = rng.gen_range(0.5..1.0);
+            commands.queue(spawn_particle(
+                particle.mesh.clone(),
+                particle.material.clone(),
+                translation.reject_from_normalized(Vec3::Y),
+                rng.gen_range(0.1..0.5),
+                size,
+                Vec3::new(horizontal.x, vertical, horizontal.y),
+            ));
+        }
+        // Horizontal
+        for _ in 0..20 {
+            let horizontal = rng.gen::<Dir2>() * rng.gen_range(6.0..8.0);
+            let vertical = rng.gen_range(0.0..2.0);
+            let size = rng.gen_range(0.5..1.0);
+            commands.queue(spawn_particle(
+                particle.mesh.clone(),
+                particle.material.clone(),
+                translation.reject_from_normalized(Vec3::Y),
+                rng.gen_range(0.5..1.0),
+                size,
+                Vec3::new(horizontal.x, vertical, horizontal.y),
+            ));
+        }
+    }
+}
+
+#[derive(Event, Reflect, Clone)]
+#[reflect(AnimationEvent)]
+struct OnLanded;
+
 impl AnimationEvent for OnLanded {
-    fn trigger(&self, player: Entity, _time: f32, target: Entity, world: &mut World) {
-        println!("LANDED!");
-        world.entity_mut(target).trigger(self.clone());
-        // Trigger the event on the animation player as well in order to transition to the walk animation at the end of the jump.
-        // TODO: there might be better ways of doing this, works fine though
-        world.entity_mut(player).trigger(self.clone());
+    fn trigger(&self, _player: Entity, _time: f32, target: Entity, world: &mut World) {
+        world.entity_mut(target).trigger(Self);
     }
 
     fn clone_value(&self) -> Box<dyn AnimationEvent> {
-        Box::new(self.clone())
+        Box::new(Self)
     }
 }
 
 impl OnLanded {
-    // The observer that will run when the detective hits the ground in the jump animation.
+    // Spawn particles once the detective lands.
     fn observer(
         trigger: Trigger<Self>,
         mut commands: Commands,
+        particle: Res<ParticleAssets>,
         animations: Res<Animations>,
         mut players: Query<(&mut AnimationPlayer, &mut AnimationTransitions)>,
         transforms: Query<&GlobalTransform>,
     ) {
-        if let Ok((mut player, mut transitions)) = players.get_mut(trigger.entity()) {
-            // If this event was targeted to the animation player, transition to the walk animation.
-            // FIXME: setting the `transition_duration` to `1.0s` results in the `OnLanded` event being triggered many times when the transition ends.
-            // I think it's because the transition duration is then longer than the rest of the jump animation, and that causes the bug somehow.
-            transitions
-                .play(&mut player, animations.walk, Duration::from_secs_f32(0.5))
-                .repeat();
-        } else {
-            // spawn a bunch of particles :3
-            let translation = transforms.get(trigger.entity()).unwrap().translation();
-            let mut rng = thread_rng();
-            for _ in 0..25 {
-                let horizontal = rng.gen::<Dir2>() * rng.gen_range(8.0..12.0);
-                let vertical = rng.gen_range(0.0..4.0);
-                let size = rng.gen_range(0.5..1.0);
-                commands.spawn((
-                    Particle {
-                        lifeteime: Timer::from_seconds(1.0, TimerMode::Once),
-                        size,
-                        velocity: Vec3::new(horizontal.x, vertical, horizontal.y),
-                    },
-                    MaterialMeshBundle {
-                        mesh: trigger.event().mesh.clone(),
-                        material: trigger.event().material.clone(),
-                        transform: Transform {
-                            translation: translation.reject_from(Vec3::Y),
-                            scale: Vec3::splat(size),
-                            ..Default::default()
-                        },
-                        ..Default::default()
-                    },
-                ));
-            }
+        // Transition to the `walk` animation.
+        let (mut player, mut transitions) = players.get_mut(trigger.entity()).unwrap();
+        transitions
+            .play(&mut player, animations.walk, Duration::from_secs_f32(1.0))
+            .repeat();
+
+        let translation = transforms.get(trigger.entity()).unwrap().translation();
+        let mut rng = thread_rng();
+        for _ in 0..25 {
+            let horizontal = rng.gen::<Dir2>() * rng.gen_range(8.0..12.0);
+            let vertical = rng.gen_range(0.0..4.0);
+            let size = rng.gen_range(0.5..1.0);
+            commands.queue(spawn_particle(
+                particle.mesh.clone(),
+                particle.material.clone(),
+                translation.reject_from_normalized(Vec3::Y),
+                rng.gen_range(0.5..1.0),
+                size,
+                Vec3::new(horizontal.x, vertical, horizontal.y),
+            ));
+        }
+    }
+}
+
+#[derive(Event, Resource, Reflect, Clone)]
+#[reflect(AnimationEvent)]
+enum OnStep {
+    Start,
+    End,
+}
+
+impl AnimationEvent for OnStep {
+    fn trigger(&self, _player: Entity, _time: f32, target: Entity, world: &mut World) {
+        world.entity_mut(target).trigger(self.clone());
+    }
+
+    fn clone_value(&self) -> Box<dyn AnimationEvent> {
+        Box::new(self.clone())
+    }
+}
+
+impl OnStep {
+    // Spawn particles on each step the detective takes.
+    fn observer(
+        trigger: Trigger<Self>,
+        mut commands: Commands,
+        particle: Res<ParticleAssets>,
+        transforms: Query<&GlobalTransform>,
+    ) {
+        let translation = transforms.get(trigger.entity()).unwrap().translation();
+        let mut rng = thread_rng();
+        for _ in 0..25 {
+            let velocity = match trigger.event() {
+                OnStep::Start => {
+                    let horizontal = rng.gen::<Dir2>() * rng.gen_range(1.0..2.0);
+                    let vertical = rng.gen_range(0.0..2.0);
+                    Vec3::new(horizontal.x, vertical, horizontal.y)
+                }
+                OnStep::End => Vec3::new(
+                    rng.gen_range(-0.2..0.2),
+                    rng.gen_range(0.0..2.0),
+                    -rng.gen_range(0.0..10.0),
+                ),
+            };
+            commands.queue(spawn_particle(
+                particle.mesh.clone(),
+                particle.material.clone(),
+                translation.reject_from_normalized(Vec3::Y),
+                rng.gen_range(0.1..0.5),
+                rng.gen_range(0.1..1.0),
+                velocity,
+            ));
         }
     }
 }
@@ -153,6 +278,10 @@ fn setup(
     // Camera
     commands.spawn(Camera3dBundle {
         transform: Transform::from_xyz(2.0, 3.0, 5.0).looking_at(Vec3::new(0.0, 1.5, 0.0), Vec3::Y),
+        camera: Camera {
+            clear_color: ClearColorConfig::Custom(ALICE_BLUE.into()),
+            ..Default::default()
+        },
         ..default()
     });
 
@@ -160,7 +289,6 @@ fn setup(
     commands.spawn(PbrBundle {
         mesh: meshes.add(Plane3d::default().mesh().size(500000.0, 500000.0)),
         material: materials.add(Color::srgb(0.3, 0.5, 0.3)),
-        transform: Transform::from_xyz(0.0, -0.075, 0.0),
         ..default()
     });
 
@@ -193,24 +321,54 @@ fn setup(
 // When the player is added, start the `walk` animation and add the `OnLanded` event.
 fn setup_scene_once_loaded(
     mut commands: Commands,
-    landed: Res<OnLanded>,
     animations: Res<Animations>,
+    bones: Res<BoneTargets>,
     graphs: Res<Assets<AnimationGraph>>,
     mut clips: ResMut<Assets<AnimationClip>>,
     mut players: Query<(Entity, &mut AnimationPlayer), Added<AnimationPlayer>>,
 ) {
     for (entity, mut player) in &mut players {
         let graph = graphs.get(&animations.graph).unwrap();
-        let node = graph.get(animations.jump).unwrap();
-        let clip = node.clip.as_ref().and_then(|id| clips.get_mut(id)).unwrap();
-
-        // Get the id of the "pelvis" bone, this is used to spawn the particles
-        // TODO: this is not necessary in this case but I want to demonstrate the use of `add_event_to_target`
-        let target_id = AnimationTargetId::from_iter(["Armature", "pelvis"]);
-        // Trigger the `OnLanded` event on 0.53s in the jump animation.
-        // The detective hits the ground between frame 8 and 9 and the frame rate is 16 fps.
+
+        let jump_node = graph.get(animations.jump).unwrap();
+        let jump_clip = jump_node
+            .clip
+            .as_ref()
+            .and_then(|id| clips.get_mut(id))
+            .unwrap();
+
+        // The jump height in the original animation is not very impressive :(
+        // make it a little bit higher.
+        jump_clip.add_curve_to_target(
+            bones.root,
+            TranslationCurve(
+                AnimatableKeyframeCurve::new([
+                    (0.0, Vec3::ZERO),
+                    (0.3, Vec3::Y * 0.5),
+                    (0.5, Vec3::ZERO),
+                ])
+                .unwrap(),
+            ),
+        );
+
+        jump_clip.add_event(0.0, OnJumped);
+        // Trigger the `OnLanded` event after 0.53s in the jump animation.
+        // The feet hits the ground between frame 8 and 9 and the frame rate is 16 fps.
         // 8.5 / 16 = 5.3
-        clip.add_event_to_target(target_id, 0.53, landed.clone());
+        jump_clip.add_event(0.53, OnLanded);
+
+        let walk_node = graph.get(animations.walk).unwrap();
+        let walk_clip = walk_node
+            .clip
+            .as_ref()
+            .and_then(|id| clips.get_mut(id))
+            .unwrap();
+
+        // Trigger `OnStep` events targeting the feet.
+        walk_clip.add_event_to_target(bones.left_foot, 0.05, OnStep::Start);
+        walk_clip.add_event_to_target(bones.left_foot, 0.5, OnStep::End);
+        walk_clip.add_event_to_target(bones.right_foot, 0.55, OnStep::Start);
+        walk_clip.add_event_to_target(bones.right_foot, 0.0, OnStep::End);
 
         let mut transitions = AnimationTransitions::new();
 
@@ -260,3 +418,32 @@ fn simulate_particles(
         if transform.scale.length_squared() < 0.01 {}
     }
 }
+
+fn spawn_particle<M: Material>(
+    mesh: Handle<Mesh>,
+    material: Handle<M>,
+    translation: Vec3,
+    lifetime: f32,
+    size: f32,
+    velocity: Vec3,
+) -> impl Command {
+    move |world: &mut World| {
+        world.spawn((
+            Particle {
+                lifeteime: Timer::from_seconds(lifetime, TimerMode::Once),
+                size,
+                velocity,
+            },
+            MaterialMeshBundle {
+                mesh,
+                material,
+                transform: Transform {
+                    translation,
+                    scale: Vec3::splat(size),
+                    ..Default::default()
+                },
+                ..Default::default()
+            },
+        ));
+    }
+}

From 8636ea6a4a6ea5930f8e71d37ecff4ddbb3b24cf Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Tue, 1 Oct 2024 18:40:31 +0200
Subject: [PATCH 45/89] remove unwrap

---
 crates/bevy_animation/src/lib.rs | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 75930d5ef410a..d20271fc5f523 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -1052,10 +1052,18 @@ fn trigger_untargeted_animation_events(
         };
 
         for (index, active_animation) in player.active_animations.iter() {
-            let Some(clip_id) = graph.get(*index).unwrap().clip.as_ref() else {
+            if !active_animation.is_finished() {
+                continue;
+            }
+
+            let Some(clip) = graph
+                .get(*index)
+                .and_then(|node| node.clip.as_ref())
+                .and_then(|id| clips.get(id))
+            else {
                 continue;
             };
-            let clip = clips.get(clip_id).unwrap();
+
             for trigger in AnimationTriggersIter::new(None, clip, active_animation) {
                 commands.queue(trigger_animation_event(
                     entity,

From 7bffcccea5d8c16e4ea44f969857233d70cd90a6 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Tue, 1 Oct 2024 18:51:49 +0200
Subject: [PATCH 46/89] ugh

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

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index d20271fc5f523..bf59249c520fb 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -1052,7 +1052,7 @@ fn trigger_untargeted_animation_events(
         };
 
         for (index, active_animation) in player.active_animations.iter() {
-            if !active_animation.is_finished() {
+            if active_animation.is_finished() {
                 continue;
             }
 

From 2148f769c63f68f6487ccac60c90f94c5ef5a054 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Wed, 2 Oct 2024 03:09:49 +0200
Subject: [PATCH 47/89] fix bugs + add tests + renames

---
 crates/bevy_animation/src/animation_event.rs |   6 +-
 crates/bevy_animation/src/lib.rs             | 281 ++++++++++++++-----
 crates/bevy_internal/src/default_plugins.rs  |   2 +-
 examples/animation/animated_fox.rs           |   7 +-
 examples/animation/animation_graph.rs        |   7 +-
 5 files changed, 221 insertions(+), 82 deletions(-)

diff --git a/crates/bevy_animation/src/animation_event.rs b/crates/bevy_animation/src/animation_event.rs
index 93be99793a520..b41435c183a62 100644
--- a/crates/bevy_animation/src/animation_event.rs
+++ b/crates/bevy_animation/src/animation_event.rs
@@ -10,13 +10,13 @@ use bevy_reflect::{
 };
 
 pub(crate) fn trigger_animation_event(
-    player: Entity,
+    player_entity: Entity,
+    target_entity: Entity,
     time: f32,
     event: Box<dyn AnimationEvent>,
-    target: Entity,
 ) -> impl Command {
     move |world: &mut World| {
-        event.trigger(player, time, target, world);
+        event.trigger(player_entity, time, target_entity, world);
     }
 }
 
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index bf59249c520fb..fd09cead8e3fe 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -581,11 +581,12 @@ impl ActiveAnimation {
     /// Update the animation given the delta time and the duration of the clip being played.
     #[inline]
     fn update(&mut self, delta: f32, clip_duration: f32) {
+        self.just_completed = false;
+
         if self.is_finished() {
             return;
         }
 
-        self.just_completed = false;
         self.last_seek_time = Some(self.seek_time);
 
         self.elapsed += delta;
@@ -615,6 +616,7 @@ impl ActiveAnimation {
     pub fn replay(&mut self) {
         self.completions = 0;
         self.elapsed = 0.0;
+        self.last_seek_time = None;
         self.seek_time = 0.0;
     }
 
@@ -983,18 +985,18 @@ pub fn advance_animations(
 
 struct AnimationTriggersIter<'a, 'b> {
     triggers: Option<core::slice::Iter<'a, AnimationEventKey>>,
-    animation: &'b ActiveAnimation,
+    active_animation: &'b ActiveAnimation,
 }
 
 impl<'a, 'b> AnimationTriggersIter<'a, 'b> {
     fn new(
         target_id: Option<AnimationTargetId>,
         clip: &'a AnimationClip,
-        animation: &'b ActiveAnimation,
+        active_animation: &'b ActiveAnimation,
     ) -> Self {
         Self {
             triggers: clip.events.get(&target_id).map(|v| v.iter()),
-            animation,
+            active_animation,
         }
     }
 }
@@ -1003,35 +1005,41 @@ impl<'a, 'b> Iterator for AnimationTriggersIter<'a, 'b> {
     type Item = &'a AnimationEventKey;
 
     fn next(&mut self) -> Option<Self::Item> {
+        // if the animation is finished (unless it was this tick), return early
+        if !self.active_animation.just_completed && self.active_animation.is_finished() {
+            return None;
+        }
         loop {
             let trigger = self.triggers.as_mut()?.next()?;
-            if !self.animation.is_finished()
-                && match (
-                    self.animation.is_playback_reversed(),
-                    self.animation.just_completed,
-                ) {
-                    // forward, trigger if `last_seek_time < trigger_time <= seek_time`
-                    (false, false) => {
-                        Some(trigger.time) >= self.animation.last_seek_time
-                            && trigger.time <= self.animation.seek_time
-                    }
-                    // forward, completed this tick
-                    (false, true) => {
-                        Some(trigger.time) >= self.animation.last_seek_time
-                            || trigger.time <= self.animation.seek_time
-                    }
-                    // reverse, trigger if `seek_time <= trigger_time < last_seek_time`
-                    (true, false) => {
-                        Some(trigger.time) <= self.animation.last_seek_time
-                            && trigger.time >= self.animation.seek_time
-                    }
-                    // reverse, completed this tick
-                    (true, true) => {
-                        Some(trigger.time) <= self.animation.last_seek_time
-                            || trigger.time >= self.animation.seek_time
-                    }
+            if match (
+                self.active_animation.is_playback_reversed(),
+                self.active_animation.just_completed && !self.active_animation.is_finished(),
+            ) {
+                // forward, trigger if `last_seek_time < trigger_time <= seek_time`
+                (false, false) => {
+                    self.active_animation.last_seek_time.map(|t| trigger.time > t).unwrap_or(true)
+                    // Some(trigger.time) >= self.active_animation.last_seek_time
+                        && trigger.time <= self.active_animation.seek_time
                 }
-            {
+                // forward, it looped this tick and we have to keep wrapping in mind
+                (false, true) => {
+                    self.active_animation.last_seek_time.map(|t| trigger.time > t).unwrap_or(true)
+                    // Some(trigger.time) >= self.active_animation.last_seek_time
+                        || trigger.time <= self.active_animation.seek_time
+                }
+                // reverse, trigger if `seek_time <= trigger_time < last_seek_time`
+                (true, false) => {
+                    self.active_animation.last_seek_time.map(|t| trigger.time <= t).unwrap_or(false)
+                    // Some(trigger.time) <= self.active_animation.last_seek_time
+                        && trigger.time > self.active_animation.seek_time
+                }
+                // reverse, looped this tick
+                (true, true) => {
+                    self.active_animation.last_seek_time.map(|t| trigger.time <= t).unwrap_or(false)
+                    // Some(trigger.time) <= self.active_animation.last_seek_time
+                        || trigger.time > self.active_animation.seek_time
+                }
+            } {
                 return Some(trigger);
             }
         }
@@ -1039,23 +1047,19 @@ impl<'a, 'b> Iterator for AnimationTriggersIter<'a, 'b> {
 }
 
 /// A system that triggers untargeted animation events for the currently-playing animations.
-fn trigger_untargeted_animation_events(
+fn trigger_animation_events(
     mut commands: Commands,
     clips: Res<Assets<AnimationClip>>,
     graphs: Res<Assets<AnimationGraph>>,
     players: Query<(Entity, &AnimationPlayer, &Handle<AnimationGraph>)>,
+    targets: Query<(Entity, &AnimationTarget)>,
 ) {
-    for (entity, player, graph_id) in &players {
-        // The graph might not have loaded yet. Safely bail.
-        let Some(graph) = graphs.get(graph_id) else {
-            return;
-        };
-
+    let mut trigger_events_loop = |target_id,
+                                   player_entity,
+                                   target_entity,
+                                   player: &AnimationPlayer,
+                                   graph: &AnimationGraph| {
         for (index, active_animation) in player.active_animations.iter() {
-            if active_animation.is_finished() {
-                continue;
-            }
-
             let Some(clip) = graph
                 .get(*index)
                 .and_then(|node| node.clip.as_ref())
@@ -1064,15 +1068,44 @@ fn trigger_untargeted_animation_events(
                 continue;
             };
 
-            for trigger in AnimationTriggersIter::new(None, clip, active_animation) {
+            for trigger in AnimationTriggersIter::new(target_id, clip, active_animation) {
                 commands.queue(trigger_animation_event(
-                    entity,
+                    player_entity,
+                    target_entity,
                     trigger.time,
                     trigger.event.clone().0,
-                    entity,
                 ));
             }
         }
+    };
+
+    // untargeted events
+    for (entity, player, graph_id) in &players {
+        // The graph might not have loaded yet. Safely bail.
+        let Some(graph) = graphs.get(graph_id) else {
+            return;
+        };
+
+        trigger_events_loop(None, entity, entity, player, graph);
+    }
+
+    // targeted events
+    for (target_entity, target) in &targets {
+        let &AnimationTarget {
+            id: target_id,
+            player: player_entity,
+        } = target;
+
+        let Ok((_, player, graph_handle)) = players.get(player_entity) else {
+            return;
+        };
+
+        // The graph might not have loaded yet. Safely bail.
+        let Some(graph) = graphs.get(graph_handle) else {
+            return;
+        };
+
+        trigger_events_loop(Some(target_id), player_entity, target_entity, player, graph);
     }
 }
 
@@ -1089,24 +1122,16 @@ pub type AnimationEntityMut<'w> = EntityMutExcept<
 
 /// A system that modifies animation targets (e.g. bones in a skinned mesh)
 /// according to the currently-playing animations.
-///
-/// Also triggers animation events.
-pub fn animate_targets_and_trigger_events(
-    par_commands: ParallelCommands,
+pub fn animate_targets(
     clips: Res<Assets<AnimationClip>>,
     graphs: Res<Assets<AnimationGraph>>,
     players: Query<(&AnimationPlayer, &Handle<AnimationGraph>)>,
-    mut targets: Query<(
-        Entity,
-        &AnimationTarget,
-        Option<&mut Transform>,
-        AnimationEntityMut,
-    )>,
+    mut targets: Query<(&AnimationTarget, Option<&mut Transform>, AnimationEntityMut)>,
 ) {
     // Evaluate all animation targets in parallel.
     targets
         .par_iter_mut()
-        .for_each(|(entity, target, mut transform, mut entity_mut)| {
+        .for_each(|(target, mut transform, mut entity_mut)| {
             let &AnimationTarget {
                 id: target_id,
                 player: player_id,
@@ -1174,17 +1199,6 @@ pub fn animate_targets_and_trigger_events(
                     continue;
                 };
 
-                for trigger in AnimationTriggersIter::new(Some(target_id), clip, active_animation) {
-                    par_commands.command_scope(|mut commands| {
-                        commands.queue(trigger_animation_event(
-                            player_id,
-                            trigger.time,
-                            trigger.event.clone().0,
-                            entity,
-                        ));
-                    });
-                }
-
                 let Some(curves) = clip.curves_for_target(target_id) else {
                     continue;
                 };
@@ -1227,6 +1241,7 @@ impl Plugin for AnimationPlugin {
             .add_systems(
                 PostUpdate,
                 (
+                    trigger_animation_events,
                     advance_transitions,
                     advance_animations,
                     // TODO: `animate_targets` can animate anything, so
@@ -1235,10 +1250,9 @@ impl Plugin for AnimationPlugin {
                     // it to its own system set after `Update` but before
                     // `PostUpdate`. For now, we just disable ambiguity testing
                     // for this system.
-                    animate_targets_and_trigger_events
+                    animate_targets
                         .after(bevy_render::mesh::morph::inherit_weights)
                         .ambiguous_with_all(),
-                    trigger_untargeted_animation_events,
                     expire_completed_transitions,
                 )
                     .chain()
@@ -1305,3 +1319,134 @@ impl AnimationGraphEvaluator {
             .extend(iter::repeat(EvaluatedAnimationGraphNode::default()).take(node_count));
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[derive(Event, Clone, Reflect)]
+    struct A;
+
+    impl AnimationEvent for A {
+        fn trigger(&self, _: Entity, _: f32, target: Entity, world: &mut World) {
+            world.entity_mut(target).trigger(self.clone());
+        }
+
+        fn clone_value(&self) -> Box<dyn AnimationEvent> {
+            Box::new(self.clone())
+        }
+    }
+
+    #[test]
+    fn test_events_triggers_on_animation() {
+        let mut active_animation = ActiveAnimation::default();
+        let mut clip = AnimationClip::default();
+        clip.add_event(0.0, A);
+        clip.add_event(0.2, A);
+        assert_eq!(0.2, clip.duration);
+
+        assert_eq!(None, active_animation.last_seek_time);
+        assert_eq!(0.0, active_animation.seek_time);
+        assert!(!active_animation.just_completed);
+        assert_eq!(
+            vec![0.0],
+            AnimationTriggersIter::new(None, &clip, &active_animation)
+                .map(|t| t.time)
+                .collect::<Vec<f32>>()
+        );
+
+        active_animation.update(0.1, clip.duration);
+        assert_eq!(Some(0.0), active_animation.last_seek_time);
+        assert_eq!(0.1, active_animation.seek_time);
+        assert!(!active_animation.just_completed);
+        assert!(AnimationTriggersIter::new(None, &clip, &active_animation)
+            .next()
+            .is_none());
+
+        active_animation.update(0.1, clip.duration);
+        assert_eq!(Some(0.1), active_animation.last_seek_time);
+        assert_eq!(0.2, active_animation.seek_time);
+        assert!(active_animation.just_completed);
+        assert_eq!(
+            vec![0.2],
+            AnimationTriggersIter::new(None, &clip, &active_animation)
+                .map(|t| t.time)
+                .collect::<Vec<f32>>()
+        );
+
+        active_animation.update(0.1, clip.duration);
+        assert_eq!(Some(0.1), active_animation.last_seek_time);
+        assert_eq!(0.2, active_animation.seek_time);
+        assert!(!active_animation.just_completed);
+        assert_eq!(
+            Vec::<f32>::new(),
+            AnimationTriggersIter::new(None, &clip, &active_animation)
+                .map(|t| t.time)
+                .collect::<Vec<f32>>()
+        );
+    }
+
+    #[test]
+    fn test_events_triggers_on_looping_animation() {
+        let mut active_animation = ActiveAnimation::default();
+        active_animation.repeat = RepeatAnimation::Forever;
+        let mut clip = AnimationClip::default();
+        clip.add_event(0.0, A);
+        clip.add_event(0.2, A);
+        clip.add_event(0.3, A);
+        assert_eq!(0.3, clip.duration);
+
+        assert_eq!(None, active_animation.last_seek_time);
+        assert_eq!(0.0, active_animation.seek_time);
+        assert!(!active_animation.just_completed);
+        assert_eq!(
+            vec![0.0],
+            AnimationTriggersIter::new(None, &clip, &active_animation)
+                .map(|t| t.time)
+                .collect::<Vec<f32>>()
+        );
+
+        active_animation.update(0.1, clip.duration);
+        assert_eq!(Some(0.0), active_animation.last_seek_time);
+        assert_eq!(0.1, active_animation.seek_time);
+        assert!(!active_animation.just_completed);
+        assert_eq!(
+            Vec::<f32>::new(),
+            AnimationTriggersIter::new(None, &clip, &active_animation)
+                .map(|t| t.time)
+                .collect::<Vec<f32>>()
+        );
+
+        active_animation.update(0.1, clip.duration);
+        assert_eq!(Some(0.1), active_animation.last_seek_time);
+        assert_eq!(0.2, active_animation.seek_time);
+        assert_eq!(
+            vec![0.2],
+            AnimationTriggersIter::new(None, &clip, &active_animation)
+                .map(|t| t.time)
+                .collect::<Vec<f32>>()
+        );
+
+        active_animation.update(0.1, clip.duration);
+        assert_eq!(Some(0.2), active_animation.last_seek_time);
+        assert_eq!(0.0, active_animation.seek_time);
+        assert!(active_animation.just_completed);
+        assert_eq!(
+            vec![0.0, 0.3],
+            AnimationTriggersIter::new(None, &clip, &active_animation)
+                .map(|t| t.time)
+                .collect::<Vec<f32>>()
+        );
+
+        active_animation.update(0.1, clip.duration);
+        assert_eq!(Some(0.0), active_animation.last_seek_time);
+        assert_eq!(0.1, active_animation.seek_time);
+        assert!(!active_animation.just_completed);
+        assert_eq!(
+            Vec::<f32>::new(),
+            AnimationTriggersIter::new(None, &clip, &active_animation)
+                .map(|t| t.time)
+                .collect::<Vec<f32>>()
+        );
+    }
+}
diff --git a/crates/bevy_internal/src/default_plugins.rs b/crates/bevy_internal/src/default_plugins.rs
index 84721cfbf38e0..74008dafafcc8 100644
--- a/crates/bevy_internal/src/default_plugins.rs
+++ b/crates/bevy_internal/src/default_plugins.rs
@@ -141,7 +141,7 @@ impl Plugin for IgnoreAmbiguitiesPlugin {
             );
             app.ignore_ambiguity(
                 bevy_app::PostUpdate,
-                bevy_animation::animate_targets_and_trigger_events,
+                bevy_animation::animate_targets,
                 bevy_ui::ui_layout_system,
             );
         }
diff --git a/examples/animation/animated_fox.rs b/examples/animation/animated_fox.rs
index 1a22ee2f6c008..6b9271cad810a 100644
--- a/examples/animation/animated_fox.rs
+++ b/examples/animation/animated_fox.rs
@@ -3,7 +3,7 @@
 use std::{f32::consts::PI, time::Duration};
 
 use bevy::{
-    animation::{animate_targets_and_trigger_events, RepeatAnimation},
+    animation::{animate_targets, RepeatAnimation},
     pbr::CascadeShadowConfigBuilder,
     prelude::*,
 };
@@ -18,10 +18,7 @@ fn main() {
         })
         .add_plugins(DefaultPlugins)
         .add_systems(Startup, setup)
-        .add_systems(
-            Update,
-            setup_scene_once_loaded.before(animate_targets_and_trigger_events),
-        )
+        .add_systems(Update, setup_scene_once_loaded.before(animate_targets))
         .add_systems(Update, keyboard_animation_control)
         .run();
 }
diff --git a/examples/animation/animation_graph.rs b/examples/animation/animation_graph.rs
index 40a8b1c9fd008..906896b3c8cc9 100644
--- a/examples/animation/animation_graph.rs
+++ b/examples/animation/animation_graph.rs
@@ -4,7 +4,7 @@
 //! playing animations by clicking and dragging left or right within the nodes.
 
 use bevy::{
-    animation::animate_targets_and_trigger_events,
+    animation::animate_targets,
     color::palettes::{
         basic::WHITE,
         css::{ANTIQUE_WHITE, DARK_GREEN},
@@ -83,10 +83,7 @@ fn main() {
             ..default()
         }))
         .add_systems(Startup, (setup_assets, setup_scene, setup_ui))
-        .add_systems(
-            Update,
-            init_animations.before(animate_targets_and_trigger_events),
-        )
+        .add_systems(Update, init_animations.before(animate_targets))
         .add_systems(
             Update,
             (handle_weight_drag, update_ui, sync_weights).chain(),

From 47f525acb156666026c5a544bc949f343efd65dd Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Wed, 2 Oct 2024 03:15:41 +0200
Subject: [PATCH 48/89] clippy + comments

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

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index fd09cead8e3fe..00e07e5ad0489 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -1046,7 +1046,7 @@ impl<'a, 'b> Iterator for AnimationTriggersIter<'a, 'b> {
     }
 }
 
-/// A system that triggers untargeted animation events for the currently-playing animations.
+/// A system that triggers animation events for the currently-playing animations.
 fn trigger_animation_events(
     mut commands: Commands,
     clips: Res<Assets<AnimationClip>>,
@@ -1241,6 +1241,8 @@ impl Plugin for AnimationPlugin {
             .add_systems(
                 PostUpdate,
                 (
+                    // `trigger_animation_events` has to run before `advance_animations` and `advance_transitions`
+                    // because if not, it won't trigger events that occur on the first tick of an animation.
                     trigger_animation_events,
                     advance_transitions,
                     advance_animations,
@@ -1388,8 +1390,10 @@ mod tests {
 
     #[test]
     fn test_events_triggers_on_looping_animation() {
-        let mut active_animation = ActiveAnimation::default();
-        active_animation.repeat = RepeatAnimation::Forever;
+        let mut active_animation = ActiveAnimation {
+            repeat: RepeatAnimation::Forever,
+            ..Default::default()
+        };
         let mut clip = AnimationClip::default();
         clip.add_event(0.0, A);
         clip.add_event(0.2, A);

From a7931d6b1a45d0f9e63d673072ea2b52fd36dedf Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Wed, 2 Oct 2024 03:21:09 +0200
Subject: [PATCH 49/89] Update lib.rs

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

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 00e07e5ad0489..48ae4eec25728 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -614,6 +614,7 @@ impl ActiveAnimation {
 
     /// Reset back to the initial state as if no time has elapsed.
     pub fn replay(&mut self) {
+        self.just_completed = false;
         self.completions = 0;
         self.elapsed = 0.0;
         self.last_seek_time = None;

From f8fd00b2560db068e7a4b696247db581ae909d84 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Wed, 2 Oct 2024 03:43:48 +0200
Subject: [PATCH 50/89] use required components

---
 examples/animation/bunny_detective.rs | 29 +++++++++++----------------
 1 file changed, 12 insertions(+), 17 deletions(-)

diff --git a/examples/animation/bunny_detective.rs b/examples/animation/bunny_detective.rs
index e6a4b39371ec6..16ad3ea921b52 100644
--- a/examples/animation/bunny_detective.rs
+++ b/examples/animation/bunny_detective.rs
@@ -286,11 +286,10 @@ fn setup(
     });
 
     // Plane
-    commands.spawn(PbrBundle {
-        mesh: meshes.add(Plane3d::default().mesh().size(500000.0, 500000.0)),
-        material: materials.add(Color::srgb(0.3, 0.5, 0.3)),
-        ..default()
-    });
+    commands.spawn((
+        Mesh3d(meshes.add(Plane3d::default().mesh().size(500000.0, 500000.0))),
+        MeshMaterial3d(materials.add(Color::srgb(0.3, 0.5, 0.3))),
+    ));
 
     // Light
     commands.spawn((
@@ -308,10 +307,9 @@ fn setup(
     ));
 
     // Bunny Detective
-    commands.spawn(SceneBundle {
-        scene: asset_server.load(GltfAssetLabel::Scene(0).from_asset(DETECTIVE_PATH)),
-        ..default()
-    });
+    commands.spawn(SceneRoot(
+        asset_server.load(GltfAssetLabel::Scene(0).from_asset(DETECTIVE_PATH)),
+    ));
 
     println!("Controls:");
     println!("  - spacebar: jump");
@@ -434,14 +432,11 @@ fn spawn_particle<M: Material>(
                 size,
                 velocity,
             },
-            MaterialMeshBundle {
-                mesh,
-                material,
-                transform: Transform {
-                    translation,
-                    scale: Vec3::splat(size),
-                    ..Default::default()
-                },
+            Mesh3d(mesh),
+            MeshMaterial3d(material),
+            Transform {
+                translation,
+                scale: Vec3::splat(size),
                 ..Default::default()
             },
         ));

From 6b8665af77eaa3e87bf94686145b152abde8e0a7 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Wed, 2 Oct 2024 15:51:36 +0200
Subject: [PATCH 51/89] Update lib.rs

---
 crates/bevy_animation/src/lib.rs | 253 ++++++++++++++++++-------------
 1 file changed, 145 insertions(+), 108 deletions(-)

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 4ce894f395421..d8b353e895218 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -64,8 +64,12 @@ use uuid::Uuid;
 pub mod prelude {
     #[doc(hidden)]
     pub use crate::{
-        animatable::*, animation_curves::*, graph::*, transition::*, AnimationClip,
-        AnimationPlayer, AnimationPlugin, VariableCurve,
+        animatable::*,
+        animation_curves::*,
+        animation_event::{AnimationEvent, ReflectAnimationEvent},
+        graph::*,
+        transition::*,
+        AnimationClip, AnimationPlayer, AnimationPlugin, VariableCurve,
     };
 }
 
@@ -452,7 +456,7 @@ impl AnimationClip {
     ///
     /// The `event` will trigger on the entity matching the target once the `time` is reached in the animation.
     ///
-    /// Use [`add_event`](Self::add_event) if you don't have a specific target.
+    /// Use [`add_event`](Self::add_event) instead if you don't have a specific target.
     pub fn add_event_to_target(
         &mut self,
         target_id: AnimationTargetId,
@@ -703,6 +707,7 @@ impl ActiveAnimation {
 
     /// Seeks to a specific time in the animation.
     pub fn seek_to(&mut self, seek_time: f32) -> &mut Self {
+        self.last_seek_time = Some(self.seek_time);
         self.seek_time = seek_time;
         self
     }
@@ -902,94 +907,12 @@ impl AnimationPlayer {
     }
 }
 
-/// A system that advances the time for all playing animations.
-pub fn advance_animations(
-    time: Res<Time>,
-    animation_clips: Res<Assets<AnimationClip>>,
-    animation_graphs: Res<Assets<AnimationGraph>>,
-    mut players: Query<(&mut AnimationPlayer, &Handle<AnimationGraph>)>,
-    animation_graph_evaluator: Local<ThreadLocal<RefCell<AnimationGraphEvaluator>>>,
-) {
-    let delta_seconds = time.delta_seconds();
-    players
-        .par_iter_mut()
-        .for_each(|(mut player, graph_handle)| {
-            let Some(animation_graph) = animation_graphs.get(graph_handle) else {
-                return;
-            };
-
-            // Tick animations, and schedule them.
-            //
-            // We use a thread-local here so we can reuse allocations across
-            // frames.
-            let mut evaluator = animation_graph_evaluator.get_or_default().borrow_mut();
-
-            let AnimationPlayer {
-                ref mut active_animations,
-                ref blend_weights,
-                ..
-            } = *player;
-
-            // Reset our state.
-            evaluator.reset(animation_graph.root, animation_graph.graph.node_count());
-
-            while let Some(node_index) = evaluator.dfs_stack.pop() {
-                // Skip if we've already visited this node.
-                if evaluator.dfs_visited.put(node_index.index()) {
-                    continue;
-                }
-
-                let node = &animation_graph[node_index];
-
-                // Calculate weight and mask from the graph.
-                let (mut weight, mut mask) = (node.weight, node.mask);
-                for parent_index in animation_graph
-                    .graph
-                    .neighbors_directed(node_index, Direction::Incoming)
-                {
-                    let evaluated_parent = &evaluator.nodes[parent_index.index()];
-                    weight *= evaluated_parent.weight;
-                    mask |= evaluated_parent.mask;
-                }
-                evaluator.nodes[node_index.index()] = EvaluatedAnimationGraphNode { weight, mask };
-
-                if let Some(active_animation) = active_animations.get_mut(&node_index) {
-                    // Tick the animation if necessary.
-                    if !active_animation.paused {
-                        if let Some(ref clip_handle) = node.clip {
-                            if let Some(clip) = animation_clips.get(clip_handle) {
-                                active_animation.update(delta_seconds, clip.duration);
-                            }
-                        }
-                    }
-
-                    weight *= active_animation.weight;
-                } else if let Some(&blend_weight) = blend_weights.get(&node_index) {
-                    weight *= blend_weight;
-                }
-
-                // Write in the computed weight and mask for this node.
-                if let Some(active_animation) = active_animations.get_mut(&node_index) {
-                    active_animation.computed_weight = weight;
-                    active_animation.computed_mask = mask;
-                }
-
-                // Push children.
-                evaluator.dfs_stack.extend(
-                    animation_graph
-                        .graph
-                        .neighbors_directed(node_index, Direction::Outgoing),
-                );
-            }
-        });
-}
-
-struct AnimationTriggersIter<'a, 'b> {
+struct TriggeredEventsIter<'a, 'b> {
     triggers: Option<core::slice::Iter<'a, AnimationEventKey>>,
     active_animation: &'b ActiveAnimation,
 }
 
-impl<'a, 'b> AnimationTriggersIter<'a, 'b> {
+impl<'a, 'b> TriggeredEventsIter<'a, 'b> {
     fn new(
         target_id: Option<AnimationTargetId>,
         clip: &'a AnimationClip,
@@ -1002,7 +925,7 @@ impl<'a, 'b> AnimationTriggersIter<'a, 'b> {
     }
 }
 
-impl<'a, 'b> Iterator for AnimationTriggersIter<'a, 'b> {
+impl<'a, 'b> Iterator for TriggeredEventsIter<'a, 'b> {
     type Item = &'a AnimationEventKey;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -1018,27 +941,35 @@ impl<'a, 'b> Iterator for AnimationTriggersIter<'a, 'b> {
             ) {
                 // forward, trigger if `last_seek_time < trigger_time <= seek_time`
                 (false, false) => {
-                    self.active_animation.last_seek_time.map(|t| trigger.time > t).unwrap_or(true)
-                    // Some(trigger.time) >= self.active_animation.last_seek_time
+                    self.active_animation
+                        .last_seek_time
+                        .map(|t| trigger.time > t)
+                        .unwrap_or(true)
                         && trigger.time <= self.active_animation.seek_time
                 }
                 // forward, it looped this tick and we have to keep wrapping in mind
                 (false, true) => {
-                    self.active_animation.last_seek_time.map(|t| trigger.time > t).unwrap_or(true)
-                    // Some(trigger.time) >= self.active_animation.last_seek_time
+                    self.active_animation
+                        .last_seek_time
+                        .map(|t| trigger.time > t)
+                        .unwrap_or(true)
                         || trigger.time <= self.active_animation.seek_time
                 }
                 // reverse, trigger if `seek_time <= trigger_time < last_seek_time`
                 (true, false) => {
-                    self.active_animation.last_seek_time.map(|t| trigger.time <= t).unwrap_or(false)
-                    // Some(trigger.time) <= self.active_animation.last_seek_time
-                        && trigger.time > self.active_animation.seek_time
+                    self.active_animation
+                        .last_seek_time
+                        .map(|t| trigger.time < t)
+                        .unwrap_or(true)
+                        && trigger.time >= self.active_animation.seek_time
                 }
                 // reverse, looped this tick
                 (true, true) => {
-                    self.active_animation.last_seek_time.map(|t| trigger.time <= t).unwrap_or(false)
-                    // Some(trigger.time) <= self.active_animation.last_seek_time
-                        || trigger.time > self.active_animation.seek_time
+                    self.active_animation
+                        .last_seek_time
+                        .map(|t| trigger.time < t)
+                        .unwrap_or(true)
+                        || trigger.time >= self.active_animation.seek_time
                 }
             } {
                 return Some(trigger);
@@ -1069,7 +1000,7 @@ fn trigger_animation_events(
                 continue;
             };
 
-            for trigger in AnimationTriggersIter::new(target_id, clip, active_animation) {
+            for trigger in TriggeredEventsIter::new(target_id, clip, active_animation) {
                 commands.queue(trigger_animation_event(
                     player_entity,
                     target_entity,
@@ -1110,6 +1041,88 @@ fn trigger_animation_events(
     }
 }
 
+/// A system that advances the time for all playing animations.
+pub fn advance_animations(
+    time: Res<Time>,
+    animation_clips: Res<Assets<AnimationClip>>,
+    animation_graphs: Res<Assets<AnimationGraph>>,
+    mut players: Query<(&mut AnimationPlayer, &Handle<AnimationGraph>)>,
+    animation_graph_evaluator: Local<ThreadLocal<RefCell<AnimationGraphEvaluator>>>,
+) {
+    let delta_seconds = time.delta_seconds();
+    players
+        .par_iter_mut()
+        .for_each(|(mut player, graph_handle)| {
+            let Some(animation_graph) = animation_graphs.get(graph_handle) else {
+                return;
+            };
+
+            // Tick animations, and schedule them.
+            //
+            // We use a thread-local here so we can reuse allocations across
+            // frames.
+            let mut evaluator = animation_graph_evaluator.get_or_default().borrow_mut();
+
+            let AnimationPlayer {
+                ref mut active_animations,
+                ref blend_weights,
+                ..
+            } = *player;
+
+            // Reset our state.
+            evaluator.reset(animation_graph.root, animation_graph.graph.node_count());
+
+            while let Some(node_index) = evaluator.dfs_stack.pop() {
+                // Skip if we've already visited this node.
+                if evaluator.dfs_visited.put(node_index.index()) {
+                    continue;
+                }
+
+                let node = &animation_graph[node_index];
+
+                // Calculate weight and mask from the graph.
+                let (mut weight, mut mask) = (node.weight, node.mask);
+                for parent_index in animation_graph
+                    .graph
+                    .neighbors_directed(node_index, Direction::Incoming)
+                {
+                    let evaluated_parent = &evaluator.nodes[parent_index.index()];
+                    weight *= evaluated_parent.weight;
+                    mask |= evaluated_parent.mask;
+                }
+                evaluator.nodes[node_index.index()] = EvaluatedAnimationGraphNode { weight, mask };
+
+                if let Some(active_animation) = active_animations.get_mut(&node_index) {
+                    // Tick the animation if necessary.
+                    if !active_animation.paused {
+                        if let Some(ref clip_handle) = node.clip {
+                            if let Some(clip) = animation_clips.get(clip_handle) {
+                                active_animation.update(delta_seconds, clip.duration);
+                            }
+                        }
+                    }
+
+                    weight *= active_animation.weight;
+                } else if let Some(&blend_weight) = blend_weights.get(&node_index) {
+                    weight *= blend_weight;
+                }
+
+                // Write in the computed weight and mask for this node.
+                if let Some(active_animation) = active_animations.get_mut(&node_index) {
+                    active_animation.computed_weight = weight;
+                    active_animation.computed_mask = mask;
+                }
+
+                // Push children.
+                evaluator.dfs_stack.extend(
+                    animation_graph
+                        .graph
+                        .neighbors_directed(node_index, Direction::Outgoing),
+                );
+            }
+        });
+}
+
 /// A type alias for [`EntityMutExcept`] as used in animation.
 pub type AnimationEntityMut<'w> = EntityMutExcept<
     'w,
@@ -1353,7 +1366,7 @@ mod tests {
         assert!(!active_animation.just_completed);
         assert_eq!(
             vec![0.0],
-            AnimationTriggersIter::new(None, &clip, &active_animation)
+            TriggeredEventsIter::new(None, &clip, &active_animation)
                 .map(|t| t.time)
                 .collect::<Vec<f32>>()
         );
@@ -1362,7 +1375,7 @@ mod tests {
         assert_eq!(Some(0.0), active_animation.last_seek_time);
         assert_eq!(0.1, active_animation.seek_time);
         assert!(!active_animation.just_completed);
-        assert!(AnimationTriggersIter::new(None, &clip, &active_animation)
+        assert!(TriggeredEventsIter::new(None, &clip, &active_animation)
             .next()
             .is_none());
 
@@ -1372,7 +1385,7 @@ mod tests {
         assert!(active_animation.just_completed);
         assert_eq!(
             vec![0.2],
-            AnimationTriggersIter::new(None, &clip, &active_animation)
+            TriggeredEventsIter::new(None, &clip, &active_animation)
                 .map(|t| t.time)
                 .collect::<Vec<f32>>()
         );
@@ -1383,7 +1396,7 @@ mod tests {
         assert!(!active_animation.just_completed);
         assert_eq!(
             Vec::<f32>::new(),
-            AnimationTriggersIter::new(None, &clip, &active_animation)
+            TriggeredEventsIter::new(None, &clip, &active_animation)
                 .map(|t| t.time)
                 .collect::<Vec<f32>>()
         );
@@ -1406,7 +1419,7 @@ mod tests {
         assert!(!active_animation.just_completed);
         assert_eq!(
             vec![0.0],
-            AnimationTriggersIter::new(None, &clip, &active_animation)
+            TriggeredEventsIter::new(None, &clip, &active_animation)
                 .map(|t| t.time)
                 .collect::<Vec<f32>>()
         );
@@ -1417,7 +1430,7 @@ mod tests {
         assert!(!active_animation.just_completed);
         assert_eq!(
             Vec::<f32>::new(),
-            AnimationTriggersIter::new(None, &clip, &active_animation)
+            TriggeredEventsIter::new(None, &clip, &active_animation)
                 .map(|t| t.time)
                 .collect::<Vec<f32>>()
         );
@@ -1427,7 +1440,7 @@ mod tests {
         assert_eq!(0.2, active_animation.seek_time);
         assert_eq!(
             vec![0.2],
-            AnimationTriggersIter::new(None, &clip, &active_animation)
+            TriggeredEventsIter::new(None, &clip, &active_animation)
                 .map(|t| t.time)
                 .collect::<Vec<f32>>()
         );
@@ -1438,7 +1451,7 @@ mod tests {
         assert!(active_animation.just_completed);
         assert_eq!(
             vec![0.0, 0.3],
-            AnimationTriggersIter::new(None, &clip, &active_animation)
+            TriggeredEventsIter::new(None, &clip, &active_animation)
                 .map(|t| t.time)
                 .collect::<Vec<f32>>()
         );
@@ -1449,7 +1462,31 @@ mod tests {
         assert!(!active_animation.just_completed);
         assert_eq!(
             Vec::<f32>::new(),
-            AnimationTriggersIter::new(None, &clip, &active_animation)
+            TriggeredEventsIter::new(None, &clip, &active_animation)
+                .map(|t| t.time)
+                .collect::<Vec<f32>>()
+        );
+
+        active_animation.speed = -1.0;
+        active_animation.update(0.1, clip.duration);
+        assert_eq!(Some(0.1), active_animation.last_seek_time);
+        assert_eq!(0.0, active_animation.seek_time);
+        assert!(!active_animation.just_completed);
+        assert_eq!(
+            vec![0.0],
+            TriggeredEventsIter::new(None, &clip, &active_animation)
+                .map(|t| t.time)
+                .collect::<Vec<f32>>()
+        );
+
+        active_animation.update(0.1, clip.duration);
+        assert_eq!(Some(0.0), active_animation.last_seek_time);
+        // float precision becomes an issue when wrapping around backwards for some reason
+        assert!(active_animation.seek_time > 0.2 && active_animation.seek_time < 0.201);
+        assert!(active_animation.just_completed);
+        assert_eq!(
+            vec![0.3],
+            TriggeredEventsIter::new(None, &clip, &active_animation)
                 .map(|t| t.time)
                 .collect::<Vec<f32>>()
         );

From dfd422fc845fb0d7a38d96e639a86daf1af9ff3f Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Wed, 2 Oct 2024 16:21:52 +0200
Subject: [PATCH 52/89] fix iterator

---
 crates/bevy_animation/src/lib.rs | 128 ++++++++++++++++++++-----------
 1 file changed, 83 insertions(+), 45 deletions(-)

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index d8b353e895218..cd2e78c54d327 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -24,7 +24,7 @@ use core::{
     cell::RefCell,
     fmt::Debug,
     hash::{Hash, Hasher},
-    iter,
+    iter, slice,
 };
 
 use bevy_app::{App, Plugin, PostUpdate};
@@ -907,9 +907,16 @@ impl AnimationPlayer {
     }
 }
 
-struct TriggeredEventsIter<'a, 'b> {
-    triggers: Option<core::slice::Iter<'a, AnimationEventKey>>,
-    active_animation: &'b ActiveAnimation,
+enum TriggeredEventsIter<'a, 'b> {
+    Missing,
+    Forward {
+        events: slice::Iter<'a, AnimationEventKey>,
+        active_animation: &'b ActiveAnimation,
+    },
+    Reverse {
+        events: iter::Rev<slice::Iter<'a, AnimationEventKey>>,
+        active_animation: &'b ActiveAnimation,
+    },
 }
 
 impl<'a, 'b> TriggeredEventsIter<'a, 'b> {
@@ -918,9 +925,18 @@ impl<'a, 'b> TriggeredEventsIter<'a, 'b> {
         clip: &'a AnimationClip,
         active_animation: &'b ActiveAnimation,
     ) -> Self {
-        Self {
-            triggers: clip.events.get(&target_id).map(|v| v.iter()),
-            active_animation,
+        let Some(events) = clip.events.get(&target_id) else {
+            return Self::Missing;
+        };
+        match active_animation.is_playback_reversed() {
+            false => Self::Forward {
+                events: events.iter(),
+                active_animation,
+            },
+            true => Self::Reverse {
+                events: events.iter().rev(),
+                active_animation,
+            },
         }
     }
 }
@@ -929,50 +945,72 @@ impl<'a, 'b> Iterator for TriggeredEventsIter<'a, 'b> {
     type Item = &'a AnimationEventKey;
 
     fn next(&mut self) -> Option<Self::Item> {
+        let active_animation = match &*self {
+            TriggeredEventsIter::Missing => return None,
+            TriggeredEventsIter::Forward {
+                active_animation, ..
+            }
+            | TriggeredEventsIter::Reverse {
+                active_animation, ..
+            } => *active_animation,
+        };
+
         // if the animation is finished (unless it was this tick), return early
-        if !self.active_animation.just_completed && self.active_animation.is_finished() {
+        if !active_animation.just_completed && active_animation.is_finished() {
             return None;
         }
+
         loop {
-            let trigger = self.triggers.as_mut()?.next()?;
-            if match (
-                self.active_animation.is_playback_reversed(),
-                self.active_animation.just_completed && !self.active_animation.is_finished(),
-            ) {
-                // forward, trigger if `last_seek_time < trigger_time <= seek_time`
-                (false, false) => {
-                    self.active_animation
-                        .last_seek_time
-                        .map(|t| trigger.time > t)
-                        .unwrap_or(true)
-                        && trigger.time <= self.active_animation.seek_time
-                }
-                // forward, it looped this tick and we have to keep wrapping in mind
-                (false, true) => {
-                    self.active_animation
-                        .last_seek_time
-                        .map(|t| trigger.time > t)
-                        .unwrap_or(true)
-                        || trigger.time <= self.active_animation.seek_time
-                }
-                // reverse, trigger if `seek_time <= trigger_time < last_seek_time`
-                (true, false) => {
-                    self.active_animation
-                        .last_seek_time
-                        .map(|t| trigger.time < t)
-                        .unwrap_or(true)
-                        && trigger.time >= self.active_animation.seek_time
+            match self {
+                Self::Forward { events, .. } => {
+                    let event = events.next()?;
+                    if match active_animation.just_completed && !active_animation.is_finished() {
+                        // trigger any events that are `<= seek_time` and `> last_seek_time`
+                        false => {
+                            event.time <= active_animation.seek_time
+                                && active_animation
+                                    .last_seek_time
+                                    .map(|last_seek_time| event.time > last_seek_time)
+                                    .unwrap_or(true)
+                        }
+                        // the animation looped this tick and we have trigger events that may be `> seek_time`,
+                        // assuming they are still `< last_seek_time`
+                        true => {
+                            event.time <= active_animation.seek_time
+                                || active_animation
+                                    .last_seek_time
+                                    .map(|last_seek_time| event.time > last_seek_time)
+                                    .unwrap_or(true)
+                        }
+                    } {
+                        return Some(event);
+                    }
                 }
-                // reverse, looped this tick
-                (true, true) => {
-                    self.active_animation
-                        .last_seek_time
-                        .map(|t| trigger.time < t)
-                        .unwrap_or(true)
-                        || trigger.time >= self.active_animation.seek_time
+                Self::Reverse { events, .. } => {
+                    let event = events.next()?;
+                    if match active_animation.just_completed && !active_animation.is_finished() {
+                        // trigger any events that are `>= seek_time` and `< last_seek_time`
+                        false => {
+                            event.time >= active_animation.seek_time
+                                && active_animation
+                                    .last_seek_time
+                                    .map(|t| event.time < t)
+                                    .unwrap_or(true)
+                        }
+                        // the animation looped this tick and we have trigger events that may be `< seek_time`,
+                        // assuming they are still `> last_seek_time`
+                        true => {
+                            event.time >= active_animation.seek_time
+                                || active_animation
+                                    .last_seek_time
+                                    .map(|t| event.time < t)
+                                    .unwrap_or(true)
+                        }
+                    } {
+                        return Some(event);
+                    }
                 }
-            } {
-                return Some(trigger);
+                Self::Missing => unreachable!(),
             }
         }
     }

From 1c41b982957232caa57202ce514c3257159a7bfc Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Wed, 2 Oct 2024 16:32:18 +0200
Subject: [PATCH 53/89] Update animation_events.rs

---
 examples/animation/animation_events.rs | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/examples/animation/animation_events.rs b/examples/animation/animation_events.rs
index 11110f668f36f..8002743d7a56d 100644
--- a/examples/animation/animation_events.rs
+++ b/examples/animation/animation_events.rs
@@ -66,7 +66,13 @@ fn setup(
     mut graphs: ResMut<Assets<AnimationGraph>>,
 ) {
     // Camera
-    commands.spawn(Camera2dBundle::default());
+    commands.spawn(Camera2dBundle {
+        camera: Camera {
+            clear_color: ClearColorConfig::None,
+            ..Default::default()
+        },
+        ..Default::default()
+    });
 
     // A text entity that will have a message printed to it
     let message = commands
@@ -74,7 +80,7 @@ fn setup(
             text: Text::from_section(
                 "",
                 TextStyle {
-                    font_size: 71.0,
+                    font_size: 119.0,
                     color: Color::NONE,
                     ..Default::default()
                 },
@@ -102,8 +108,7 @@ fn setup(
     animation.set_duration(2.0);
 
     // Add events at the specified time
-    // If `time` is `0.0` it will trigger twice on the first tick for some reason
-    animation.add_event(0.001, Say::Hello(message));
+    animation.add_event(0.0, Say::Hello(message));
     animation.add_event(1.0, Say::Bye(message));
 
     let (graph, animation_index) = AnimationGraph::from_clip(animations.add(animation));

From 5decc0eca819866fe898e488f6779930e97d8ecb Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Wed, 2 Oct 2024 19:42:42 +0200
Subject: [PATCH 54/89] remove `player_entity` from `AnimationEvent`

---
 crates/bevy_animation/src/animation_event.rs |  7 ++-
 crates/bevy_animation/src/lib.rs             | 48 +++++++++-----------
 examples/animation/animation_events.rs       |  2 +-
 examples/animation/bunny_detective.rs        |  6 +--
 4 files changed, 29 insertions(+), 34 deletions(-)

diff --git a/crates/bevy_animation/src/animation_event.rs b/crates/bevy_animation/src/animation_event.rs
index b41435c183a62..d1feb1bdf5362 100644
--- a/crates/bevy_animation/src/animation_event.rs
+++ b/crates/bevy_animation/src/animation_event.rs
@@ -10,13 +10,12 @@ use bevy_reflect::{
 };
 
 pub(crate) fn trigger_animation_event(
-    player_entity: Entity,
-    target_entity: Entity,
+    entity: Entity,
     time: f32,
     event: Box<dyn AnimationEvent>,
 ) -> impl Command {
     move |world: &mut World| {
-        event.trigger(player_entity, time, target_entity, world);
+        event.trigger(time, entity, world);
     }
 }
 
@@ -25,7 +24,7 @@ pub(crate) fn trigger_animation_event(
 #[reflect_trait]
 pub trait AnimationEvent: Reflect + Send + Sync {
     /// Trigger the event, targeting `entity`.
-    fn trigger(&self, player: Entity, time: f32, target: Entity, world: &mut World);
+    fn trigger(&self, time: f32, entity: Entity, world: &mut World);
 
     /// Clone this value into a new `Box<dyn AnimationEvent>`
     fn clone_value(&self) -> Box<dyn AnimationEvent>;
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index cd2e78c54d327..a9ebb62a18eac 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -1024,30 +1024,26 @@ fn trigger_animation_events(
     players: Query<(Entity, &AnimationPlayer, &Handle<AnimationGraph>)>,
     targets: Query<(Entity, &AnimationTarget)>,
 ) {
-    let mut trigger_events_loop = |target_id,
-                                   player_entity,
-                                   target_entity,
-                                   player: &AnimationPlayer,
-                                   graph: &AnimationGraph| {
-        for (index, active_animation) in player.active_animations.iter() {
-            let Some(clip) = graph
-                .get(*index)
-                .and_then(|node| node.clip.as_ref())
-                .and_then(|id| clips.get(id))
-            else {
-                continue;
-            };
+    let mut trigger_events_loop =
+        |target_id, entity, player: &AnimationPlayer, graph: &AnimationGraph| {
+            for (index, active_animation) in player.active_animations.iter() {
+                let Some(clip) = graph
+                    .get(*index)
+                    .and_then(|node| node.clip.as_ref())
+                    .and_then(|id| clips.get(id))
+                else {
+                    continue;
+                };
 
-            for trigger in TriggeredEventsIter::new(target_id, clip, active_animation) {
-                commands.queue(trigger_animation_event(
-                    player_entity,
-                    target_entity,
-                    trigger.time,
-                    trigger.event.clone().0,
-                ));
+                for trigger in TriggeredEventsIter::new(target_id, clip, active_animation) {
+                    commands.queue(trigger_animation_event(
+                        entity,
+                        trigger.time,
+                        trigger.event.clone().0,
+                    ));
+                }
             }
-        }
-    };
+        };
 
     // untargeted events
     for (entity, player, graph_id) in &players {
@@ -1056,11 +1052,11 @@ fn trigger_animation_events(
             return;
         };
 
-        trigger_events_loop(None, entity, entity, player, graph);
+        trigger_events_loop(None, entity, player, graph);
     }
 
     // targeted events
-    for (target_entity, target) in &targets {
+    for (entity, target) in &targets {
         let &AnimationTarget {
             id: target_id,
             player: player_entity,
@@ -1075,7 +1071,7 @@ fn trigger_animation_events(
             return;
         };
 
-        trigger_events_loop(Some(target_id), player_entity, target_entity, player, graph);
+        trigger_events_loop(Some(target_id), entity, player, graph);
     }
 }
 
@@ -1382,7 +1378,7 @@ mod tests {
     struct A;
 
     impl AnimationEvent for A {
-        fn trigger(&self, _: Entity, _: f32, target: Entity, world: &mut World) {
+        fn trigger(&self, _time: f32, target: Entity, world: &mut World) {
             world.entity_mut(target).trigger(self.clone());
         }
 
diff --git a/examples/animation/animation_events.rs b/examples/animation/animation_events.rs
index 8002743d7a56d..93c9357db512b 100644
--- a/examples/animation/animation_events.rs
+++ b/examples/animation/animation_events.rs
@@ -51,7 +51,7 @@ impl Say {
 }
 
 impl AnimationEvent for Say {
-    fn trigger(&self, _player: Entity, _time: f32, target: Entity, world: &mut World) {
+    fn trigger(&self, _time: f32, target: Entity, world: &mut World) {
         world.entity_mut(target).trigger(self.clone());
     }
 
diff --git a/examples/animation/bunny_detective.rs b/examples/animation/bunny_detective.rs
index 16ad3ea921b52..25159c5a085de 100644
--- a/examples/animation/bunny_detective.rs
+++ b/examples/animation/bunny_detective.rs
@@ -104,7 +104,7 @@ impl FromWorld for ParticleAssets {
 struct OnJumped;
 
 impl AnimationEvent for OnJumped {
-    fn trigger(&self, _player: Entity, _time: f32, target: Entity, world: &mut World) {
+    fn trigger(&self, _time: f32, target: Entity, world: &mut World) {
         world.entity_mut(target).trigger(Self);
     }
 
@@ -159,7 +159,7 @@ impl OnJumped {
 struct OnLanded;
 
 impl AnimationEvent for OnLanded {
-    fn trigger(&self, _player: Entity, _time: f32, target: Entity, world: &mut World) {
+    fn trigger(&self, _time: f32, target: Entity, world: &mut World) {
         world.entity_mut(target).trigger(Self);
     }
 
@@ -210,7 +210,7 @@ enum OnStep {
 }
 
 impl AnimationEvent for OnStep {
-    fn trigger(&self, _player: Entity, _time: f32, target: Entity, world: &mut World) {
+    fn trigger(&self, _time: f32, target: Entity, world: &mut World) {
         world.entity_mut(target).trigger(self.clone());
     }
 

From fd8953adcf0242aafc333bc50b6e2b50ac3ad8ce Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Thu, 3 Oct 2024 01:31:26 +0200
Subject: [PATCH 55/89] fix trigger order

---
 crates/bevy_animation/src/lib.rs | 172 ++++++++++++++++++-------------
 1 file changed, 98 insertions(+), 74 deletions(-)

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index a9ebb62a18eac..e721141f0d3aa 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -907,18 +907,25 @@ impl AnimationPlayer {
     }
 }
 
-enum TriggeredEventsIter<'a, 'b> {
-    Missing,
-    Forward {
-        events: slice::Iter<'a, AnimationEventKey>,
-        active_animation: &'b ActiveAnimation,
+enum TriggeredEventsIterInner<'a> {
+    None,
+    Forward(slice::Iter<'a, AnimationEventKey>),
+    Reverse(iter::Rev<slice::Iter<'a, AnimationEventKey>>),
+    ForwardLooping {
+        a: slice::Iter<'a, AnimationEventKey>,
+        b: slice::Iter<'a, AnimationEventKey>,
     },
-    Reverse {
-        events: iter::Rev<slice::Iter<'a, AnimationEventKey>>,
-        active_animation: &'b ActiveAnimation,
+    ReverseLooping {
+        a: iter::Rev<slice::Iter<'a, AnimationEventKey>>,
+        b: iter::Rev<slice::Iter<'a, AnimationEventKey>>,
     },
 }
 
+struct TriggeredEventsIter<'a, 'b> {
+    inner: TriggeredEventsIterInner<'a>,
+    active_animation: &'b ActiveAnimation,
+}
+
 impl<'a, 'b> TriggeredEventsIter<'a, 'b> {
     fn new(
         target_id: Option<AnimationTargetId>,
@@ -926,17 +933,29 @@ impl<'a, 'b> TriggeredEventsIter<'a, 'b> {
         active_animation: &'b ActiveAnimation,
     ) -> Self {
         let Some(events) = clip.events.get(&target_id) else {
-            return Self::Missing;
-        };
-        match active_animation.is_playback_reversed() {
-            false => Self::Forward {
-                events: events.iter(),
+            return Self {
+                inner: TriggeredEventsIterInner::None,
                 active_animation,
+            };
+        };
+        let reverse = active_animation.is_playback_reversed();
+        // the animation completed this tick, while still playing
+        let looping = active_animation.just_completed && !active_animation.is_finished();
+        let inner = match (reverse, looping) {
+            (false, false) => TriggeredEventsIterInner::Forward(events.iter()),
+            (true, false) => TriggeredEventsIterInner::Reverse(events.iter().rev()),
+            (false, true) => TriggeredEventsIterInner::ForwardLooping {
+                a: events.iter(),
+                b: events.iter(),
             },
-            true => Self::Reverse {
-                events: events.iter().rev(),
-                active_animation,
+            (true, true) => TriggeredEventsIterInner::ReverseLooping {
+                a: events.iter().rev(),
+                b: events.iter().rev(),
             },
+        };
+        Self {
+            inner,
+            active_animation,
         }
     }
 }
@@ -945,72 +964,77 @@ impl<'a, 'b> Iterator for TriggeredEventsIter<'a, 'b> {
     type Item = &'a AnimationEventKey;
 
     fn next(&mut self) -> Option<Self::Item> {
-        let active_animation = match &*self {
-            TriggeredEventsIter::Missing => return None,
-            TriggeredEventsIter::Forward {
-                active_animation, ..
-            }
-            | TriggeredEventsIter::Reverse {
-                active_animation, ..
-            } => *active_animation,
-        };
-
-        // if the animation is finished (unless it was this tick), return early
-        if !active_animation.just_completed && active_animation.is_finished() {
+        // if the animation was finished earlier, return early
+        if !self.active_animation.just_completed && self.active_animation.is_finished() {
             return None;
         }
-
+        let &ActiveAnimation {
+            last_seek_time,
+            seek_time,
+            ..
+        } = self.active_animation;
+        // loop untill we find a triggered event or return `None`
         loop {
-            match self {
-                Self::Forward { events, .. } => {
-                    let event = events.next()?;
-                    if match active_animation.just_completed && !active_animation.is_finished() {
-                        // trigger any events that are `<= seek_time` and `> last_seek_time`
-                        false => {
-                            event.time <= active_animation.seek_time
-                                && active_animation
-                                    .last_seek_time
-                                    .map(|last_seek_time| event.time > last_seek_time)
-                                    .unwrap_or(true)
-                        }
-                        // the animation looped this tick and we have trigger events that may be `> seek_time`,
-                        // assuming they are still `< last_seek_time`
-                        true => {
-                            event.time <= active_animation.seek_time
-                                || active_animation
-                                    .last_seek_time
-                                    .map(|last_seek_time| event.time > last_seek_time)
-                                    .unwrap_or(true)
-                        }
-                    } {
+            match &mut self.inner {
+                TriggeredEventsIterInner::None => return None,
+                // the event should trigger if `event.time >= seek_time`
+                // we also have to check if `event.time < last_seek_time`
+                // to make sure the event is only triggered once
+                TriggeredEventsIterInner::Forward(iter) => {
+                    let event = iter.next()?;
+                    if event.time <= seek_time
+                        && last_seek_time.map(|lst| event.time > lst).unwrap_or(true)
+                    {
                         return Some(event);
                     }
                 }
-                Self::Reverse { events, .. } => {
-                    let event = events.next()?;
-                    if match active_animation.just_completed && !active_animation.is_finished() {
-                        // trigger any events that are `>= seek_time` and `< last_seek_time`
-                        false => {
-                            event.time >= active_animation.seek_time
-                                && active_animation
-                                    .last_seek_time
-                                    .map(|t| event.time < t)
-                                    .unwrap_or(true)
-                        }
-                        // the animation looped this tick and we have trigger events that may be `< seek_time`,
-                        // assuming they are still `> last_seek_time`
-                        true => {
-                            event.time >= active_animation.seek_time
-                                || active_animation
-                                    .last_seek_time
-                                    .map(|t| event.time < t)
-                                    .unwrap_or(true)
-                        }
-                    } {
+                TriggeredEventsIterInner::Reverse(rev) => {
+                    let event = rev.next()?;
+                    if event.time >= seek_time
+                        && last_seek_time.map(|lst| event.time < lst).unwrap_or(true)
+                    {
                         return Some(event);
                     }
                 }
-                Self::Missing => unreachable!(),
+                // when looping, we first trigger events where `event.time > last_seek_time`
+                // untill the iterator is exhausted
+                // then we use the other iterator to trigger events where `event.time <= seek_time`
+                // this is to make sure all events are triggered in the correct order that they occured
+                //
+                // Note: this is unlikely to work well if the animation somehow
+                // finished multiple times in one tick, should be rare enough though
+                TriggeredEventsIterInner::ForwardLooping { a, b } => {
+                    let event = match a.next() {
+                        Some(event)
+                            if last_seek_time.map(|lst| event.time > lst).unwrap_or(true) =>
+                        {
+                            event
+                        }
+                        None => match b.next() {
+                            Some(event) if event.time <= seek_time => event,
+                            None => return None,
+                            _ => continue,
+                        },
+                        _ => continue,
+                    };
+                    return Some(event);
+                }
+                TriggeredEventsIterInner::ReverseLooping { a, b } => {
+                    let event = match a.next() {
+                        Some(event)
+                            if last_seek_time.map(|lst| event.time < lst).unwrap_or(true) =>
+                        {
+                            event
+                        }
+                        None => match b.next() {
+                            Some(event) if event.time >= seek_time => event,
+                            None => return None,
+                            _ => continue,
+                        },
+                        _ => continue,
+                    };
+                    return Some(event);
+                }
             }
         }
     }
@@ -1484,7 +1508,7 @@ mod tests {
         assert_eq!(0.0, active_animation.seek_time);
         assert!(active_animation.just_completed);
         assert_eq!(
-            vec![0.0, 0.3],
+            vec![0.3, 0.0,],
             TriggeredEventsIter::new(None, &clip, &active_animation)
                 .map(|t| t.time)
                 .collect::<Vec<f32>>()

From 932ad5b5de8ddabdbabd330dd290aed8d3299c80 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Thu, 3 Oct 2024 01:35:53 +0200
Subject: [PATCH 56/89] typos

---
 crates/bevy_animation/src/lib.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index e721141f0d3aa..ad43eafd7972e 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -973,7 +973,7 @@ impl<'a, 'b> Iterator for TriggeredEventsIter<'a, 'b> {
             seek_time,
             ..
         } = self.active_animation;
-        // loop untill we find a triggered event or return `None`
+        // loop until we find a triggered event or return `None`
         loop {
             match &mut self.inner {
                 TriggeredEventsIterInner::None => return None,
@@ -997,9 +997,9 @@ impl<'a, 'b> Iterator for TriggeredEventsIter<'a, 'b> {
                     }
                 }
                 // when looping, we first trigger events where `event.time > last_seek_time`
-                // untill the iterator is exhausted
+                // until the iterator is exhausted
                 // then we use the other iterator to trigger events where `event.time <= seek_time`
-                // this is to make sure all events are triggered in the correct order that they occured
+                // this is to make sure all events are triggered in the correct order that they occurred
                 //
                 // Note: this is unlikely to work well if the animation somehow
                 // finished multiple times in one tick, should be rare enough though

From 17fb536d3caebfd108b65588d1d8232e4609095e Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Thu, 3 Oct 2024 19:20:15 +0200
Subject: [PATCH 57/89] refactor

---
 crates/bevy_animation/src/lib.rs | 558 +++++++++++++++----------------
 1 file changed, 264 insertions(+), 294 deletions(-)

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index ad43eafd7972e..1ceebc69156b8 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -586,13 +586,12 @@ impl ActiveAnimation {
     #[inline]
     fn update(&mut self, delta: f32, clip_duration: f32) {
         self.just_completed = false;
+        self.last_seek_time = Some(self.seek_time);
 
         if self.is_finished() {
             return;
         }
 
-        self.last_seek_time = Some(self.seek_time);
-
         self.elapsed += delta;
         self.seek_time += delta * self.speed;
 
@@ -907,168 +906,13 @@ impl AnimationPlayer {
     }
 }
 
-enum TriggeredEventsIterInner<'a> {
-    None,
-    Forward(slice::Iter<'a, AnimationEventKey>),
-    Reverse(iter::Rev<slice::Iter<'a, AnimationEventKey>>),
-    ForwardLooping {
-        a: slice::Iter<'a, AnimationEventKey>,
-        b: slice::Iter<'a, AnimationEventKey>,
-    },
-    ReverseLooping {
-        a: iter::Rev<slice::Iter<'a, AnimationEventKey>>,
-        b: iter::Rev<slice::Iter<'a, AnimationEventKey>>,
-    },
-}
-
-struct TriggeredEventsIter<'a, 'b> {
-    inner: TriggeredEventsIterInner<'a>,
-    active_animation: &'b ActiveAnimation,
-}
-
-impl<'a, 'b> TriggeredEventsIter<'a, 'b> {
-    fn new(
-        target_id: Option<AnimationTargetId>,
-        clip: &'a AnimationClip,
-        active_animation: &'b ActiveAnimation,
-    ) -> Self {
-        let Some(events) = clip.events.get(&target_id) else {
-            return Self {
-                inner: TriggeredEventsIterInner::None,
-                active_animation,
-            };
-        };
-        let reverse = active_animation.is_playback_reversed();
-        // the animation completed this tick, while still playing
-        let looping = active_animation.just_completed && !active_animation.is_finished();
-        let inner = match (reverse, looping) {
-            (false, false) => TriggeredEventsIterInner::Forward(events.iter()),
-            (true, false) => TriggeredEventsIterInner::Reverse(events.iter().rev()),
-            (false, true) => TriggeredEventsIterInner::ForwardLooping {
-                a: events.iter(),
-                b: events.iter(),
-            },
-            (true, true) => TriggeredEventsIterInner::ReverseLooping {
-                a: events.iter().rev(),
-                b: events.iter().rev(),
-            },
-        };
-        Self {
-            inner,
-            active_animation,
-        }
-    }
-}
-
-impl<'a, 'b> Iterator for TriggeredEventsIter<'a, 'b> {
-    type Item = &'a AnimationEventKey;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        // if the animation was finished earlier, return early
-        if !self.active_animation.just_completed && self.active_animation.is_finished() {
-            return None;
-        }
-        let &ActiveAnimation {
-            last_seek_time,
-            seek_time,
-            ..
-        } = self.active_animation;
-        // loop until we find a triggered event or return `None`
-        loop {
-            match &mut self.inner {
-                TriggeredEventsIterInner::None => return None,
-                // the event should trigger if `event.time >= seek_time`
-                // we also have to check if `event.time < last_seek_time`
-                // to make sure the event is only triggered once
-                TriggeredEventsIterInner::Forward(iter) => {
-                    let event = iter.next()?;
-                    if event.time <= seek_time
-                        && last_seek_time.map(|lst| event.time > lst).unwrap_or(true)
-                    {
-                        return Some(event);
-                    }
-                }
-                TriggeredEventsIterInner::Reverse(rev) => {
-                    let event = rev.next()?;
-                    if event.time >= seek_time
-                        && last_seek_time.map(|lst| event.time < lst).unwrap_or(true)
-                    {
-                        return Some(event);
-                    }
-                }
-                // when looping, we first trigger events where `event.time > last_seek_time`
-                // until the iterator is exhausted
-                // then we use the other iterator to trigger events where `event.time <= seek_time`
-                // this is to make sure all events are triggered in the correct order that they occurred
-                //
-                // Note: this is unlikely to work well if the animation somehow
-                // finished multiple times in one tick, should be rare enough though
-                TriggeredEventsIterInner::ForwardLooping { a, b } => {
-                    let event = match a.next() {
-                        Some(event)
-                            if last_seek_time.map(|lst| event.time > lst).unwrap_or(true) =>
-                        {
-                            event
-                        }
-                        None => match b.next() {
-                            Some(event) if event.time <= seek_time => event,
-                            None => return None,
-                            _ => continue,
-                        },
-                        _ => continue,
-                    };
-                    return Some(event);
-                }
-                TriggeredEventsIterInner::ReverseLooping { a, b } => {
-                    let event = match a.next() {
-                        Some(event)
-                            if last_seek_time.map(|lst| event.time < lst).unwrap_or(true) =>
-                        {
-                            event
-                        }
-                        None => match b.next() {
-                            Some(event) if event.time >= seek_time => event,
-                            None => return None,
-                            _ => continue,
-                        },
-                        _ => continue,
-                    };
-                    return Some(event);
-                }
-            }
-        }
-    }
-}
-
-/// A system that triggers animation events for the currently-playing animations.
-fn trigger_animation_events(
+/// A system that triggers untargeted animation events for the currently-playing animations.
+fn trigger_untargeted_animation_events(
     mut commands: Commands,
     clips: Res<Assets<AnimationClip>>,
     graphs: Res<Assets<AnimationGraph>>,
     players: Query<(Entity, &AnimationPlayer, &Handle<AnimationGraph>)>,
-    targets: Query<(Entity, &AnimationTarget)>,
 ) {
-    let mut trigger_events_loop =
-        |target_id, entity, player: &AnimationPlayer, graph: &AnimationGraph| {
-            for (index, active_animation) in player.active_animations.iter() {
-                let Some(clip) = graph
-                    .get(*index)
-                    .and_then(|node| node.clip.as_ref())
-                    .and_then(|id| clips.get(id))
-                else {
-                    continue;
-                };
-
-                for trigger in TriggeredEventsIter::new(target_id, clip, active_animation) {
-                    commands.queue(trigger_animation_event(
-                        entity,
-                        trigger.time,
-                        trigger.event.clone().0,
-                    ));
-                }
-            }
-        };
-
     // untargeted events
     for (entity, player, graph_id) in &players {
         // The graph might not have loaded yet. Safely bail.
@@ -1076,26 +920,23 @@ fn trigger_animation_events(
             return;
         };
 
-        trigger_events_loop(None, entity, player, graph);
-    }
-
-    // targeted events
-    for (entity, target) in &targets {
-        let &AnimationTarget {
-            id: target_id,
-            player: player_entity,
-        } = target;
-
-        let Ok((_, player, graph_handle)) = players.get(player_entity) else {
-            return;
-        };
+        for (index, active_animation) in player.active_animations.iter() {
+            let Some(clip) = graph
+                .get(*index)
+                .and_then(|node| node.clip.as_ref())
+                .and_then(|id| clips.get(id))
+            else {
+                continue;
+            };
 
-        // The graph might not have loaded yet. Safely bail.
-        let Some(graph) = graphs.get(graph_handle) else {
-            return;
-        };
+            let Some(triggered_events) = TriggeredEvents::new(None, clip, active_animation) else {
+                continue;
+            };
 
-        trigger_events_loop(Some(target_id), entity, player, graph);
+            for AnimationEventKey { time, event } in triggered_events.iter() {
+                commands.queue(trigger_animation_event(entity, *time, event.clone().0));
+            }
+        }
     }
 }
 
@@ -1195,15 +1036,21 @@ pub type AnimationEntityMut<'w> = EntityMutExcept<
 /// A system that modifies animation targets (e.g. bones in a skinned mesh)
 /// according to the currently-playing animations.
 pub fn animate_targets(
+    par_commands: ParallelCommands,
     clips: Res<Assets<AnimationClip>>,
     graphs: Res<Assets<AnimationGraph>>,
     players: Query<(&AnimationPlayer, &Handle<AnimationGraph>)>,
-    mut targets: Query<(&AnimationTarget, Option<&mut Transform>, AnimationEntityMut)>,
+    mut targets: Query<(
+        Entity,
+        &AnimationTarget,
+        Option<&mut Transform>,
+        AnimationEntityMut,
+    )>,
 ) {
     // Evaluate all animation targets in parallel.
     targets
         .par_iter_mut()
-        .for_each(|(target, mut transform, mut entity_mut)| {
+        .for_each(|(entity, target, mut transform, mut entity_mut)| {
             let &AnimationTarget {
                 id: target_id,
                 player: player_id,
@@ -1271,6 +1118,23 @@ pub fn animate_targets(
                     continue;
                 };
 
+                // Trigger all animation events that occurred this tick, if any.
+                if let Some(triggered_events) =
+                    TriggeredEvents::new(Some(target_id), clip, active_animation)
+                {
+                    if !triggered_events.is_empty() {
+                        par_commands.command_scope(move |mut commands| {
+                            for AnimationEventKey { time, event } in triggered_events.iter() {
+                                commands.queue(trigger_animation_event(
+                                    entity,
+                                    *time,
+                                    event.clone().0,
+                                ));
+                            }
+                        });
+                    }
+                }
+
                 let Some(curves) = clip.curves_for_target(target_id) else {
                     continue;
                 };
@@ -1313,9 +1177,6 @@ impl Plugin for AnimationPlugin {
             .add_systems(
                 PostUpdate,
                 (
-                    // `trigger_animation_events` has to run before `advance_animations` and `advance_transitions`
-                    // because if not, it won't trigger events that occur on the first tick of an animation.
-                    trigger_animation_events,
                     advance_transitions,
                     advance_animations,
                     // TODO: `animate_targets` can animate anything, so
@@ -1327,6 +1188,7 @@ impl Plugin for AnimationPlugin {
                     animate_targets
                         .after(bevy_render::mesh::morph::inherit_weights)
                         .ambiguous_with_all(),
+                    trigger_untargeted_animation_events,
                     expire_completed_transitions,
                 )
                     .chain()
@@ -1394,6 +1256,155 @@ impl AnimationGraphEvaluator {
     }
 }
 
+/// All the events from an [`AnimationClip`] that occurred this tick.
+#[derive(Debug, Clone)]
+struct TriggeredEvents<'a> {
+    direction: TriggeredEventsDir,
+    lower: &'a [AnimationEventKey],
+    upper: &'a [AnimationEventKey],
+}
+
+impl<'a> TriggeredEvents<'a> {
+    fn new(
+        target_id: Option<AnimationTargetId>,
+        clip: &'a AnimationClip,
+        active_animation: &ActiveAnimation,
+    ) -> Option<Self> {
+        let events = clip.events.get(&target_id)?;
+        let reverse = active_animation.is_playback_reversed();
+        let is_finished = active_animation.is_finished();
+
+        // Return eatly if the animation have finished on a previous tick.
+        if is_finished && !active_animation.just_completed {
+            return None;
+        }
+
+        // The animation completed this tick, while still playing.
+        let looping = active_animation.just_completed && !is_finished;
+        let direction = match (reverse, looping) {
+            (false, false) => TriggeredEventsDir::Forward,
+            (false, true) => TriggeredEventsDir::ForwardLooping,
+            (true, false) => TriggeredEventsDir::Reverse,
+            (true, true) => TriggeredEventsDir::ReverseLooping,
+        };
+
+        let last_time = active_animation.last_seek_time?;
+        let this_time = active_animation.seek_time;
+
+        let (lower, upper) = match direction {
+            // Return all events where last_time <= event.time < this_time.
+            TriggeredEventsDir::Forward => {
+                let start = events.partition_point(|event| event.time < last_time);
+                // The animation finished this tick, return any remaining events.
+                if is_finished {
+                    (&events[start..], &events[0..0])
+                } else {
+                    let end = events.partition_point(|event| event.time < this_time);
+                    (&events[start..end], &events[0..0])
+                }
+            }
+            // Return all events where this_time < event.time <= last_time.
+            TriggeredEventsDir::Reverse => {
+                let end = events.partition_point(|event| event.time <= last_time);
+                // The animation finished, return any remaining events.
+                if is_finished {
+                    (&events[..end], &events[0..0])
+                } else {
+                    let start = events.partition_point(|event| event.time <= this_time);
+                    (&events[start..end], &events[0..0])
+                }
+            }
+            // The animation is looping this tick and we have to return events where
+            // either last_tick <= event.time or event.time < this_tick.
+            TriggeredEventsDir::ForwardLooping => {
+                let upper_start = events.partition_point(|event| event.time < last_time); // First index where t >= last_tick
+                let lower_end = events.partition_point(|event| event.time < this_time); // First index where t >= this_tick
+
+                let upper = &events[upper_start..];
+                let lower = &events[..lower_end];
+                (upper, lower)
+            }
+            // The animation is looping this tick and we have to return events where
+            // either last_tick >= event.time or event.time > this_tick.
+            TriggeredEventsDir::ReverseLooping => {
+                let lower_end = events.partition_point(|event| event.time <= last_time); // First index where t > last_tick
+                let upper_start = events.partition_point(|event| event.time <= this_time); // First index where t > this_tick
+
+                let upper = &events[upper_start..];
+                let lower = &events[..lower_end];
+                (lower, upper)
+            }
+        };
+        Some(Self {
+            direction,
+            lower,
+            upper,
+        })
+    }
+
+    fn is_empty(&self) -> bool {
+        self.lower.is_empty() && self.upper.is_empty()
+    }
+
+    fn iter(&self) -> TriggeredEventsIter {
+        match self.direction {
+            TriggeredEventsDir::Forward => TriggeredEventsIter::Forward(self.lower.iter()),
+            TriggeredEventsDir::Reverse => TriggeredEventsIter::Reverse(self.lower.iter().rev()),
+            TriggeredEventsDir::ForwardLooping => TriggeredEventsIter::ForwardLooping {
+                upper: self.upper.iter(),
+                lower: self.lower.iter(),
+            },
+            TriggeredEventsDir::ReverseLooping => TriggeredEventsIter::ReverseLooping {
+                lower: self.lower.iter().rev(),
+                upper: self.upper.iter().rev(),
+            },
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+enum TriggeredEventsDir {
+    /// The animation is playing normally
+    Forward,
+    /// The animation is playing in reverse
+    Reverse,
+    /// The animation is looping this tick
+    ForwardLooping,
+    /// The animation playing in reverse and looping this tick
+    ReverseLooping,
+}
+
+#[derive(Debug, Clone)]
+enum TriggeredEventsIter<'a> {
+    Forward(slice::Iter<'a, AnimationEventKey>),
+    Reverse(iter::Rev<slice::Iter<'a, AnimationEventKey>>),
+    ForwardLooping {
+        upper: slice::Iter<'a, AnimationEventKey>,
+        lower: slice::Iter<'a, AnimationEventKey>,
+    },
+    ReverseLooping {
+        lower: iter::Rev<slice::Iter<'a, AnimationEventKey>>,
+        upper: iter::Rev<slice::Iter<'a, AnimationEventKey>>,
+    },
+}
+
+impl<'a> Iterator for TriggeredEventsIter<'a> {
+    type Item = &'a AnimationEventKey;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self {
+            TriggeredEventsIter::Forward(iter) => iter.next(),
+            TriggeredEventsIter::Reverse(rev) => rev.next(),
+            TriggeredEventsIter::ForwardLooping { upper, lower } => {
+                upper.next().or_else(|| lower.next())
+            }
+            TriggeredEventsIter::ReverseLooping { lower, upper } => {
+                lower.next().or_else(|| upper.next())
+            }
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -1411,6 +1422,26 @@ mod tests {
         }
     }
 
+    #[track_caller]
+    fn assert_triggered_times(
+        active_animation: &ActiveAnimation,
+        clip: &AnimationClip,
+        expected: impl Into<Vec<f32>>,
+    ) {
+        let Some(events) = TriggeredEvents::new(None, clip, active_animation) else {
+            assert_eq!(expected.into(), vec![]);
+            return;
+        };
+        let got: Vec<_> = events.iter().map(|t| t.time).collect();
+        assert_eq!(
+            expected.into(),
+            got,
+            "\n{events:#?}\nlast_time: {:?}\nthis_time:{}",
+            active_animation.last_seek_time,
+            active_animation.seek_time
+        );
+    }
+
     #[test]
     fn test_events_triggers_on_animation() {
         let mut active_animation = ActiveAnimation::default();
@@ -1419,45 +1450,27 @@ mod tests {
         clip.add_event(0.2, A);
         assert_eq!(0.2, clip.duration);
 
-        assert_eq!(None, active_animation.last_seek_time);
-        assert_eq!(0.0, active_animation.seek_time);
-        assert!(!active_animation.just_completed);
-        assert_eq!(
-            vec![0.0],
-            TriggeredEventsIter::new(None, &clip, &active_animation)
-                .map(|t| t.time)
-                .collect::<Vec<f32>>()
-        );
-
-        active_animation.update(0.1, clip.duration);
-        assert_eq!(Some(0.0), active_animation.last_seek_time);
-        assert_eq!(0.1, active_animation.seek_time);
-        assert!(!active_animation.just_completed);
-        assert!(TriggeredEventsIter::new(None, &clip, &active_animation)
-            .next()
-            .is_none());
-
-        active_animation.update(0.1, clip.duration);
-        assert_eq!(Some(0.1), active_animation.last_seek_time);
-        assert_eq!(0.2, active_animation.seek_time);
-        assert!(active_animation.just_completed);
-        assert_eq!(
-            vec![0.2],
-            TriggeredEventsIter::new(None, &clip, &active_animation)
-                .map(|t| t.time)
-                .collect::<Vec<f32>>()
-        );
+        assert_triggered_times(&active_animation, &clip, []);
+        active_animation.update(0.1, clip.duration); // 0.0 : 0.1
+        assert_triggered_times(&active_animation, &clip, [0.0]);
+        active_animation.update(0.1, clip.duration); // 0.1 : 0.2
+        assert_triggered_times(&active_animation, &clip, [0.2]);
+        active_animation.update(0.1, clip.duration); // 0.2 : 0.2
+        assert_triggered_times(&active_animation, &clip, []);
+        active_animation.update(0.1, clip.duration); // 0.2 : 0.2
+        assert_triggered_times(&active_animation, &clip, []);
 
-        active_animation.update(0.1, clip.duration);
-        assert_eq!(Some(0.1), active_animation.last_seek_time);
-        assert_eq!(0.2, active_animation.seek_time);
-        assert!(!active_animation.just_completed);
-        assert_eq!(
-            Vec::<f32>::new(),
-            TriggeredEventsIter::new(None, &clip, &active_animation)
-                .map(|t| t.time)
-                .collect::<Vec<f32>>()
-        );
+        active_animation.speed = -1.0;
+        active_animation.completions = 0;
+        assert_triggered_times(&active_animation, &clip, []);
+        active_animation.update(0.1, clip.duration); // 0.2 : 0.1
+        assert_triggered_times(&active_animation, &clip, [0.2]);
+        active_animation.update(0.1, clip.duration); // 0.1 : 0.0
+        assert_triggered_times(&active_animation, &clip, []);
+        active_animation.update(0.1, clip.duration); // 0.0 : 0.0
+        assert_triggered_times(&active_animation, &clip, [0.0]);
+        active_animation.update(0.1, clip.duration); // 0.0 : 0.0
+        assert_triggered_times(&active_animation, &clip, []);
     }
 
     #[test]
@@ -1472,81 +1485,38 @@ mod tests {
         clip.add_event(0.3, A);
         assert_eq!(0.3, clip.duration);
 
-        assert_eq!(None, active_animation.last_seek_time);
-        assert_eq!(0.0, active_animation.seek_time);
-        assert!(!active_animation.just_completed);
-        assert_eq!(
-            vec![0.0],
-            TriggeredEventsIter::new(None, &clip, &active_animation)
-                .map(|t| t.time)
-                .collect::<Vec<f32>>()
-        );
-
-        active_animation.update(0.1, clip.duration);
-        assert_eq!(Some(0.0), active_animation.last_seek_time);
-        assert_eq!(0.1, active_animation.seek_time);
-        assert!(!active_animation.just_completed);
-        assert_eq!(
-            Vec::<f32>::new(),
-            TriggeredEventsIter::new(None, &clip, &active_animation)
-                .map(|t| t.time)
-                .collect::<Vec<f32>>()
-        );
-
-        active_animation.update(0.1, clip.duration);
-        assert_eq!(Some(0.1), active_animation.last_seek_time);
-        assert_eq!(0.2, active_animation.seek_time);
-        assert_eq!(
-            vec![0.2],
-            TriggeredEventsIter::new(None, &clip, &active_animation)
-                .map(|t| t.time)
-                .collect::<Vec<f32>>()
-        );
-
-        active_animation.update(0.1, clip.duration);
-        assert_eq!(Some(0.2), active_animation.last_seek_time);
-        assert_eq!(0.0, active_animation.seek_time);
-        assert!(active_animation.just_completed);
-        assert_eq!(
-            vec![0.3, 0.0,],
-            TriggeredEventsIter::new(None, &clip, &active_animation)
-                .map(|t| t.time)
-                .collect::<Vec<f32>>()
-        );
-
-        active_animation.update(0.1, clip.duration);
-        assert_eq!(Some(0.0), active_animation.last_seek_time);
-        assert_eq!(0.1, active_animation.seek_time);
-        assert!(!active_animation.just_completed);
-        assert_eq!(
-            Vec::<f32>::new(),
-            TriggeredEventsIter::new(None, &clip, &active_animation)
-                .map(|t| t.time)
-                .collect::<Vec<f32>>()
-        );
+        assert_triggered_times(&active_animation, &clip, []);
+        active_animation.update(0.1, clip.duration); // 0.0 : 0.1
+        assert_triggered_times(&active_animation, &clip, [0.0]);
+        active_animation.update(0.1, clip.duration); // 0.1 : 0.2
+        assert_triggered_times(&active_animation, &clip, []);
+        active_animation.update(0.1, clip.duration); // 0.2 : 0.3
+        assert_triggered_times(&active_animation, &clip, [0.2, 0.3]);
+        active_animation.update(0.1, clip.duration); // 0.3 : 0.1
+        assert_triggered_times(&active_animation, &clip, [0.0]);
+        active_animation.update(0.1, clip.duration); // 0.1 : 0.2
+        assert_triggered_times(&active_animation, &clip, []);
 
         active_animation.speed = -1.0;
-        active_animation.update(0.1, clip.duration);
-        assert_eq!(Some(0.1), active_animation.last_seek_time);
-        assert_eq!(0.0, active_animation.seek_time);
-        assert!(!active_animation.just_completed);
-        assert_eq!(
-            vec![0.0],
-            TriggeredEventsIter::new(None, &clip, &active_animation)
-                .map(|t| t.time)
-                .collect::<Vec<f32>>()
-        );
-
-        active_animation.update(0.1, clip.duration);
-        assert_eq!(Some(0.0), active_animation.last_seek_time);
-        // float precision becomes an issue when wrapping around backwards for some reason
-        assert!(active_animation.seek_time > 0.2 && active_animation.seek_time < 0.201);
-        assert!(active_animation.just_completed);
-        assert_eq!(
-            vec![0.3],
-            TriggeredEventsIter::new(None, &clip, &active_animation)
-                .map(|t| t.time)
-                .collect::<Vec<f32>>()
-        );
+        active_animation.update(0.1, clip.duration); // 0.2 : 0.1
+        assert_triggered_times(&active_animation, &clip, [0.2]);
+        active_animation.update(0.1, clip.duration); // 0.1 : 0.0
+        assert_triggered_times(&active_animation, &clip, []);
+        active_animation.update(0.1, clip.duration); // 0.0 : 0.2
+        assert_triggered_times(&active_animation, &clip, [0.0, 0.3]);
+        active_animation.update(0.1, clip.duration); // 0.2 : 0.1
+        assert_triggered_times(&active_animation, &clip, [0.2]);
+        active_animation.update(0.1, clip.duration); // 0.1 : 0.0
+        assert_triggered_times(&active_animation, &clip, []);
+
+        active_animation.replay();
+        active_animation.update(clip.duration, clip.duration); // 0.0 : 0.0
+        assert_triggered_times(&active_animation, &clip, [0.0, 0.3, 0.2]);
+
+        active_animation.replay();
+        active_animation.seek_time = clip.duration;
+        active_animation.last_seek_time = Some(clip.duration);
+        active_animation.update(clip.duration, clip.duration); // 0.3 : 0.0
+        assert_triggered_times(&active_animation, &clip, [0.3, 0.2]);
     }
 }

From 65703dd70c70260e5816608a102e67514910d8c0 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Thu, 3 Oct 2024 19:52:33 +0200
Subject: [PATCH 58/89] tests + fix bug

---
 crates/bevy_animation/src/lib.rs | 81 +++++++++++++++++++++-----------
 1 file changed, 53 insertions(+), 28 deletions(-)

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 0555166254764..6fd4f099e3c2e 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -1380,7 +1380,7 @@ impl<'a> TriggeredEvents<'a> {
 
                 let upper = &events[upper_start..];
                 let lower = &events[..lower_end];
-                (upper, lower)
+                (lower, upper)
             }
             // The animation is looping this tick and we have to return events where
             // either last_tick >= event.time or event.time > this_tick.
@@ -1481,13 +1481,13 @@ mod tests {
     }
 
     #[track_caller]
-    fn assert_triggered_times(
+    fn assert_triggered_events_with(
         active_animation: &ActiveAnimation,
         clip: &AnimationClip,
         expected: impl Into<Vec<f32>>,
     ) {
         let Some(events) = TriggeredEvents::new(None, clip, active_animation) else {
-            assert_eq!(expected.into(), vec![]);
+            assert_eq!(expected.into(), Vec::<f32>::new());
             return;
         };
         let got: Vec<_> = events.iter().map(|t| t.time).collect();
@@ -1501,38 +1501,63 @@ mod tests {
     }
 
     #[test]
-    fn test_events_triggers_on_animation() {
+    fn test_multiple_events_triggers() {
+        let mut active_animation = ActiveAnimation {
+            repeat: RepeatAnimation::Forever,
+            ..Default::default()
+        };
+        let mut clip = AnimationClip::default();
+        clip.duration = 1.0;
+        clip.add_event(0.5, A);
+        clip.add_event(0.5, A);
+        clip.add_event(0.5, A);
+
+        assert_triggered_events_with(&active_animation, &clip, []);
+        active_animation.update(0.8, clip.duration); // 0.0 : 0.8
+        assert_triggered_events_with(&active_animation, &clip, [0.5, 0.5, 0.5]);
+
+        clip.add_event(1.0, A);
+        clip.add_event(1.0, A);
+        clip.add_event(0.0, A);
+        clip.add_event(0.0, A);
+
+        active_animation.update(0.4, clip.duration); // 0.8 : 0.2
+        assert_triggered_events_with(&active_animation, &clip, [1.0, 1.0, 0.0, 0.0]);
+    }
+
+    #[test]
+    fn test_events_triggers() {
         let mut active_animation = ActiveAnimation::default();
         let mut clip = AnimationClip::default();
         clip.add_event(0.0, A);
         clip.add_event(0.2, A);
         assert_eq!(0.2, clip.duration);
 
-        assert_triggered_times(&active_animation, &clip, []);
+        assert_triggered_events_with(&active_animation, &clip, []);
         active_animation.update(0.1, clip.duration); // 0.0 : 0.1
-        assert_triggered_times(&active_animation, &clip, [0.0]);
+        assert_triggered_events_with(&active_animation, &clip, [0.0]);
         active_animation.update(0.1, clip.duration); // 0.1 : 0.2
-        assert_triggered_times(&active_animation, &clip, [0.2]);
+        assert_triggered_events_with(&active_animation, &clip, [0.2]);
         active_animation.update(0.1, clip.duration); // 0.2 : 0.2
-        assert_triggered_times(&active_animation, &clip, []);
+        assert_triggered_events_with(&active_animation, &clip, []);
         active_animation.update(0.1, clip.duration); // 0.2 : 0.2
-        assert_triggered_times(&active_animation, &clip, []);
+        assert_triggered_events_with(&active_animation, &clip, []);
 
         active_animation.speed = -1.0;
         active_animation.completions = 0;
-        assert_triggered_times(&active_animation, &clip, []);
+        assert_triggered_events_with(&active_animation, &clip, []);
         active_animation.update(0.1, clip.duration); // 0.2 : 0.1
-        assert_triggered_times(&active_animation, &clip, [0.2]);
+        assert_triggered_events_with(&active_animation, &clip, [0.2]);
         active_animation.update(0.1, clip.duration); // 0.1 : 0.0
-        assert_triggered_times(&active_animation, &clip, []);
+        assert_triggered_events_with(&active_animation, &clip, []);
         active_animation.update(0.1, clip.duration); // 0.0 : 0.0
-        assert_triggered_times(&active_animation, &clip, [0.0]);
+        assert_triggered_events_with(&active_animation, &clip, [0.0]);
         active_animation.update(0.1, clip.duration); // 0.0 : 0.0
-        assert_triggered_times(&active_animation, &clip, []);
+        assert_triggered_events_with(&active_animation, &clip, []);
     }
 
     #[test]
-    fn test_events_triggers_on_looping_animation() {
+    fn test_events_triggers_looping() {
         let mut active_animation = ActiveAnimation {
             repeat: RepeatAnimation::Forever,
             ..Default::default()
@@ -1543,38 +1568,38 @@ mod tests {
         clip.add_event(0.3, A);
         assert_eq!(0.3, clip.duration);
 
-        assert_triggered_times(&active_animation, &clip, []);
+        assert_triggered_events_with(&active_animation, &clip, []);
         active_animation.update(0.1, clip.duration); // 0.0 : 0.1
-        assert_triggered_times(&active_animation, &clip, [0.0]);
+        assert_triggered_events_with(&active_animation, &clip, [0.0]);
         active_animation.update(0.1, clip.duration); // 0.1 : 0.2
-        assert_triggered_times(&active_animation, &clip, []);
+        assert_triggered_events_with(&active_animation, &clip, []);
         active_animation.update(0.1, clip.duration); // 0.2 : 0.3
-        assert_triggered_times(&active_animation, &clip, [0.2, 0.3]);
+        assert_triggered_events_with(&active_animation, &clip, [0.2, 0.3]);
         active_animation.update(0.1, clip.duration); // 0.3 : 0.1
-        assert_triggered_times(&active_animation, &clip, [0.0]);
+        assert_triggered_events_with(&active_animation, &clip, [0.0]);
         active_animation.update(0.1, clip.duration); // 0.1 : 0.2
-        assert_triggered_times(&active_animation, &clip, []);
+        assert_triggered_events_with(&active_animation, &clip, []);
 
         active_animation.speed = -1.0;
         active_animation.update(0.1, clip.duration); // 0.2 : 0.1
-        assert_triggered_times(&active_animation, &clip, [0.2]);
+        assert_triggered_events_with(&active_animation, &clip, [0.2]);
         active_animation.update(0.1, clip.duration); // 0.1 : 0.0
-        assert_triggered_times(&active_animation, &clip, []);
+        assert_triggered_events_with(&active_animation, &clip, []);
         active_animation.update(0.1, clip.duration); // 0.0 : 0.2
-        assert_triggered_times(&active_animation, &clip, [0.0, 0.3]);
+        assert_triggered_events_with(&active_animation, &clip, [0.0, 0.3]);
         active_animation.update(0.1, clip.duration); // 0.2 : 0.1
-        assert_triggered_times(&active_animation, &clip, [0.2]);
+        assert_triggered_events_with(&active_animation, &clip, [0.2]);
         active_animation.update(0.1, clip.duration); // 0.1 : 0.0
-        assert_triggered_times(&active_animation, &clip, []);
+        assert_triggered_events_with(&active_animation, &clip, []);
 
         active_animation.replay();
         active_animation.update(clip.duration, clip.duration); // 0.0 : 0.0
-        assert_triggered_times(&active_animation, &clip, [0.0, 0.3, 0.2]);
+        assert_triggered_events_with(&active_animation, &clip, [0.0, 0.3, 0.2]);
 
         active_animation.replay();
         active_animation.seek_time = clip.duration;
         active_animation.last_seek_time = Some(clip.duration);
         active_animation.update(clip.duration, clip.duration); // 0.3 : 0.0
-        assert_triggered_times(&active_animation, &clip, [0.3, 0.2]);
+        assert_triggered_events_with(&active_animation, &clip, [0.3, 0.2]);
     }
 }

From d0e4b380c9354f68d354b16c02d52ac5ee92a8e9 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Thu, 3 Oct 2024 20:41:08 +0200
Subject: [PATCH 59/89] clippy

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

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 6fd4f099e3c2e..8e162773d4a05 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -1506,8 +1506,10 @@ mod tests {
             repeat: RepeatAnimation::Forever,
             ..Default::default()
         };
-        let mut clip = AnimationClip::default();
-        clip.duration = 1.0;
+        let mut clip = AnimationClip {
+            duration: 1.0,
+            ..Default::default()
+        };
         clip.add_event(0.5, A);
         clip.add_event(0.5, A);
         clip.add_event(0.5, A);

From 7afc9d53570233f86f8a6c3274050a2959ff12e3 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Thu, 3 Oct 2024 21:58:33 +0200
Subject: [PATCH 60/89] remove sort

---
 crates/bevy_animation/src/lib.rs      | 20 ++++++++++++--------
 examples/animation/bunny_detective.rs | 15 ++++++---------
 2 files changed, 18 insertions(+), 17 deletions(-)

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 8e162773d4a05..eb0179b753bac 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -483,11 +483,15 @@ impl AnimationClip {
     ) {
         self.duration = self.duration.max(time);
         let triggers = self.events.entry(target_id).or_default();
-        triggers.push(AnimationEventKey {
-            time,
-            event: AnimationEventData::new(event),
-        });
-        triggers.sort_by_key(|k| FloatOrd(k.time));
+        match triggers.binary_search_by_key(&FloatOrd(time), |e| FloatOrd(e.time)) {
+            Ok(index) | Err(index) => triggers.insert(
+                index,
+                AnimationEventKey {
+                    time,
+                    event: AnimationEventData::new(event),
+                },
+            ),
+        }
     }
 }
 
@@ -1518,9 +1522,9 @@ mod tests {
         active_animation.update(0.8, clip.duration); // 0.0 : 0.8
         assert_triggered_events_with(&active_animation, &clip, [0.5, 0.5, 0.5]);
 
-        clip.add_event(1.0, A);
         clip.add_event(1.0, A);
         clip.add_event(0.0, A);
+        clip.add_event(1.0, A);
         clip.add_event(0.0, A);
 
         active_animation.update(0.4, clip.duration); // 0.8 : 0.2
@@ -1531,8 +1535,8 @@ mod tests {
     fn test_events_triggers() {
         let mut active_animation = ActiveAnimation::default();
         let mut clip = AnimationClip::default();
-        clip.add_event(0.0, A);
         clip.add_event(0.2, A);
+        clip.add_event(0.0, A);
         assert_eq!(0.2, clip.duration);
 
         assert_triggered_events_with(&active_animation, &clip, []);
@@ -1565,9 +1569,9 @@ mod tests {
             ..Default::default()
         };
         let mut clip = AnimationClip::default();
+        clip.add_event(0.3, A);
         clip.add_event(0.0, A);
         clip.add_event(0.2, A);
-        clip.add_event(0.3, A);
         assert_eq!(0.3, clip.duration);
 
         assert_triggered_events_with(&active_animation, &clip, []);
diff --git a/examples/animation/bunny_detective.rs b/examples/animation/bunny_detective.rs
index 25159c5a085de..ff892a997d192 100644
--- a/examples/animation/bunny_detective.rs
+++ b/examples/animation/bunny_detective.rs
@@ -3,10 +3,7 @@
 use std::{f32::consts::PI, time::Duration};
 
 use bevy::{
-    animation::{
-        animation_event::{AnimationEvent, ReflectAnimationEvent},
-        AnimationTargetId,
-    },
+    animation::AnimationTargetId,
     color::palettes::css::{ALICE_BLUE, WHITE},
     pbr::CascadeShadowConfigBuilder,
     prelude::*,
@@ -181,7 +178,7 @@ impl OnLanded {
         // Transition to the `walk` animation.
         let (mut player, mut transitions) = players.get_mut(trigger.entity()).unwrap();
         transitions
-            .play(&mut player, animations.walk, Duration::from_secs_f32(1.0))
+            .play(&mut player, animations.walk, Duration::from_secs_f32(0.8))
             .repeat();
 
         let translation = transforms.get(trigger.entity()).unwrap().translation();
@@ -350,9 +347,9 @@ fn setup_scene_once_loaded(
         );
 
         jump_clip.add_event(0.0, OnJumped);
-        // Trigger the `OnLanded` event after 0.53s in the jump animation.
-        // The feet hits the ground between frame 8 and 9 and the frame rate is 16 fps.
-        // 8.5 / 16 = 5.3
+        // Trigger the OnLanded event after 0.53s in the jump animation.
+        // The feet hits the ground between frame 8 and 9 in the animation
+        // and the frame rate of the animation is 16 fps: 8.5 / 16 = 5.3
         jump_clip.add_event(0.53, OnLanded);
 
         let walk_node = graph.get(animations.walk).unwrap();
@@ -362,7 +359,7 @@ fn setup_scene_once_loaded(
             .and_then(|id| clips.get_mut(id))
             .unwrap();
 
-        // Trigger `OnStep` events targeting the feet.
+        // Trigger OnStep events targeting the feet.
         walk_clip.add_event_to_target(bones.left_foot, 0.05, OnStep::Start);
         walk_clip.add_event_to_target(bones.left_foot, 0.5, OnStep::End);
         walk_clip.add_event_to_target(bones.right_foot, 0.55, OnStep::Start);

From 6ba9b71051912136c238e4d3cd4eaa044935a360 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Thu, 3 Oct 2024 23:02:49 +0200
Subject: [PATCH 61/89] Update animation_events.rs

---
 examples/animation/animation_events.rs | 86 ++++++++++++--------------
 1 file changed, 40 insertions(+), 46 deletions(-)

diff --git a/examples/animation/animation_events.rs b/examples/animation/animation_events.rs
index 93c9357db512b..a0e35ef04318e 100644
--- a/examples/animation/animation_events.rs
+++ b/examples/animation/animation_events.rs
@@ -2,46 +2,37 @@
 
 use bevy::{
     animation::animation_event::{AnimationEvent, ReflectAnimationEvent},
-    color::palettes::css::{ALICE_BLUE, CRIMSON},
+    color::palettes::css::{ALICE_BLUE, BLACK, CRIMSON},
+    core_pipeline::bloom::Bloom,
     prelude::*,
 };
 
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
-        .register_type::<Say>()
         .observe(Say::observer)
         .add_systems(Startup, setup)
-        .add_systems(Update, animate_text_opacity)
+        .add_systems(PreUpdate, animate_text_opacity)
         .run();
 }
 
 #[derive(Event, Reflect, Clone)]
 #[reflect(AnimationEvent)]
 enum Say {
-    Hello(Entity),
-    Bye(Entity),
+    Hello,
+    Bye,
 }
 
 impl Say {
-    fn entity(&self) -> Entity {
-        match self {
-            Say::Hello(entity) | Say::Bye(entity) => *entity,
-        }
-    }
-}
-
-impl Say {
-    fn observer(trigger: Trigger<Self>, mut query: Query<&mut Text>) {
-        let mut text = query.get_mut(trigger.event().entity()).unwrap();
-
+    fn observer(trigger: Trigger<Self>, mut text: Query<&mut Text, With<MessageText>>) {
+        let mut text = text.get_single_mut().unwrap();
         match trigger.event() {
-            Say::Hello(_) => {
+            Say::Hello => {
                 text.sections[0].style.color = ALICE_BLUE.into();
                 text.sections[0].value = "HELLO".into();
                 println!("HELLO");
             }
-            Say::Bye(_) => {
+            Say::Bye => {
                 text.sections[0].style.color = CRIMSON.into();
                 text.sections[0].value = "BYE".into();
                 println!("BYE");
@@ -50,6 +41,7 @@ impl Say {
     }
 }
 
+// TODO: this should be derived
 impl AnimationEvent for Say {
     fn trigger(&self, _time: f32, target: Entity, world: &mut World) {
         world.entity_mut(target).trigger(self.clone());
@@ -60,23 +52,34 @@ impl AnimationEvent for Say {
     }
 }
 
+#[derive(Component)]
+struct MessageText;
+
 fn setup(
     mut commands: Commands,
     mut animations: ResMut<Assets<AnimationClip>>,
     mut graphs: ResMut<Assets<AnimationGraph>>,
 ) {
     // Camera
-    commands.spawn(Camera2dBundle {
-        camera: Camera {
-            clear_color: ClearColorConfig::None,
+    commands.spawn((
+        Camera2dBundle {
+            camera: Camera {
+                clear_color: ClearColorConfig::Custom(BLACK.into()),
+                hdr: true,
+                ..Default::default()
+            },
             ..Default::default()
         },
-        ..Default::default()
-    });
+        Bloom {
+            intensity: 0.4,
+            ..Bloom::NATURAL
+        },
+    ));
 
-    // A text entity that will have a message printed to it
-    let message = commands
-        .spawn(TextBundle {
+    // The text that will be changed by animation events.
+    commands.spawn((
+        MessageText,
+        Text2dBundle {
             text: Text::from_section(
                 "",
                 TextStyle {
@@ -86,31 +89,21 @@ fn setup(
                 },
             ),
             ..Default::default()
-        })
-        .id();
-
-    // Container node for the message
-    commands
-        .spawn(NodeBundle {
-            style: Style {
-                width: Val::Percent(100.0),
-                height: Val::Percent(100.0),
-                justify_content: JustifyContent::Center,
-                align_items: AlignItems::Center,
-                ..Default::default()
-            },
-            ..Default::default()
-        })
-        .add_child(message);
+        },
+    ));
 
-    // Create a new animation clip
+    // Create a new animation clip.
     let mut animation = AnimationClip::default();
+
+    // This is only necessary if you want the duration of the
+    // animation to be longer than the last event in the clip.
     animation.set_duration(2.0);
 
-    // Add events at the specified time
-    animation.add_event(0.0, Say::Hello(message));
-    animation.add_event(1.0, Say::Bye(message));
+    // Add events at the specified time.
+    animation.add_event(0.0, Say::Hello);
+    animation.add_event(1.0, Say::Bye);
 
+    // Create the animation graph.
     let (graph, animation_index) = AnimationGraph::from_clip(animations.add(animation));
     let mut player = AnimationPlayer::default();
     player.play(animation_index).repeat();
@@ -118,6 +111,7 @@ fn setup(
     commands.spawn((graphs.add(graph), player));
 }
 
+// Slowly fade out the text opacity.
 fn animate_text_opacity(mut query: Query<&mut Text>, time: Res<Time>) {
     for mut text in &mut query {
         let color = &mut text.sections[0].style.color;

From b0532d178167e5931e9e683c0cc247b3924aec3e Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Thu, 3 Oct 2024 23:52:08 +0200
Subject: [PATCH 62/89] derive macro i guess

Update bunny_detective.rs
---
 crates/bevy_animation/Cargo.toml             |  1 +
 crates/bevy_animation/derive/Cargo.toml      | 27 +++++++++++++++
 crates/bevy_animation/derive/src/lib.rs      | 33 ++++++++++++++++++
 crates/bevy_animation/src/animation_event.rs |  2 ++
 examples/animation/animation_events.rs       | 14 +-------
 examples/animation/bunny_detective.rs        | 36 ++------------------
 6 files changed, 67 insertions(+), 46 deletions(-)
 create mode 100644 crates/bevy_animation/derive/Cargo.toml
 create mode 100644 crates/bevy_animation/derive/src/lib.rs

diff --git a/crates/bevy_animation/Cargo.toml b/crates/bevy_animation/Cargo.toml
index 66d20c49fe872..a55de59cf5b7f 100644
--- a/crates/bevy_animation/Cargo.toml
+++ b/crates/bevy_animation/Cargo.toml
@@ -10,6 +10,7 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
+bevy_animation_derive = { path = "derive", version = "0.15.0-dev" }
 bevy_app = { path = "../bevy_app", version = "0.15.0-dev" }
 bevy_asset = { path = "../bevy_asset", version = "0.15.0-dev" }
 bevy_color = { path = "../bevy_color", version = "0.15.0-dev" }
diff --git a/crates/bevy_animation/derive/Cargo.toml b/crates/bevy_animation/derive/Cargo.toml
new file mode 100644
index 0000000000000..14af125509d5a
--- /dev/null
+++ b/crates/bevy_animation/derive/Cargo.toml
@@ -0,0 +1,27 @@
+[package]
+name = "bevy_animation_derive"
+version = "0.15.0-dev"
+edition = "2021"
+description = "Derive implementations for bevy_animation"
+homepage = "https://bevyengine.org"
+repository = "https://github.com/bevyengine/bevy"
+license = "MIT OR Apache-2.0"
+keywords = ["bevy"]
+
+[lib]
+proc-macro = true
+
+[dependencies]
+bevy_macro_utils = { path = "../../bevy_macro_utils", version = "0.15.0-dev" }
+bevy_ecs_macros = { path = "../../bevy_ecs/macros", version = "0.15.0-dev" }
+proc-macro2 = "1.0"
+quote = "1.0"
+syn = { version = "2.0", features = ["full"] }
+uuid = { version = "1.1", features = ["v4"] }
+
+[lints]
+workspace = true
+
+[package.metadata.docs.rs]
+rustdoc-args = ["-Zunstable-options", "--generate-link-to-definition"]
+all-features = true
diff --git a/crates/bevy_animation/derive/src/lib.rs b/crates/bevy_animation/derive/src/lib.rs
new file mode 100644
index 0000000000000..a024f6ccc2d55
--- /dev/null
+++ b/crates/bevy_animation/derive/src/lib.rs
@@ -0,0 +1,33 @@
+//! Derive macros for `bevy_animation`.
+
+extern crate proc_macro;
+
+use bevy_macro_utils::BevyManifest;
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{parse_macro_input, DeriveInput};
+
+/// Used to derive `AnimationEvent` for a type.
+#[proc_macro_derive(AnimationEvent)]
+pub fn derive_animation_event(input: TokenStream) -> TokenStream {
+    let ast = parse_macro_input!(input as DeriveInput);
+    let name = ast.ident;
+    let manifest = BevyManifest::default();
+    let bevy_animation_path = manifest.get_path("bevy_animation");
+    let bevy_ecs_path = manifest.get_path("bevy_ecs");
+    let animation_event_path = quote! { #bevy_animation_path::animation_event };
+    let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl();
+    // TODO: This could derive Event as well.
+    quote! {
+        impl #impl_generics #animation_event_path::AnimationEvent for #name #ty_generics #where_clause {
+            fn trigger(&self, _time: f32, entity: #bevy_ecs_path::entity::Entity, world: &mut #bevy_ecs_path::world::World) {
+                world.entity_mut(entity).trigger(Clone::clone(self));
+            }
+
+            fn clone_value(&self) -> Box<dyn #animation_event_path::AnimationEvent> {
+                Box::new(Clone::clone(self))
+            }
+        }
+    }
+    .into()
+}
diff --git a/crates/bevy_animation/src/animation_event.rs b/crates/bevy_animation/src/animation_event.rs
index d1feb1bdf5362..e76fb0b3c13ca 100644
--- a/crates/bevy_animation/src/animation_event.rs
+++ b/crates/bevy_animation/src/animation_event.rs
@@ -9,6 +9,8 @@ use bevy_reflect::{
     TupleStructFieldIter, TupleStructInfo, TypeInfo, TypeRegistration, Typed, UnnamedField,
 };
 
+pub use bevy_animation_derive::AnimationEvent;
+
 pub(crate) fn trigger_animation_event(
     entity: Entity,
     time: f32,
diff --git a/examples/animation/animation_events.rs b/examples/animation/animation_events.rs
index a0e35ef04318e..259b5db4583c6 100644
--- a/examples/animation/animation_events.rs
+++ b/examples/animation/animation_events.rs
@@ -1,7 +1,6 @@
 //! Demonstrate how to use animation events.
 
 use bevy::{
-    animation::animation_event::{AnimationEvent, ReflectAnimationEvent},
     color::palettes::css::{ALICE_BLUE, BLACK, CRIMSON},
     core_pipeline::bloom::Bloom,
     prelude::*,
@@ -16,7 +15,7 @@ fn main() {
         .run();
 }
 
-#[derive(Event, Reflect, Clone)]
+#[derive(Event, AnimationEvent, Reflect, Clone)]
 #[reflect(AnimationEvent)]
 enum Say {
     Hello,
@@ -41,17 +40,6 @@ impl Say {
     }
 }
 
-// TODO: this should be derived
-impl AnimationEvent for Say {
-    fn trigger(&self, _time: f32, target: Entity, world: &mut World) {
-        world.entity_mut(target).trigger(self.clone());
-    }
-
-    fn clone_value(&self) -> Box<dyn AnimationEvent> {
-        Box::new(self.clone())
-    }
-}
-
 #[derive(Component)]
 struct MessageText;
 
diff --git a/examples/animation/bunny_detective.rs b/examples/animation/bunny_detective.rs
index ff892a997d192..dcf7acf2aec12 100644
--- a/examples/animation/bunny_detective.rs
+++ b/examples/animation/bunny_detective.rs
@@ -96,20 +96,10 @@ impl FromWorld for ParticleAssets {
     }
 }
 
-#[derive(Event, Reflect, Clone)]
+#[derive(Event, AnimationEvent, Reflect, Clone)]
 #[reflect(AnimationEvent)]
 struct OnJumped;
 
-impl AnimationEvent for OnJumped {
-    fn trigger(&self, _time: f32, target: Entity, world: &mut World) {
-        world.entity_mut(target).trigger(Self);
-    }
-
-    fn clone_value(&self) -> Box<dyn AnimationEvent> {
-        Box::new(Self)
-    }
-}
-
 impl OnJumped {
     // Spawn particles once the detective jumps.
     fn observer(
@@ -151,20 +141,10 @@ impl OnJumped {
     }
 }
 
-#[derive(Event, Reflect, Clone)]
+#[derive(Event, AnimationEvent, Reflect, Clone)]
 #[reflect(AnimationEvent)]
 struct OnLanded;
 
-impl AnimationEvent for OnLanded {
-    fn trigger(&self, _time: f32, target: Entity, world: &mut World) {
-        world.entity_mut(target).trigger(Self);
-    }
-
-    fn clone_value(&self) -> Box<dyn AnimationEvent> {
-        Box::new(Self)
-    }
-}
-
 impl OnLanded {
     // Spawn particles once the detective lands.
     fn observer(
@@ -199,23 +179,13 @@ impl OnLanded {
     }
 }
 
-#[derive(Event, Resource, Reflect, Clone)]
+#[derive(Event, AnimationEvent, Resource, Reflect, Clone)]
 #[reflect(AnimationEvent)]
 enum OnStep {
     Start,
     End,
 }
 
-impl AnimationEvent for OnStep {
-    fn trigger(&self, _time: f32, target: Entity, world: &mut World) {
-        world.entity_mut(target).trigger(self.clone());
-    }
-
-    fn clone_value(&self) -> Box<dyn AnimationEvent> {
-        Box::new(self.clone())
-    }
-}
-
 impl OnStep {
     // Spawn particles on each step the detective takes.
     fn observer(

From 4f88b023decf4ad2b8c6d0ec8e6597808522086e Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Fri, 4 Oct 2024 00:25:20 +0200
Subject: [PATCH 63/89] add instructions ui to example

---
 examples/animation/bunny_detective.rs | 30 +++++++++++++++++++++++++--
 1 file changed, 28 insertions(+), 2 deletions(-)

diff --git a/examples/animation/bunny_detective.rs b/examples/animation/bunny_detective.rs
index dcf7acf2aec12..576b227570ed0 100644
--- a/examples/animation/bunny_detective.rs
+++ b/examples/animation/bunny_detective.rs
@@ -17,12 +17,12 @@ fn main() {
         .register_type::<(OnLanded, OnJumped, OnStep)>()
         .add_plugins(DefaultPlugins)
         .insert_resource(AmbientLight {
-            color: Color::WHITE,
+            color: ALICE_BLUE.into(),
             brightness: 2000.,
         })
         .init_resource::<ParticleAssets>()
         .init_resource::<BoneTargets>()
-        .add_systems(Startup, setup)
+        .add_systems(Startup, (setup, setup_instructions))
         .add_systems(
             Update,
             (setup_scene_once_loaded, jump_input, simulate_particles),
@@ -409,3 +409,29 @@ fn spawn_particle<M: Material>(
         ));
     }
 }
+
+fn setup_instructions(mut commands: Commands) {
+    commands
+        .spawn(NodeBundle {
+            style: Style {
+                padding: UiRect::all(Val::Px(20.0)),
+                width: Val::Percent(100.0),
+                height: Val::Percent(100.0),
+                justify_content: JustifyContent::Center,
+                align_items: AlignItems::End,
+                ..Default::default()
+            },
+            ..Default::default()
+        })
+        .with_child(TextBundle {
+            text: Text::from_section(
+                "press spacebar to jump",
+                TextStyle {
+                    font_size: 40.0,
+                    color: ALICE_BLUE.into(),
+                    ..Default::default()
+                },
+            ),
+            ..Default::default()
+        });
+}

From e763cb4fe5e87b09986bdb178648edfbf6bfb5be Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Fri, 4 Oct 2024 14:37:04 +0200
Subject: [PATCH 64/89] remove unused dependencies

---
 crates/bevy_animation/derive/Cargo.toml | 2 --
 1 file changed, 2 deletions(-)

diff --git a/crates/bevy_animation/derive/Cargo.toml b/crates/bevy_animation/derive/Cargo.toml
index 14af125509d5a..ad44a82b0029f 100644
--- a/crates/bevy_animation/derive/Cargo.toml
+++ b/crates/bevy_animation/derive/Cargo.toml
@@ -13,11 +13,9 @@ proc-macro = true
 
 [dependencies]
 bevy_macro_utils = { path = "../../bevy_macro_utils", version = "0.15.0-dev" }
-bevy_ecs_macros = { path = "../../bevy_ecs/macros", version = "0.15.0-dev" }
 proc-macro2 = "1.0"
 quote = "1.0"
 syn = { version = "2.0", features = ["full"] }
-uuid = { version = "1.1", features = ["v4"] }
 
 [lints]
 workspace = true

From d9359eb127d46bd7aa2d8e6767a77b7376e835b0 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Fri, 4 Oct 2024 14:44:51 +0200
Subject: [PATCH 65/89] remove comments

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

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index eb0179b753bac..6a3effbe0a90b 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -1379,8 +1379,8 @@ impl<'a> TriggeredEvents<'a> {
             // The animation is looping this tick and we have to return events where
             // either last_tick <= event.time or event.time < this_tick.
             TriggeredEventsDir::ForwardLooping => {
-                let upper_start = events.partition_point(|event| event.time < last_time); // First index where t >= last_tick
-                let lower_end = events.partition_point(|event| event.time < this_time); // First index where t >= this_tick
+                let upper_start = events.partition_point(|event| event.time < last_time);
+                let lower_end = events.partition_point(|event| event.time < this_time);
 
                 let upper = &events[upper_start..];
                 let lower = &events[..lower_end];
@@ -1389,8 +1389,8 @@ impl<'a> TriggeredEvents<'a> {
             // The animation is looping this tick and we have to return events where
             // either last_tick >= event.time or event.time > this_tick.
             TriggeredEventsDir::ReverseLooping => {
-                let lower_end = events.partition_point(|event| event.time <= last_time); // First index where t > last_tick
-                let upper_start = events.partition_point(|event| event.time <= this_time); // First index where t > this_tick
+                let lower_end = events.partition_point(|event| event.time <= last_time);
+                let upper_start = events.partition_point(|event| event.time <= this_time);
 
                 let upper = &events[upper_start..];
                 let lower = &events[..lower_end];

From a244b4a6c280a39f70c0edd66f775d2d022f054c Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Fri, 4 Oct 2024 15:11:36 +0200
Subject: [PATCH 66/89] rename root bone + remove non-deform bones

---
 assets/models/animated/buntective.glb | Bin 347484 -> 301380 bytes
 examples/animation/bunny_detective.rs |   6 +++---
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/assets/models/animated/buntective.glb b/assets/models/animated/buntective.glb
index 3a78a75b37747688a23f0c55fbe025e8d68b443d..002498f3fa3766281e12a97ac0d02b33aeff03bc 100644
GIT binary patch
delta 15700
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
H-C6N}>Y}}+

delta 38195
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
OQv+vzpW(mQ|Nj6~CGnI1

diff --git a/examples/animation/bunny_detective.rs b/examples/animation/bunny_detective.rs
index 576b227570ed0..63ebb0a070edb 100644
--- a/examples/animation/bunny_detective.rs
+++ b/examples/animation/bunny_detective.rs
@@ -50,16 +50,16 @@ struct BoneTargets {
 impl Default for BoneTargets {
     fn default() -> Self {
         Self {
-            root: AnimationTargetId::from_iter(["Armature"]),
+            root: AnimationTargetId::from_iter(["Bunny"]),
             right_foot: AnimationTargetId::from_iter([
-                "Armature",
+                "Bunny",
                 "pelvis",
                 "upperleg.r",
                 "lowerleg.r",
                 "foot.r",
             ]),
             left_foot: AnimationTargetId::from_iter([
-                "Armature",
+                "Bunny",
                 "pelvis",
                 "upperleg.l",
                 "lowerleg.l",

From 710498e69a134b329bf032a35c35fb7e9612187c Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Fri, 4 Oct 2024 16:26:23 +0200
Subject: [PATCH 67/89] add `CloneableAnimationEvent`

Update lib.rs
---
 crates/bevy_animation/derive/src/lib.rs      |  4 ----
 crates/bevy_animation/src/animation_event.rs | 22 +++++++++++++++++---
 crates/bevy_animation/src/lib.rs             |  7 +------
 3 files changed, 20 insertions(+), 13 deletions(-)

diff --git a/crates/bevy_animation/derive/src/lib.rs b/crates/bevy_animation/derive/src/lib.rs
index a024f6ccc2d55..49a2259682448 100644
--- a/crates/bevy_animation/derive/src/lib.rs
+++ b/crates/bevy_animation/derive/src/lib.rs
@@ -23,10 +23,6 @@ pub fn derive_animation_event(input: TokenStream) -> TokenStream {
             fn trigger(&self, _time: f32, entity: #bevy_ecs_path::entity::Entity, world: &mut #bevy_ecs_path::world::World) {
                 world.entity_mut(entity).trigger(Clone::clone(self));
             }
-
-            fn clone_value(&self) -> Box<dyn #animation_event_path::AnimationEvent> {
-                Box::new(Clone::clone(self))
-            }
         }
     }
     .into()
diff --git a/crates/bevy_animation/src/animation_event.rs b/crates/bevy_animation/src/animation_event.rs
index e76fb0b3c13ca..d501fbbee6d98 100644
--- a/crates/bevy_animation/src/animation_event.rs
+++ b/crates/bevy_animation/src/animation_event.rs
@@ -21,17 +21,33 @@ pub(crate) fn trigger_animation_event(
     }
 }
 
-// TODO: this should have a derive macro
 /// An event that can be used with animations.
+/// It can be derived to trigger as an observer event,
+/// if you need more complex behaivour, consider
+/// a manual implementation.
 #[reflect_trait]
-pub trait AnimationEvent: Reflect + Send + Sync {
+pub trait AnimationEvent: CloneableAnimationEvent + Reflect + Send + Sync {
     /// Trigger the event, targeting `entity`.
     fn trigger(&self, time: f32, entity: Entity, world: &mut World);
+}
 
+/// This trait exist so that manual implementors of [`AnimationEvent`]
+/// does not have to implement `clone_value`.
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` does not implement `Clone`",
+    note = "consider annotating `{Self}` with `#[derive(Clone)]`"
+)]
+pub trait CloneableAnimationEvent {
     /// Clone this value into a new `Box<dyn AnimationEvent>`
     fn clone_value(&self) -> Box<dyn AnimationEvent>;
 }
 
+impl<T: AnimationEvent + Clone> CloneableAnimationEvent for T {
+    fn clone_value(&self) -> Box<dyn AnimationEvent> {
+        Box::new(self.clone())
+    }
+}
+
 /// The data that will be used to trigger an animation event.
 #[derive(TypePath)]
 pub(crate) struct AnimationEventData(pub(crate) Box<dyn AnimationEvent>);
@@ -53,7 +69,7 @@ impl Debug for AnimationEventData {
 
 impl Clone for AnimationEventData {
     fn clone(&self) -> Self {
-        Self(AnimationEvent::clone_value(self.0.as_ref()))
+        Self(CloneableAnimationEvent::clone_value(self.0.as_ref()))
     }
 }
 
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 6a3effbe0a90b..ed1dd41c192cf 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -919,7 +919,6 @@ fn trigger_untargeted_animation_events(
     graphs: Res<Assets<AnimationGraph>>,
     players: Query<(Entity, &AnimationPlayer, &Handle<AnimationGraph>)>,
 ) {
-    // untargeted events
     for (entity, player, graph_id) in &players {
         // The graph might not have loaded yet. Safely bail.
         let Some(graph) = graphs.get(graph_id) else {
@@ -1471,17 +1470,13 @@ impl<'a> Iterator for TriggeredEventsIter<'a> {
 mod tests {
     use super::*;
 
-    #[derive(Event, Clone, Reflect)]
+    #[derive(Event, Reflect, Clone)]
     struct A;
 
     impl AnimationEvent for A {
         fn trigger(&self, _time: f32, target: Entity, world: &mut World) {
             world.entity_mut(target).trigger(self.clone());
         }
-
-        fn clone_value(&self) -> Box<dyn AnimationEvent> {
-            Box::new(self.clone())
-        }
     }
 
     #[track_caller]

From 0165c29860ca2ce9f8f941fd8f25d0558255a827 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Fri, 4 Oct 2024 16:29:45 +0200
Subject: [PATCH 68/89] update examples

---
 examples/animation/animation_events.rs | 38 +++++++++++-------
 examples/animation/bunny_detective.rs  | 55 +++++++++++++-------------
 2 files changed, 52 insertions(+), 41 deletions(-)

diff --git a/examples/animation/animation_events.rs b/examples/animation/animation_events.rs
index 259b5db4583c6..4644d0856fc5c 100644
--- a/examples/animation/animation_events.rs
+++ b/examples/animation/animation_events.rs
@@ -9,40 +9,50 @@ use bevy::{
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
-        .observe(Say::observer)
+        .add_event::<Say>()
         .add_systems(Startup, setup)
-        .add_systems(PreUpdate, animate_text_opacity)
+        .add_systems(PreUpdate, (animate_text_opacity, edit_message))
         .run();
 }
 
-#[derive(Event, AnimationEvent, Reflect, Clone)]
+#[derive(Component)]
+struct MessageText;
+
+#[derive(Event, Reflect, Clone)]
 #[reflect(AnimationEvent)]
 enum Say {
     Hello,
     Bye,
 }
 
-impl Say {
-    fn observer(trigger: Trigger<Self>, mut text: Query<&mut Text, With<MessageText>>) {
-        let mut text = text.get_single_mut().unwrap();
-        match trigger.event() {
+// AnimationEvent can also be derived, but doing so will
+// trigger it as an observer event which runs in PostUpdate.
+// We need to set the message text before that so it is
+// updated before rendering without a one frame delay.
+impl AnimationEvent for Say {
+    fn trigger(&self, _time: f32, _entity: Entity, world: &mut World) {
+        world.send_event(self.clone());
+    }
+}
+
+fn edit_message(
+    mut event_reader: EventReader<Say>,
+    mut text: Single<&mut Text, With<MessageText>>,
+) {
+    for event in event_reader.read() {
+        match event {
             Say::Hello => {
-                text.sections[0].style.color = ALICE_BLUE.into();
                 text.sections[0].value = "HELLO".into();
-                println!("HELLO");
+                text.sections[0].style.color = ALICE_BLUE.into();
             }
             Say::Bye => {
-                text.sections[0].style.color = CRIMSON.into();
                 text.sections[0].value = "BYE".into();
-                println!("BYE");
+                text.sections[0].style.color = CRIMSON.into();
             }
         }
     }
 }
 
-#[derive(Component)]
-struct MessageText;
-
 fn setup(
     mut commands: Commands,
     mut animations: ResMut<Assets<AnimationClip>>,
diff --git a/examples/animation/bunny_detective.rs b/examples/animation/bunny_detective.rs
index 63ebb0a070edb..fc403fee46df0 100644
--- a/examples/animation/bunny_detective.rs
+++ b/examples/animation/bunny_detective.rs
@@ -49,6 +49,7 @@ struct BoneTargets {
 
 impl Default for BoneTargets {
     fn default() -> Self {
+        // Store the id's of the bones we want to add events to for later use.
         Self {
             root: AnimationTargetId::from_iter(["Bunny"]),
             right_foot: AnimationTargetId::from_iter([
@@ -69,33 +70,6 @@ impl Default for BoneTargets {
     }
 }
 
-#[derive(Component)]
-struct Particle {
-    lifeteime: Timer,
-    size: f32,
-    velocity: Vec3,
-}
-
-#[derive(Resource)]
-struct ParticleAssets {
-    mesh: Handle<Mesh>,
-    material: Handle<StandardMaterial>,
-}
-
-impl FromWorld for ParticleAssets {
-    fn from_world(world: &mut World) -> Self {
-        Self {
-            mesh: world.resource_mut::<Assets<Mesh>>().add(Sphere::new(0.25)),
-            material: world
-                .resource_mut::<Assets<StandardMaterial>>()
-                .add(StandardMaterial {
-                    base_color: WHITE.into(),
-                    ..Default::default()
-                }),
-        }
-    }
-}
-
 #[derive(Event, AnimationEvent, Reflect, Clone)]
 #[reflect(AnimationEvent)]
 struct OnJumped;
@@ -365,6 +339,33 @@ fn jump_input(
     }
 }
 
+#[derive(Component)]
+struct Particle {
+    lifeteime: Timer,
+    size: f32,
+    velocity: Vec3,
+}
+
+#[derive(Resource)]
+struct ParticleAssets {
+    mesh: Handle<Mesh>,
+    material: Handle<StandardMaterial>,
+}
+
+impl FromWorld for ParticleAssets {
+    fn from_world(world: &mut World) -> Self {
+        Self {
+            mesh: world.resource_mut::<Assets<Mesh>>().add(Sphere::new(0.25)),
+            material: world
+                .resource_mut::<Assets<StandardMaterial>>()
+                .add(StandardMaterial {
+                    base_color: WHITE.into(),
+                    ..Default::default()
+                }),
+        }
+    }
+}
+
 fn simulate_particles(
     mut commands: Commands,
     mut query: Query<(Entity, &mut Transform, &mut Particle)>,

From 7708aa18528746c523114768b46e0ab1c1f4c3f7 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Fri, 4 Oct 2024 16:38:30 +0200
Subject: [PATCH 69/89] typos

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

diff --git a/crates/bevy_animation/src/animation_event.rs b/crates/bevy_animation/src/animation_event.rs
index d501fbbee6d98..d08bab0fb93ef 100644
--- a/crates/bevy_animation/src/animation_event.rs
+++ b/crates/bevy_animation/src/animation_event.rs
@@ -23,7 +23,7 @@ pub(crate) fn trigger_animation_event(
 
 /// An event that can be used with animations.
 /// It can be derived to trigger as an observer event,
-/// if you need more complex behaivour, consider
+/// if you need more complex behaviour, consider
 /// a manual implementation.
 #[reflect_trait]
 pub trait AnimationEvent: CloneableAnimationEvent + Reflect + Send + Sync {

From 0aef794af697d76630dc6be66eb78c557cc6369f Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Fri, 4 Oct 2024 20:38:57 +0200
Subject: [PATCH 70/89] add `weight` to `AnimationEvent`

Update animation_events.rs
---
 crates/bevy_animation/derive/src/lib.rs      |  2 +-
 crates/bevy_animation/src/animation_event.rs |  5 +++--
 crates/bevy_animation/src/lib.rs             | 10 ++++++++--
 examples/animation/animation_events.rs       |  2 +-
 4 files changed, 13 insertions(+), 6 deletions(-)

diff --git a/crates/bevy_animation/derive/src/lib.rs b/crates/bevy_animation/derive/src/lib.rs
index 49a2259682448..48bce1163eae9 100644
--- a/crates/bevy_animation/derive/src/lib.rs
+++ b/crates/bevy_animation/derive/src/lib.rs
@@ -20,7 +20,7 @@ pub fn derive_animation_event(input: TokenStream) -> TokenStream {
     // TODO: This could derive Event as well.
     quote! {
         impl #impl_generics #animation_event_path::AnimationEvent for #name #ty_generics #where_clause {
-            fn trigger(&self, _time: f32, entity: #bevy_ecs_path::entity::Entity, world: &mut #bevy_ecs_path::world::World) {
+            fn trigger(&self, _time: f32, _weight: f32, entity: #bevy_ecs_path::entity::Entity, world: &mut #bevy_ecs_path::world::World) {
                 world.entity_mut(entity).trigger(Clone::clone(self));
             }
         }
diff --git a/crates/bevy_animation/src/animation_event.rs b/crates/bevy_animation/src/animation_event.rs
index d08bab0fb93ef..54a7716c119ac 100644
--- a/crates/bevy_animation/src/animation_event.rs
+++ b/crates/bevy_animation/src/animation_event.rs
@@ -14,10 +14,11 @@ pub use bevy_animation_derive::AnimationEvent;
 pub(crate) fn trigger_animation_event(
     entity: Entity,
     time: f32,
+    weight: f32,
     event: Box<dyn AnimationEvent>,
 ) -> impl Command {
     move |world: &mut World| {
-        event.trigger(time, entity, world);
+        event.trigger(time, weight, entity, world);
     }
 }
 
@@ -28,7 +29,7 @@ pub(crate) fn trigger_animation_event(
 #[reflect_trait]
 pub trait AnimationEvent: CloneableAnimationEvent + Reflect + Send + Sync {
     /// Trigger the event, targeting `entity`.
-    fn trigger(&self, time: f32, entity: Entity, world: &mut World);
+    fn trigger(&self, time: f32, weight: f32, entity: Entity, world: &mut World);
 }
 
 /// This trait exist so that manual implementors of [`AnimationEvent`]
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index ed1dd41c192cf..cb0462ab40e7f 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -939,7 +939,12 @@ fn trigger_untargeted_animation_events(
             };
 
             for AnimationEventKey { time, event } in triggered_events.iter() {
-                commands.queue(trigger_animation_event(entity, *time, event.clone().0));
+                commands.queue(trigger_animation_event(
+                    entity,
+                    *time,
+                    active_animation.weight,
+                    event.clone().0,
+                ));
             }
         }
     }
@@ -1119,6 +1124,7 @@ pub fn animate_targets(
                                         commands.queue(trigger_animation_event(
                                             entity,
                                             *time,
+                                            active_animation.weight,
                                             event.clone().0,
                                         ));
                                     }
@@ -1474,7 +1480,7 @@ mod tests {
     struct A;
 
     impl AnimationEvent for A {
-        fn trigger(&self, _time: f32, target: Entity, world: &mut World) {
+        fn trigger(&self, _time: f32, _weight: f32, target: Entity, world: &mut World) {
             world.entity_mut(target).trigger(self.clone());
         }
     }
diff --git a/examples/animation/animation_events.rs b/examples/animation/animation_events.rs
index 4644d0856fc5c..98ad9b99744bd 100644
--- a/examples/animation/animation_events.rs
+++ b/examples/animation/animation_events.rs
@@ -30,7 +30,7 @@ enum Say {
 // We need to set the message text before that so it is
 // updated before rendering without a one frame delay.
 impl AnimationEvent for Say {
-    fn trigger(&self, _time: f32, _entity: Entity, world: &mut World) {
+    fn trigger(&self, _time: f32, _weight: f32, _entity: Entity, world: &mut World) {
         world.send_event(self.clone());
     }
 }

From dbb4a60f35915ee41e0e2c6d716358cf1cc75e68 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Fri, 4 Oct 2024 20:41:06 +0200
Subject: [PATCH 71/89] move feet up from ground

---
 assets/models/animated/buntective.glb | Bin 301380 -> 300680 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/assets/models/animated/buntective.glb b/assets/models/animated/buntective.glb
index 002498f3fa3766281e12a97ac0d02b33aeff03bc..fa89960b2287c0bb419763cc02c24d6d2fff05c4 100644
GIT binary patch
delta 20645
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

delta 20452
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
J^4L_>{y!fxc?AFf


From b7a559d9ceceba5f924547d55644e72ef34b3ec4 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Fri, 4 Oct 2024 22:26:34 +0200
Subject: [PATCH 72/89] Update bunny_detective.rs

Update bunny_detective.rs
---
 examples/animation/bunny_detective.rs | 26 ++++++++++++++++++--------
 1 file changed, 18 insertions(+), 8 deletions(-)

diff --git a/examples/animation/bunny_detective.rs b/examples/animation/bunny_detective.rs
index fc403fee46df0..995965f85b726 100644
--- a/examples/animation/bunny_detective.rs
+++ b/examples/animation/bunny_detective.rs
@@ -81,10 +81,15 @@ impl OnJumped {
         mut commands: Commands,
         particle: Res<ParticleAssets>,
         transforms: Query<&GlobalTransform>,
+        mut text_visibility: Single<&mut Visibility, With<Text>>,
     ) {
+        // Hide instructions text.
+        *text_visibility.as_mut() = Visibility::Hidden;
+
         let translation = transforms.get(trigger.entity()).unwrap().translation();
         let mut rng = thread_rng();
-        // Vertical
+
+        // Spawn particle upward burst
         for _ in 0..5 {
             let horizontal = rng.gen::<Dir2>() * rng.gen_range(0.0..0.2);
             let vertical = rng.gen_range(0.0..10.0);
@@ -98,7 +103,7 @@ impl OnJumped {
                 Vec3::new(horizontal.x, vertical, horizontal.y),
             ));
         }
-        // Horizontal
+        // Spawn particle horizontal burst
         for _ in 0..20 {
             let horizontal = rng.gen::<Dir2>() * rng.gen_range(6.0..8.0);
             let vertical = rng.gen_range(0.0..2.0);
@@ -126,15 +131,19 @@ impl OnLanded {
         mut commands: Commands,
         particle: Res<ParticleAssets>,
         animations: Res<Animations>,
-        mut players: Query<(&mut AnimationPlayer, &mut AnimationTransitions)>,
+        mut animation_players: Query<(&mut AnimationPlayer, &mut AnimationTransitions)>,
+        mut text_visibility: Single<&mut Visibility, With<Text>>,
         transforms: Query<&GlobalTransform>,
     ) {
         // Transition to the `walk` animation.
-        let (mut player, mut transitions) = players.get_mut(trigger.entity()).unwrap();
+        let (mut player, mut transitions) = animation_players.get_mut(trigger.entity()).unwrap();
         transitions
             .play(&mut player, animations.walk, Duration::from_secs_f32(0.8))
             .repeat();
 
+        // Show instructions text.
+        **text_visibility = Visibility::Visible;
+
         let translation = transforms.get(trigger.entity()).unwrap().translation();
         let mut rng = thread_rng();
         for _ in 0..25 {
@@ -341,7 +350,7 @@ fn jump_input(
 
 #[derive(Component)]
 struct Particle {
-    lifeteime: Timer,
+    lifeteime_timer: Timer,
     size: f32,
     velocity: Vec3,
 }
@@ -372,11 +381,12 @@ fn simulate_particles(
     time: Res<Time>,
 ) {
     for (entity, mut transform, mut particle) in &mut query {
-        if particle.lifeteime.tick(time.delta()).just_finished() {
+        if particle.lifeteime_timer.tick(time.delta()).just_finished() {
             commands.entity(entity).despawn();
         } else {
             transform.translation += particle.velocity * time.delta_seconds();
-            transform.scale = Vec3::splat(particle.size.lerp(0.0, particle.lifeteime.fraction()));
+            transform.scale =
+                Vec3::splat(particle.size.lerp(0.0, particle.lifeteime_timer.fraction()));
             particle
                 .velocity
                 .smooth_nudge(&Vec3::ZERO, 4.0, time.delta_seconds());
@@ -396,7 +406,7 @@ fn spawn_particle<M: Material>(
     move |world: &mut World| {
         world.spawn((
             Particle {
-                lifeteime: Timer::from_seconds(lifetime, TimerMode::Once),
+                lifeteime_timer: Timer::from_seconds(lifetime, TimerMode::Once),
                 size,
                 velocity,
             },

From 48964ec8f788560ef96c02eb3f6159620412a102 Mon Sep 17 00:00:00 2001
From: poopy <gonesbird@gmail.com>
Date: Fri, 4 Oct 2024 23:22:38 +0200
Subject: [PATCH 73/89] Update crates/bevy_animation/src/animation_event.rs

Co-authored-by: Matty <weatherleymatthew@gmail.com>
---
 crates/bevy_animation/src/animation_event.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_animation/src/animation_event.rs b/crates/bevy_animation/src/animation_event.rs
index 54a7716c119ac..d923348bdcb97 100644
--- a/crates/bevy_animation/src/animation_event.rs
+++ b/crates/bevy_animation/src/animation_event.rs
@@ -33,7 +33,7 @@ pub trait AnimationEvent: CloneableAnimationEvent + Reflect + Send + Sync {
 }
 
 /// This trait exist so that manual implementors of [`AnimationEvent`]
-/// does not have to implement `clone_value`.
+/// do not have to implement `clone_value`.
 #[diagnostic::on_unimplemented(
     message = "`{Self}` does not implement `Clone`",
     note = "consider annotating `{Self}` with `#[derive(Clone)]`"

From a13a094ff80d068a8bdc9e555e4de165e6891d66 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Fri, 4 Oct 2024 23:22:55 +0200
Subject: [PATCH 74/89] implement suggestions

---
 crates/bevy_animation/src/lib.rs | 84 ++++++++++++++++++++++----------
 1 file changed, 58 insertions(+), 26 deletions(-)

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index cb0462ab40e7f..5118a8d1fa538 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -287,12 +287,18 @@ pub struct AnimationClip {
 }
 
 #[derive(Reflect, Debug, Clone)]
-pub(crate) struct AnimationEventKey {
+pub(crate) struct TimedAnimationEvent {
     time: f32,
     event: AnimationEventData,
 }
 
-pub(crate) type AnimationEvents = HashMap<Option<AnimationTargetId>, Vec<AnimationEventKey>>;
+#[derive(Reflect, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone)]
+pub(crate) enum AnimationEventTarget {
+    Root,
+    Node(AnimationTargetId),
+}
+
+pub(crate) type AnimationEvents = HashMap<AnimationEventTarget, Vec<TimedAnimationEvent>>;
 
 /// A mapping from [`AnimationTargetId`] (e.g. bone in a skinned mesh) to the
 /// animation curves.
@@ -463,7 +469,7 @@ impl AnimationClip {
         time: f32,
         event: impl AnimationEvent,
     ) {
-        self.add_event_to_target_inner(Some(target_id), time, event);
+        self.add_event_to_target_inner(AnimationEventTarget::Node(target_id), time, event);
     }
 
     /// Add a untargeted [`AnimationEvent`] to this [`AnimationClip`].
@@ -472,21 +478,21 @@ impl AnimationClip {
     ///
     /// See also [`add_event_to_target`](Self::add_event_to_target).
     pub fn add_event(&mut self, time: f32, event: impl AnimationEvent) {
-        self.add_event_to_target_inner(None, time, event);
+        self.add_event_to_target_inner(AnimationEventTarget::Root, time, event);
     }
 
     fn add_event_to_target_inner(
         &mut self,
-        target_id: Option<AnimationTargetId>,
+        target: AnimationEventTarget,
         time: f32,
         event: impl AnimationEvent,
     ) {
         self.duration = self.duration.max(time);
-        let triggers = self.events.entry(target_id).or_default();
+        let triggers = self.events.entry(target).or_default();
         match triggers.binary_search_by_key(&FloatOrd(time), |e| FloatOrd(e.time)) {
             Ok(index) | Err(index) => triggers.insert(
                 index,
-                AnimationEventKey {
+                TimedAnimationEvent {
                     time,
                     event: AnimationEventData::new(event),
                 },
@@ -711,6 +717,20 @@ impl ActiveAnimation {
     }
 
     /// Seeks to a specific time in the animation.
+    ///
+    /// This will not trigger events between the current time and `seek_time`.
+    /// Use [`seek_ti`](Self::seek_to) if this is desired.
+    pub fn set_seek_time(&mut self, seek_time: f32) -> &mut Self {
+        self.last_seek_time = Some(seek_time);
+        self.seek_time = seek_time;
+        self
+    }
+
+    /// Seeks to a specific time in the animation.
+    ///
+    /// Note that any events between the current time and `seek_time`
+    /// will be triggered on the next update.
+    /// Use [`set_seek_time`](Self::set_seek_time) if this is undisered.
     pub fn seek_to(&mut self, seek_time: f32) -> &mut Self {
         self.last_seek_time = Some(self.seek_time);
         self.seek_time = seek_time;
@@ -718,7 +738,12 @@ impl ActiveAnimation {
     }
 
     /// Seeks to the beginning of the animation.
+    ///
+    /// Note that any events between the current time and `0.0`
+    /// will be triggered on the next update.
+    /// Use [`set_seek_time`](Self::set_seek_time) if this is undisered.
     pub fn rewind(&mut self) -> &mut Self {
+        self.last_seek_time = Some(self.seek_time);
         self.seek_time = 0.0;
         self
     }
@@ -934,11 +959,13 @@ fn trigger_untargeted_animation_events(
                 continue;
             };
 
-            let Some(triggered_events) = TriggeredEvents::new(None, clip, active_animation) else {
+            let Some(triggered_events) =
+                TriggeredEvents::from_animation(AnimationEventTarget::Root, clip, active_animation)
+            else {
                 continue;
             };
 
-            for AnimationEventKey { time, event } in triggered_events.iter() {
+            for TimedAnimationEvent { time, event } in triggered_events.iter() {
                 commands.queue(trigger_animation_event(
                     entity,
                     *time,
@@ -1114,12 +1141,15 @@ pub fn animate_targets(
                         };
 
                         // Trigger all animation events that occurred this tick, if any.
-                        if let Some(triggered_events) =
-                            TriggeredEvents::new(Some(target_id), clip, active_animation)
-                        {
+                        if let Some(triggered_events) = TriggeredEvents::from_animation(
+                            AnimationEventTarget::Node(target_id),
+                            clip,
+                            active_animation,
+                        ) {
                             if !triggered_events.is_empty() {
                                 par_commands.command_scope(move |mut commands| {
-                                    for AnimationEventKey { time, event } in triggered_events.iter()
+                                    for TimedAnimationEvent { time, event } in
+                                        triggered_events.iter()
                                     {
                                         commands.queue(trigger_animation_event(
                                             entity,
@@ -1327,17 +1357,17 @@ impl AnimationEvaluationState {
 #[derive(Debug, Clone)]
 struct TriggeredEvents<'a> {
     direction: TriggeredEventsDir,
-    lower: &'a [AnimationEventKey],
-    upper: &'a [AnimationEventKey],
+    lower: &'a [TimedAnimationEvent],
+    upper: &'a [TimedAnimationEvent],
 }
 
 impl<'a> TriggeredEvents<'a> {
-    fn new(
-        target_id: Option<AnimationTargetId>,
+    fn from_animation(
+        target: AnimationEventTarget,
         clip: &'a AnimationClip,
         active_animation: &ActiveAnimation,
     ) -> Option<Self> {
-        let events = clip.events.get(&target_id)?;
+        let events = clip.events.get(&target)?;
         let reverse = active_animation.is_playback_reversed();
         let is_finished = active_animation.is_finished();
 
@@ -1443,20 +1473,20 @@ enum TriggeredEventsDir {
 
 #[derive(Debug, Clone)]
 enum TriggeredEventsIter<'a> {
-    Forward(slice::Iter<'a, AnimationEventKey>),
-    Reverse(iter::Rev<slice::Iter<'a, AnimationEventKey>>),
+    Forward(slice::Iter<'a, TimedAnimationEvent>),
+    Reverse(iter::Rev<slice::Iter<'a, TimedAnimationEvent>>),
     ForwardLooping {
-        upper: slice::Iter<'a, AnimationEventKey>,
-        lower: slice::Iter<'a, AnimationEventKey>,
+        upper: slice::Iter<'a, TimedAnimationEvent>,
+        lower: slice::Iter<'a, TimedAnimationEvent>,
     },
     ReverseLooping {
-        lower: iter::Rev<slice::Iter<'a, AnimationEventKey>>,
-        upper: iter::Rev<slice::Iter<'a, AnimationEventKey>>,
+        lower: iter::Rev<slice::Iter<'a, TimedAnimationEvent>>,
+        upper: iter::Rev<slice::Iter<'a, TimedAnimationEvent>>,
     },
 }
 
 impl<'a> Iterator for TriggeredEventsIter<'a> {
-    type Item = &'a AnimationEventKey;
+    type Item = &'a TimedAnimationEvent;
 
     fn next(&mut self) -> Option<Self::Item> {
         match self {
@@ -1491,7 +1521,9 @@ mod tests {
         clip: &AnimationClip,
         expected: impl Into<Vec<f32>>,
     ) {
-        let Some(events) = TriggeredEvents::new(None, clip, active_animation) else {
+        let Some(events) =
+            TriggeredEvents::from_animation(AnimationEventTarget::Root, clip, active_animation)
+        else {
             assert_eq!(expected.into(), Vec::<f32>::new());
             return;
         };

From 6d8703c8c23289e1ae7c5fbc2a50dee13a046e45 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Fri, 4 Oct 2024 23:24:08 +0200
Subject: [PATCH 75/89] remove pub(crate)

---
 crates/bevy_animation/src/lib.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 5118a8d1fa538..3d354139eb778 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -287,18 +287,18 @@ pub struct AnimationClip {
 }
 
 #[derive(Reflect, Debug, Clone)]
-pub(crate) struct TimedAnimationEvent {
+struct TimedAnimationEvent {
     time: f32,
     event: AnimationEventData,
 }
 
 #[derive(Reflect, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone)]
-pub(crate) enum AnimationEventTarget {
+enum AnimationEventTarget {
     Root,
     Node(AnimationTargetId),
 }
 
-pub(crate) type AnimationEvents = HashMap<AnimationEventTarget, Vec<TimedAnimationEvent>>;
+type AnimationEvents = HashMap<AnimationEventTarget, Vec<TimedAnimationEvent>>;
 
 /// A mapping from [`AnimationTargetId`] (e.g. bone in a skinned mesh) to the
 /// animation curves.

From f8c2de07dd80d6596d0fde8f114cc755bfdb10a6 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Fri, 4 Oct 2024 23:37:50 +0200
Subject: [PATCH 76/89] typo

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

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 3d354139eb778..4d6cb9c8e8dbd 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -719,7 +719,7 @@ impl ActiveAnimation {
     /// Seeks to a specific time in the animation.
     ///
     /// This will not trigger events between the current time and `seek_time`.
-    /// Use [`seek_ti`](Self::seek_to) if this is desired.
+    /// Use [`seek_to`](Self::seek_to) if this is desired.
     pub fn set_seek_time(&mut self, seek_time: f32) -> &mut Self {
         self.last_seek_time = Some(seek_time);
         self.seek_time = seek_time;

From 299355caf815999f1e5550f5ce72f44c65188f2e Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Fri, 4 Oct 2024 23:47:38 +0200
Subject: [PATCH 77/89] disable jumping input while jumping

---
 examples/animation/bunny_detective.rs | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/examples/animation/bunny_detective.rs b/examples/animation/bunny_detective.rs
index 995965f85b726..fdb23d9aa229c 100644
--- a/examples/animation/bunny_detective.rs
+++ b/examples/animation/bunny_detective.rs
@@ -70,6 +70,9 @@ impl Default for BoneTargets {
     }
 }
 
+#[derive(Component)]
+struct Jumping;
+
 #[derive(Event, AnimationEvent, Reflect, Clone)]
 #[reflect(AnimationEvent)]
 struct OnJumped;
@@ -83,6 +86,8 @@ impl OnJumped {
         transforms: Query<&GlobalTransform>,
         mut text_visibility: Single<&mut Visibility, With<Text>>,
     ) {
+        commands.entity(trigger.entity()).insert(Jumping);
+
         // Hide instructions text.
         *text_visibility.as_mut() = Visibility::Hidden;
 
@@ -135,6 +140,8 @@ impl OnLanded {
         mut text_visibility: Single<&mut Visibility, With<Text>>,
         transforms: Query<&GlobalTransform>,
     ) {
+        commands.entity(trigger.entity()).remove::<Jumping>();
+
         // Transition to the `walk` animation.
         let (mut player, mut transitions) = animation_players.get_mut(trigger.entity()).unwrap();
         transitions
@@ -339,7 +346,7 @@ fn setup_scene_once_loaded(
 fn jump_input(
     keyboard_input: Res<ButtonInput<KeyCode>>,
     animations: Res<Animations>,
-    mut players: Query<(&mut AnimationPlayer, &mut AnimationTransitions)>,
+    mut players: Query<(&mut AnimationPlayer, &mut AnimationTransitions), Without<Jumping>>,
 ) {
     for (mut player, mut transitions) in &mut players {
         if keyboard_input.just_pressed(KeyCode::Space) {

From e0203d38d0e78402cf9074b4d0e0bde7b9620acb Mon Sep 17 00:00:00 2001
From: poopy <gonesbird@gmail.com>
Date: Sat, 5 Oct 2024 00:09:38 +0200
Subject: [PATCH 78/89] Update crates/bevy_animation/src/lib.rs

Co-authored-by: Chris Biscardi <chris@christopherbiscardi.com>
---
 crates/bevy_animation/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 4d6cb9c8e8dbd..5dcaf903d6eb1 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -1371,7 +1371,7 @@ impl<'a> TriggeredEvents<'a> {
         let reverse = active_animation.is_playback_reversed();
         let is_finished = active_animation.is_finished();
 
-        // Return eatly if the animation have finished on a previous tick.
+        // Return early if the animation have finished on a previous tick.
         if is_finished && !active_animation.just_completed {
             return None;
         }

From 14a330263a1c61967eb0cd448ab969e308817dd0 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Sat, 5 Oct 2024 00:21:10 +0200
Subject: [PATCH 79/89] add data to event in `animation_events.rs`

---
 examples/animation/animation_events.rs | 40 ++++++++++++++------------
 1 file changed, 22 insertions(+), 18 deletions(-)

diff --git a/examples/animation/animation_events.rs b/examples/animation/animation_events.rs
index 98ad9b99744bd..92cda0133be62 100644
--- a/examples/animation/animation_events.rs
+++ b/examples/animation/animation_events.rs
@@ -9,7 +9,7 @@ use bevy::{
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
-        .add_event::<Say>()
+        .add_event::<MessageEvent>()
         .add_systems(Startup, setup)
         .add_systems(PreUpdate, (animate_text_opacity, edit_message))
         .run();
@@ -20,36 +20,28 @@ struct MessageText;
 
 #[derive(Event, Reflect, Clone)]
 #[reflect(AnimationEvent)]
-enum Say {
-    Hello,
-    Bye,
+struct MessageEvent {
+    value: String,
+    color: Color,
 }
 
 // AnimationEvent can also be derived, but doing so will
 // trigger it as an observer event which runs in PostUpdate.
 // We need to set the message text before that so it is
 // updated before rendering without a one frame delay.
-impl AnimationEvent for Say {
+impl AnimationEvent for MessageEvent {
     fn trigger(&self, _time: f32, _weight: f32, _entity: Entity, world: &mut World) {
         world.send_event(self.clone());
     }
 }
 
 fn edit_message(
-    mut event_reader: EventReader<Say>,
+    mut event_reader: EventReader<MessageEvent>,
     mut text: Single<&mut Text, With<MessageText>>,
 ) {
     for event in event_reader.read() {
-        match event {
-            Say::Hello => {
-                text.sections[0].value = "HELLO".into();
-                text.sections[0].style.color = ALICE_BLUE.into();
-            }
-            Say::Bye => {
-                text.sections[0].value = "BYE".into();
-                text.sections[0].style.color = CRIMSON.into();
-            }
-        }
+        text.sections[0].value = event.value.clone();
+        text.sections[0].style.color = event.color;
     }
 }
 
@@ -98,8 +90,20 @@ fn setup(
     animation.set_duration(2.0);
 
     // Add events at the specified time.
-    animation.add_event(0.0, Say::Hello);
-    animation.add_event(1.0, Say::Bye);
+    animation.add_event(
+        0.0,
+        MessageEvent {
+            value: "HELLO".into(),
+            color: ALICE_BLUE.into(),
+        },
+    );
+    animation.add_event(
+        1.0,
+        MessageEvent {
+            value: "BYE".into(),
+            color: CRIMSON.into(),
+        },
+    );
 
     // Create the animation graph.
     let (graph, animation_index) = AnimationGraph::from_clip(animations.add(animation));

From 249d49b008919390288c4d8a5c330d8606091c42 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Sat, 5 Oct 2024 02:26:59 +0200
Subject: [PATCH 80/89] rip buntective :(

---
 Cargo.toml                            |  11 -
 assets/models/animated/buntective.glb | Bin 300680 -> 0 bytes
 examples/README.md                    |   1 -
 examples/animation/animated_fox.rs    | 195 ++++++++++-
 examples/animation/bunny_detective.rs | 455 --------------------------
 5 files changed, 192 insertions(+), 470 deletions(-)
 delete mode 100644 assets/models/animated/buntective.glb
 delete mode 100644 examples/animation/bunny_detective.rs

diff --git a/Cargo.toml b/Cargo.toml
index 3bff9c45c4783..84b04755e7af1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1188,17 +1188,6 @@ doc-scrape-examples = true
 hidden = true
 
 # Animation
-[[example]]
-name = "bunny_detective"
-path = "examples/animation/bunny_detective.rs"
-doc-scrape-examples = true
-
-[package.metadata.example.bunny_detective]
-name = "Bunny Detective"
-description = "Demonstrate how to use animation events with an animated character"
-category = "Animation"
-wasm = true
-
 [[example]]
 name = "animation_events"
 path = "examples/animation/animation_events.rs"
diff --git a/assets/models/animated/buntective.glb b/assets/models/animated/buntective.glb
deleted file mode 100644
index fa89960b2287c0bb419763cc02c24d6d2fff05c4..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 300680
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%0A9enI|GaL<Z<%6UH7eg<gx`z$6vFQ{6mmqFqI~gt
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

diff --git a/examples/README.md b/examples/README.md
index 60cd1da74d3ff..1e2d56cf15920 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -196,7 +196,6 @@ Example | Description
 [Animation Events](../examples/animation/animation_events.rs) | Demonstrate how to use animation events
 [Animation Graph](../examples/animation/animation_graph.rs) | Blends multiple animations together with a graph
 [Animation Masks](../examples/animation/animation_masks.rs) | Demonstrates animation masks
-[Bunny Detective](../examples/animation/bunny_detective.rs) | Demonstrate how to use animation events with an animated character
 [Color animation](../examples/animation/color_animation.rs) | Demonstrates how to animate colors using mixing and splines in different color spaces
 [Cubic Curve](../examples/animation/cubic_curve.rs) | Bezier curve example showing a cube following a cubic curve
 [Custom Skinned Mesh](../examples/animation/custom_skinned_mesh.rs) | Skinned mesh example with mesh and joints data defined in code
diff --git a/examples/animation/animated_fox.rs b/examples/animation/animated_fox.rs
index 73a662526e190..590284fae8eeb 100644
--- a/examples/animation/animated_fox.rs
+++ b/examples/animation/animated_fox.rs
@@ -3,10 +3,12 @@
 use std::{f32::consts::PI, time::Duration};
 
 use bevy::{
-    animation::{animate_targets, RepeatAnimation},
+    animation::{animate_targets, AnimationTargetId, RepeatAnimation},
+    color::palettes::css::WHITE,
     pbr::CascadeShadowConfigBuilder,
     prelude::*,
 };
+use rand::{thread_rng, Rng};
 
 const FOX_PATH: &str = "models/animated/Fox.glb";
 
@@ -17,19 +19,51 @@ fn main() {
             brightness: 2000.,
         })
         .add_plugins(DefaultPlugins)
+        .init_resource::<ParticleAssets>()
+        .init_resource::<FoxFeetTargets>()
         .add_systems(Startup, setup)
         .add_systems(Update, setup_scene_once_loaded.before(animate_targets))
-        .add_systems(Update, keyboard_animation_control)
+        .add_systems(Update, (keyboard_animation_control, simulate_particles))
+        .observe(OnStep::observer)
         .run();
 }
 
 #[derive(Resource)]
 struct Animations {
     animations: Vec<AnimationNodeIndex>,
-    #[allow(dead_code)]
     graph: Handle<AnimationGraph>,
 }
 
+#[derive(Event, AnimationEvent, Reflect, Clone)]
+#[reflect(AnimationEvent)]
+struct OnStep;
+
+impl OnStep {
+    fn observer(
+        trigger: Trigger<Self>,
+        particle: Res<ParticleAssets>,
+        mut commands: Commands,
+        transforms: Query<&GlobalTransform>,
+    ) {
+        let translation = transforms.get(trigger.entity()).unwrap().translation();
+        let mut rng = thread_rng();
+        // Spawn a bunch of particles.
+        for _ in 0..14 {
+            let horizontal = rng.gen::<Dir2>() * rng.gen_range(8.0..12.0);
+            let vertical = rng.gen_range(0.0..4.0);
+            let size = rng.gen_range(0.2..1.0);
+            commands.queue(spawn_particle(
+                particle.mesh.clone(),
+                particle.material.clone(),
+                translation.reject_from_normalized(Vec3::Y),
+                rng.gen_range(0.2..0.6),
+                size,
+                Vec3::new(horizontal.x, vertical, horizontal.y) * 10.0,
+            ));
+        }
+    }
+}
+
 fn setup(
     mut commands: Commands,
     asset_server: Res<AssetServer>,
@@ -98,9 +132,32 @@ fn setup(
 fn setup_scene_once_loaded(
     mut commands: Commands,
     animations: Res<Animations>,
+    feet: Res<FoxFeetTargets>,
+    graphs: Res<Assets<AnimationGraph>>,
+    mut clips: ResMut<Assets<AnimationClip>>,
     mut players: Query<(Entity, &mut AnimationPlayer), Added<AnimationPlayer>>,
 ) {
+    fn get_clip<'a>(
+        node: AnimationNodeIndex,
+        graph: &AnimationGraph,
+        clips: &'a mut Assets<AnimationClip>,
+    ) -> &'a mut AnimationClip {
+        let node = graph.get(node).unwrap();
+        let clip = node.clip.as_ref().and_then(|id| clips.get_mut(id)).unwrap();
+        clip
+    }
+
     for (entity, mut player) in &mut players {
+        let graph = graphs.get(&animations.graph).unwrap();
+
+        // Send `OnStep` events once the fox feet hits the ground
+        // in the running animation.
+        let running_animation = get_clip(animations.animations[0], graph, &mut clips);
+        running_animation.add_event_to_target(feet.front_left, 0.625, OnStep);
+        running_animation.add_event_to_target(feet.front_right, 0.5, OnStep);
+        running_animation.add_event_to_target(feet.back_left, 0.0, OnStep);
+        running_animation.add_event_to_target(feet.back_right, 0.125, OnStep);
+
         let mut transitions = AnimationTransitions::new();
 
         // Make sure to start the animation via the `AnimationTransitions`
@@ -201,3 +258,135 @@ fn keyboard_animation_control(
         }
     }
 }
+
+fn simulate_particles(
+    mut commands: Commands,
+    mut query: Query<(Entity, &mut Transform, &mut Particle)>,
+    time: Res<Time>,
+) {
+    for (entity, mut transform, mut particle) in &mut query {
+        if particle.lifeteime_timer.tick(time.delta()).just_finished() {
+            commands.entity(entity).despawn();
+        } else {
+            transform.translation += particle.velocity * time.delta_seconds();
+            transform.scale =
+                Vec3::splat(particle.size.lerp(0.0, particle.lifeteime_timer.fraction()));
+            particle
+                .velocity
+                .smooth_nudge(&Vec3::ZERO, 4.0, time.delta_seconds());
+        }
+        if transform.scale.length_squared() < 0.01 {}
+    }
+}
+
+fn spawn_particle<M: Material>(
+    mesh: Handle<Mesh>,
+    material: Handle<M>,
+    translation: Vec3,
+    lifetime: f32,
+    size: f32,
+    velocity: Vec3,
+) -> impl Command {
+    move |world: &mut World| {
+        world.spawn((
+            Particle {
+                lifeteime_timer: Timer::from_seconds(lifetime, TimerMode::Once),
+                size,
+                velocity,
+            },
+            Mesh3d(mesh),
+            MeshMaterial3d(material),
+            Transform {
+                translation,
+                scale: Vec3::splat(size),
+                ..Default::default()
+            },
+        ));
+    }
+}
+
+#[derive(Component)]
+struct Particle {
+    lifeteime_timer: Timer,
+    size: f32,
+    velocity: Vec3,
+}
+
+#[derive(Resource)]
+struct ParticleAssets {
+    mesh: Handle<Mesh>,
+    material: Handle<StandardMaterial>,
+}
+
+impl FromWorld for ParticleAssets {
+    fn from_world(world: &mut World) -> Self {
+        Self {
+            mesh: world.resource_mut::<Assets<Mesh>>().add(Sphere::new(10.0)),
+            material: world
+                .resource_mut::<Assets<StandardMaterial>>()
+                .add(StandardMaterial {
+                    base_color: WHITE.into(),
+                    ..Default::default()
+                }),
+        }
+    }
+}
+
+#[derive(Resource)]
+struct FoxFeetTargets {
+    front_right: AnimationTargetId,
+    front_left: AnimationTargetId,
+    back_left: AnimationTargetId,
+    back_right: AnimationTargetId,
+}
+
+impl Default for FoxFeetTargets {
+    fn default() -> Self {
+        // Get the id's of the feet and store them in a resource.
+        let hip_node = ["root", "_rootJoint", "b_Root_00", "b_Hip_01"];
+        let front_left_foot = hip_node.iter().chain(
+            [
+                "b_Spine01_02",
+                "b_Spine02_03",
+                "b_LeftUpperArm_09",
+                "b_LeftForeArm_010",
+                "b_LeftHand_011",
+            ]
+            .iter(),
+        );
+        let front_right_foot = hip_node.iter().chain(
+            [
+                "b_Spine01_02",
+                "b_Spine02_03",
+                "b_RightUpperArm_06",
+                "b_RightForeArm_07",
+                "b_RightHand_08",
+            ]
+            .iter(),
+        );
+        let back_left_foot = hip_node.iter().chain(
+            [
+                "b_LeftLeg01_015",
+                "b_LeftLeg02_016",
+                "b_LeftFoot01_017",
+                "b_LeftFoot02_018",
+            ]
+            .iter(),
+        );
+        let back_right_foot = hip_node.iter().chain(
+            [
+                "b_RightLeg01_019",
+                "b_RightLeg02_020",
+                "b_RightFoot01_021",
+                "b_RightFoot02_022",
+            ]
+            .iter(),
+        );
+        Self {
+            front_left: AnimationTargetId::from_iter(front_left_foot),
+            front_right: AnimationTargetId::from_iter(front_right_foot),
+            back_left: AnimationTargetId::from_iter(back_left_foot),
+            back_right: AnimationTargetId::from_iter(back_right_foot),
+        }
+    }
+}
diff --git a/examples/animation/bunny_detective.rs b/examples/animation/bunny_detective.rs
deleted file mode 100644
index fdb23d9aa229c..0000000000000
--- a/examples/animation/bunny_detective.rs
+++ /dev/null
@@ -1,455 +0,0 @@
-//! Demonstrate how to use animation events with an animated character.
-
-use std::{f32::consts::PI, time::Duration};
-
-use bevy::{
-    animation::AnimationTargetId,
-    color::palettes::css::{ALICE_BLUE, WHITE},
-    pbr::CascadeShadowConfigBuilder,
-    prelude::*,
-};
-use rand::{thread_rng, Rng};
-
-const DETECTIVE_PATH: &str = "models/animated/buntective.glb";
-
-fn main() {
-    App::new()
-        .register_type::<(OnLanded, OnJumped, OnStep)>()
-        .add_plugins(DefaultPlugins)
-        .insert_resource(AmbientLight {
-            color: ALICE_BLUE.into(),
-            brightness: 2000.,
-        })
-        .init_resource::<ParticleAssets>()
-        .init_resource::<BoneTargets>()
-        .add_systems(Startup, (setup, setup_instructions))
-        .add_systems(
-            Update,
-            (setup_scene_once_loaded, jump_input, simulate_particles),
-        )
-        .observe(OnLanded::observer)
-        .observe(OnJumped::observer)
-        .observe(OnStep::observer)
-        .run();
-}
-
-#[derive(Resource)]
-struct Animations {
-    walk: AnimationNodeIndex,
-    jump: AnimationNodeIndex,
-    graph: Handle<AnimationGraph>,
-}
-
-#[derive(Resource)]
-struct BoneTargets {
-    root: AnimationTargetId,
-    right_foot: AnimationTargetId,
-    left_foot: AnimationTargetId,
-}
-
-impl Default for BoneTargets {
-    fn default() -> Self {
-        // Store the id's of the bones we want to add events to for later use.
-        Self {
-            root: AnimationTargetId::from_iter(["Bunny"]),
-            right_foot: AnimationTargetId::from_iter([
-                "Bunny",
-                "pelvis",
-                "upperleg.r",
-                "lowerleg.r",
-                "foot.r",
-            ]),
-            left_foot: AnimationTargetId::from_iter([
-                "Bunny",
-                "pelvis",
-                "upperleg.l",
-                "lowerleg.l",
-                "foot.l",
-            ]),
-        }
-    }
-}
-
-#[derive(Component)]
-struct Jumping;
-
-#[derive(Event, AnimationEvent, Reflect, Clone)]
-#[reflect(AnimationEvent)]
-struct OnJumped;
-
-impl OnJumped {
-    // Spawn particles once the detective jumps.
-    fn observer(
-        trigger: Trigger<Self>,
-        mut commands: Commands,
-        particle: Res<ParticleAssets>,
-        transforms: Query<&GlobalTransform>,
-        mut text_visibility: Single<&mut Visibility, With<Text>>,
-    ) {
-        commands.entity(trigger.entity()).insert(Jumping);
-
-        // Hide instructions text.
-        *text_visibility.as_mut() = Visibility::Hidden;
-
-        let translation = transforms.get(trigger.entity()).unwrap().translation();
-        let mut rng = thread_rng();
-
-        // Spawn particle upward burst
-        for _ in 0..5 {
-            let horizontal = rng.gen::<Dir2>() * rng.gen_range(0.0..0.2);
-            let vertical = rng.gen_range(0.0..10.0);
-            let size = rng.gen_range(0.5..1.0);
-            commands.queue(spawn_particle(
-                particle.mesh.clone(),
-                particle.material.clone(),
-                translation.reject_from_normalized(Vec3::Y),
-                rng.gen_range(0.1..0.5),
-                size,
-                Vec3::new(horizontal.x, vertical, horizontal.y),
-            ));
-        }
-        // Spawn particle horizontal burst
-        for _ in 0..20 {
-            let horizontal = rng.gen::<Dir2>() * rng.gen_range(6.0..8.0);
-            let vertical = rng.gen_range(0.0..2.0);
-            let size = rng.gen_range(0.5..1.0);
-            commands.queue(spawn_particle(
-                particle.mesh.clone(),
-                particle.material.clone(),
-                translation.reject_from_normalized(Vec3::Y),
-                rng.gen_range(0.5..1.0),
-                size,
-                Vec3::new(horizontal.x, vertical, horizontal.y),
-            ));
-        }
-    }
-}
-
-#[derive(Event, AnimationEvent, Reflect, Clone)]
-#[reflect(AnimationEvent)]
-struct OnLanded;
-
-impl OnLanded {
-    // Spawn particles once the detective lands.
-    fn observer(
-        trigger: Trigger<Self>,
-        mut commands: Commands,
-        particle: Res<ParticleAssets>,
-        animations: Res<Animations>,
-        mut animation_players: Query<(&mut AnimationPlayer, &mut AnimationTransitions)>,
-        mut text_visibility: Single<&mut Visibility, With<Text>>,
-        transforms: Query<&GlobalTransform>,
-    ) {
-        commands.entity(trigger.entity()).remove::<Jumping>();
-
-        // Transition to the `walk` animation.
-        let (mut player, mut transitions) = animation_players.get_mut(trigger.entity()).unwrap();
-        transitions
-            .play(&mut player, animations.walk, Duration::from_secs_f32(0.8))
-            .repeat();
-
-        // Show instructions text.
-        **text_visibility = Visibility::Visible;
-
-        let translation = transforms.get(trigger.entity()).unwrap().translation();
-        let mut rng = thread_rng();
-        for _ in 0..25 {
-            let horizontal = rng.gen::<Dir2>() * rng.gen_range(8.0..12.0);
-            let vertical = rng.gen_range(0.0..4.0);
-            let size = rng.gen_range(0.5..1.0);
-            commands.queue(spawn_particle(
-                particle.mesh.clone(),
-                particle.material.clone(),
-                translation.reject_from_normalized(Vec3::Y),
-                rng.gen_range(0.5..1.0),
-                size,
-                Vec3::new(horizontal.x, vertical, horizontal.y),
-            ));
-        }
-    }
-}
-
-#[derive(Event, AnimationEvent, Resource, Reflect, Clone)]
-#[reflect(AnimationEvent)]
-enum OnStep {
-    Start,
-    End,
-}
-
-impl OnStep {
-    // Spawn particles on each step the detective takes.
-    fn observer(
-        trigger: Trigger<Self>,
-        mut commands: Commands,
-        particle: Res<ParticleAssets>,
-        transforms: Query<&GlobalTransform>,
-    ) {
-        let translation = transforms.get(trigger.entity()).unwrap().translation();
-        let mut rng = thread_rng();
-        for _ in 0..25 {
-            let velocity = match trigger.event() {
-                OnStep::Start => {
-                    let horizontal = rng.gen::<Dir2>() * rng.gen_range(1.0..2.0);
-                    let vertical = rng.gen_range(0.0..2.0);
-                    Vec3::new(horizontal.x, vertical, horizontal.y)
-                }
-                OnStep::End => Vec3::new(
-                    rng.gen_range(-0.2..0.2),
-                    rng.gen_range(0.0..2.0),
-                    -rng.gen_range(0.0..10.0),
-                ),
-            };
-            commands.queue(spawn_particle(
-                particle.mesh.clone(),
-                particle.material.clone(),
-                translation.reject_from_normalized(Vec3::Y),
-                rng.gen_range(0.1..0.5),
-                rng.gen_range(0.1..1.0),
-                velocity,
-            ));
-        }
-    }
-}
-
-fn setup(
-    mut commands: Commands,
-    asset_server: Res<AssetServer>,
-    mut meshes: ResMut<Assets<Mesh>>,
-    mut materials: ResMut<Assets<StandardMaterial>>,
-    mut graphs: ResMut<Assets<AnimationGraph>>,
-) {
-    // Build the animation graph
-    let (graph, node_indices) = AnimationGraph::from_clips([
-        asset_server.load(GltfAssetLabel::Animation(0).from_asset(DETECTIVE_PATH)), // walk animation
-        asset_server.load(GltfAssetLabel::Animation(2).from_asset(DETECTIVE_PATH)), // jump animation
-    ]);
-
-    // Insert a resource with the current scene information
-    let graph_handle = graphs.add(graph);
-    commands.insert_resource(Animations {
-        walk: node_indices[0],
-        jump: node_indices[1],
-        graph: graph_handle,
-    });
-
-    // Camera
-    commands.spawn(Camera3dBundle {
-        transform: Transform::from_xyz(2.0, 3.0, 5.0).looking_at(Vec3::new(0.0, 1.5, 0.0), Vec3::Y),
-        camera: Camera {
-            clear_color: ClearColorConfig::Custom(ALICE_BLUE.into()),
-            ..Default::default()
-        },
-        ..default()
-    });
-
-    // Plane
-    commands.spawn((
-        Mesh3d(meshes.add(Plane3d::default().mesh().size(500000.0, 500000.0))),
-        MeshMaterial3d(materials.add(Color::srgb(0.3, 0.5, 0.3))),
-    ));
-
-    // Light
-    commands.spawn((
-        Transform::from_rotation(Quat::from_euler(EulerRot::ZYX, 0.0, 1.0, -PI / 4.)),
-        DirectionalLight {
-            shadows_enabled: true,
-            ..default()
-        },
-        CascadeShadowConfigBuilder {
-            first_cascade_far_bound: 2.0,
-            maximum_distance: 10.0,
-            ..default()
-        }
-        .build(),
-    ));
-
-    // Bunny Detective
-    commands.spawn(SceneRoot(
-        asset_server.load(GltfAssetLabel::Scene(0).from_asset(DETECTIVE_PATH)),
-    ));
-
-    println!("Controls:");
-    println!("  - spacebar: jump");
-}
-
-// An `AnimationPlayer` is automatically added to the scene when it's ready.
-// When the player is added, start the `walk` animation and add the `OnLanded` event.
-fn setup_scene_once_loaded(
-    mut commands: Commands,
-    animations: Res<Animations>,
-    bones: Res<BoneTargets>,
-    graphs: Res<Assets<AnimationGraph>>,
-    mut clips: ResMut<Assets<AnimationClip>>,
-    mut players: Query<(Entity, &mut AnimationPlayer), Added<AnimationPlayer>>,
-) {
-    for (entity, mut player) in &mut players {
-        let graph = graphs.get(&animations.graph).unwrap();
-
-        let jump_node = graph.get(animations.jump).unwrap();
-        let jump_clip = jump_node
-            .clip
-            .as_ref()
-            .and_then(|id| clips.get_mut(id))
-            .unwrap();
-
-        // The jump height in the original animation is not very impressive :(
-        // make it a little bit higher.
-        jump_clip.add_curve_to_target(
-            bones.root,
-            TranslationCurve(
-                AnimatableKeyframeCurve::new([
-                    (0.0, Vec3::ZERO),
-                    (0.3, Vec3::Y * 0.5),
-                    (0.5, Vec3::ZERO),
-                ])
-                .unwrap(),
-            ),
-        );
-
-        jump_clip.add_event(0.0, OnJumped);
-        // Trigger the OnLanded event after 0.53s in the jump animation.
-        // The feet hits the ground between frame 8 and 9 in the animation
-        // and the frame rate of the animation is 16 fps: 8.5 / 16 = 5.3
-        jump_clip.add_event(0.53, OnLanded);
-
-        let walk_node = graph.get(animations.walk).unwrap();
-        let walk_clip = walk_node
-            .clip
-            .as_ref()
-            .and_then(|id| clips.get_mut(id))
-            .unwrap();
-
-        // Trigger OnStep events targeting the feet.
-        walk_clip.add_event_to_target(bones.left_foot, 0.05, OnStep::Start);
-        walk_clip.add_event_to_target(bones.left_foot, 0.5, OnStep::End);
-        walk_clip.add_event_to_target(bones.right_foot, 0.55, OnStep::Start);
-        walk_clip.add_event_to_target(bones.right_foot, 0.0, OnStep::End);
-
-        let mut transitions = AnimationTransitions::new();
-
-        // 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.walk, Duration::ZERO)
-            .repeat();
-
-        commands
-            .entity(entity)
-            .insert(animations.graph.clone())
-            .insert(transitions);
-    }
-}
-
-// Play the `jump` animation when the space bar is pressed.
-fn jump_input(
-    keyboard_input: Res<ButtonInput<KeyCode>>,
-    animations: Res<Animations>,
-    mut players: Query<(&mut AnimationPlayer, &mut AnimationTransitions), Without<Jumping>>,
-) {
-    for (mut player, mut transitions) in &mut players {
-        if keyboard_input.just_pressed(KeyCode::Space) {
-            transitions.play(&mut player, animations.jump, Duration::from_millis(75));
-        }
-    }
-}
-
-#[derive(Component)]
-struct Particle {
-    lifeteime_timer: Timer,
-    size: f32,
-    velocity: Vec3,
-}
-
-#[derive(Resource)]
-struct ParticleAssets {
-    mesh: Handle<Mesh>,
-    material: Handle<StandardMaterial>,
-}
-
-impl FromWorld for ParticleAssets {
-    fn from_world(world: &mut World) -> Self {
-        Self {
-            mesh: world.resource_mut::<Assets<Mesh>>().add(Sphere::new(0.25)),
-            material: world
-                .resource_mut::<Assets<StandardMaterial>>()
-                .add(StandardMaterial {
-                    base_color: WHITE.into(),
-                    ..Default::default()
-                }),
-        }
-    }
-}
-
-fn simulate_particles(
-    mut commands: Commands,
-    mut query: Query<(Entity, &mut Transform, &mut Particle)>,
-    time: Res<Time>,
-) {
-    for (entity, mut transform, mut particle) in &mut query {
-        if particle.lifeteime_timer.tick(time.delta()).just_finished() {
-            commands.entity(entity).despawn();
-        } else {
-            transform.translation += particle.velocity * time.delta_seconds();
-            transform.scale =
-                Vec3::splat(particle.size.lerp(0.0, particle.lifeteime_timer.fraction()));
-            particle
-                .velocity
-                .smooth_nudge(&Vec3::ZERO, 4.0, time.delta_seconds());
-        }
-        if transform.scale.length_squared() < 0.01 {}
-    }
-}
-
-fn spawn_particle<M: Material>(
-    mesh: Handle<Mesh>,
-    material: Handle<M>,
-    translation: Vec3,
-    lifetime: f32,
-    size: f32,
-    velocity: Vec3,
-) -> impl Command {
-    move |world: &mut World| {
-        world.spawn((
-            Particle {
-                lifeteime_timer: Timer::from_seconds(lifetime, TimerMode::Once),
-                size,
-                velocity,
-            },
-            Mesh3d(mesh),
-            MeshMaterial3d(material),
-            Transform {
-                translation,
-                scale: Vec3::splat(size),
-                ..Default::default()
-            },
-        ));
-    }
-}
-
-fn setup_instructions(mut commands: Commands) {
-    commands
-        .spawn(NodeBundle {
-            style: Style {
-                padding: UiRect::all(Val::Px(20.0)),
-                width: Val::Percent(100.0),
-                height: Val::Percent(100.0),
-                justify_content: JustifyContent::Center,
-                align_items: AlignItems::End,
-                ..Default::default()
-            },
-            ..Default::default()
-        })
-        .with_child(TextBundle {
-            text: Text::from_section(
-                "press spacebar to jump",
-                TextStyle {
-                    font_size: 40.0,
-                    color: ALICE_BLUE.into(),
-                    ..Default::default()
-                },
-            ),
-            ..Default::default()
-        });
-}

From a1b1f199b553c2d204385b8a7ded0b4db1e757bf Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Sat, 5 Oct 2024 02:39:17 +0200
Subject: [PATCH 81/89] ci fix

---
 crates/bevy_animation/src/lib.rs   | 5 ++++-
 examples/animation/animated_fox.rs | 7 +++++--
 2 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index cb432019af912..a687e7e4da689 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -951,7 +951,10 @@ fn trigger_untargeted_animation_events(
         for (index, active_animation) in player.active_animations.iter() {
             let Some(clip) = graph
                 .get(*index)
-                .and_then(|node| node.clip.as_ref())
+                .and_then(|node| match &node.node_type {
+                    AnimationNodeType::Clip(handle) => Some(handle),
+                    AnimationNodeType::Blend | AnimationNodeType::Add => None,
+                })
                 .and_then(|id| clips.get(id))
             else {
                 continue;
diff --git a/examples/animation/animated_fox.rs b/examples/animation/animated_fox.rs
index 590284fae8eeb..a5cd6383e6af6 100644
--- a/examples/animation/animated_fox.rs
+++ b/examples/animation/animated_fox.rs
@@ -143,8 +143,11 @@ fn setup_scene_once_loaded(
         clips: &'a mut Assets<AnimationClip>,
     ) -> &'a mut AnimationClip {
         let node = graph.get(node).unwrap();
-        let clip = node.clip.as_ref().and_then(|id| clips.get_mut(id)).unwrap();
-        clip
+        let clip = match &node.node_type {
+            AnimationNodeType::Clip(handle) => clips.get_mut(handle),
+            _ => unreachable!(),
+        };
+        clip.unwrap()
     }
 
     for (entity, mut player) in &mut players {

From e0f00713ec770c32c8c9149bebbc788af58dd9fa Mon Sep 17 00:00:00 2001
From: poopy <gonesbird@gmail.com>
Date: Sat, 5 Oct 2024 13:33:30 +0200
Subject: [PATCH 82/89] Update examples/animation/animated_fox.rs

Co-authored-by: Chris Biscardi <chris@christopherbiscardi.com>
---
 examples/animation/animated_fox.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/examples/animation/animated_fox.rs b/examples/animation/animated_fox.rs
index a5cd6383e6af6..fc157ec568908 100644
--- a/examples/animation/animated_fox.rs
+++ b/examples/animation/animated_fox.rs
@@ -39,6 +39,7 @@ struct Animations {
 struct OnStep;
 
 impl OnStep {
+    // The observer is not required to be defined in an impl block
     fn observer(
         trigger: Trigger<Self>,
         particle: Res<ParticleAssets>,

From 805c4fbadd27a941d3ff65dd4d14a149fe0b5c2e Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Sat, 5 Oct 2024 13:41:29 +0200
Subject: [PATCH 83/89] explain how to calculate event time

---
 examples/animation/animated_fox.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/examples/animation/animated_fox.rs b/examples/animation/animated_fox.rs
index a5cd6383e6af6..35887e6bd970c 100644
--- a/examples/animation/animated_fox.rs
+++ b/examples/animation/animated_fox.rs
@@ -153,9 +153,11 @@ fn setup_scene_once_loaded(
     for (entity, mut player) in &mut players {
         let graph = graphs.get(&animations.graph).unwrap();
 
-        // Send `OnStep` events once the fox feet hits the ground
-        // in the running animation.
+        // Send `OnStep` events once the fox feet hits the ground in the running animation.
         let running_animation = get_clip(animations.animations[0], graph, &mut clips);
+        // You can determine the time an event should trigger if you know witch frame it occurs and
+        // the frame rate of the animation. Let's say we want to trigger an event at frame 15,
+        // and the animation has a frame rate of 24 fps, then time = 15 / 24 = 0.625.
         running_animation.add_event_to_target(feet.front_left, 0.625, OnStep);
         running_animation.add_event_to_target(feet.front_right, 0.5, OnStep);
         running_animation.add_event_to_target(feet.back_left, 0.0, OnStep);

From 1b5b90386272c84171a0d8d650cc5e9226014f97 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Sat, 5 Oct 2024 13:53:17 +0200
Subject: [PATCH 84/89] observe_on_step

---
 examples/animation/animated_fox.rs | 47 ++++++++++++++----------------
 1 file changed, 22 insertions(+), 25 deletions(-)

diff --git a/examples/animation/animated_fox.rs b/examples/animation/animated_fox.rs
index 481fde78d8caa..f9bd97dbd9c1c 100644
--- a/examples/animation/animated_fox.rs
+++ b/examples/animation/animated_fox.rs
@@ -24,7 +24,7 @@ fn main() {
         .add_systems(Startup, setup)
         .add_systems(Update, setup_scene_once_loaded.before(animate_targets))
         .add_systems(Update, (keyboard_animation_control, simulate_particles))
-        .observe(OnStep::observer)
+        .observe(observe_on_step)
         .run();
 }
 
@@ -38,30 +38,27 @@ struct Animations {
 #[reflect(AnimationEvent)]
 struct OnStep;
 
-impl OnStep {
-    // The observer is not required to be defined in an impl block
-    fn observer(
-        trigger: Trigger<Self>,
-        particle: Res<ParticleAssets>,
-        mut commands: Commands,
-        transforms: Query<&GlobalTransform>,
-    ) {
-        let translation = transforms.get(trigger.entity()).unwrap().translation();
-        let mut rng = thread_rng();
-        // Spawn a bunch of particles.
-        for _ in 0..14 {
-            let horizontal = rng.gen::<Dir2>() * rng.gen_range(8.0..12.0);
-            let vertical = rng.gen_range(0.0..4.0);
-            let size = rng.gen_range(0.2..1.0);
-            commands.queue(spawn_particle(
-                particle.mesh.clone(),
-                particle.material.clone(),
-                translation.reject_from_normalized(Vec3::Y),
-                rng.gen_range(0.2..0.6),
-                size,
-                Vec3::new(horizontal.x, vertical, horizontal.y) * 10.0,
-            ));
-        }
+fn observe_on_step(
+    trigger: Trigger<OnStep>,
+    particle: Res<ParticleAssets>,
+    mut commands: Commands,
+    transforms: Query<&GlobalTransform>,
+) {
+    let translation = transforms.get(trigger.entity()).unwrap().translation();
+    let mut rng = thread_rng();
+    // Spawn a bunch of particles.
+    for _ in 0..14 {
+        let horizontal = rng.gen::<Dir2>() * rng.gen_range(8.0..12.0);
+        let vertical = rng.gen_range(0.0..4.0);
+        let size = rng.gen_range(0.2..1.0);
+        commands.queue(spawn_particle(
+            particle.mesh.clone(),
+            particle.material.clone(),
+            translation.reject_from_normalized(Vec3::Y),
+            rng.gen_range(0.2..0.6),
+            size,
+            Vec3::new(horizontal.x, vertical, horizontal.y) * 10.0,
+        ));
     }
 }
 

From 8e1d6ef0677fac92505540819bbcea57d53ebb68 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Sat, 5 Oct 2024 13:54:26 +0200
Subject: [PATCH 85/89] use required components

---
 examples/animation/animation_events.rs | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/examples/animation/animation_events.rs b/examples/animation/animation_events.rs
index 92cda0133be62..85e94a8af70b0 100644
--- a/examples/animation/animation_events.rs
+++ b/examples/animation/animation_events.rs
@@ -52,12 +52,10 @@ fn setup(
 ) {
     // Camera
     commands.spawn((
-        Camera2dBundle {
-            camera: Camera {
-                clear_color: ClearColorConfig::Custom(BLACK.into()),
-                hdr: true,
-                ..Default::default()
-            },
+        Camera2d,
+        Camera {
+            clear_color: ClearColorConfig::Custom(BLACK.into()),
+            hdr: true,
             ..Default::default()
         },
         Bloom {

From f00700a464ae126b2be5f466d6330601cb6b0ef1 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Sat, 5 Oct 2024 14:02:16 +0200
Subject: [PATCH 86/89] clarify that `time` is in seconds

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

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index a687e7e4da689..ce849d068952c 100755
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -460,7 +460,8 @@ impl AnimationClip {
 
     /// Add an [`AnimationEvent`] to an [`AnimationTarget`] named by an [`AnimationTargetId`].
     ///
-    /// The `event` will trigger on the entity matching the target once the `time` is reached in the animation.
+    /// The `event` will trigger on the entity matching the target once the `time` (in seconds)
+    /// is reached in the animation.
     ///
     /// Use [`add_event`](Self::add_event) instead if you don't have a specific target.
     pub fn add_event_to_target(
@@ -474,7 +475,8 @@ impl AnimationClip {
 
     /// Add a untargeted [`AnimationEvent`] to this [`AnimationClip`].
     ///
-    /// The `event` will trigger on the [`AnimationPlayer`] entity once the `time` is reached in the animation.
+    /// The `event` will trigger on the [`AnimationPlayer`] entity once the `time` (in seconds)
+    /// is reached in the animation.
     ///
     /// See also [`add_event_to_target`](Self::add_event_to_target).
     pub fn add_event(&mut self, time: f32, event: impl AnimationEvent) {

From a192f67ec0204c27bbe01239ece6c4ecfabe2631 Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Sat, 5 Oct 2024 14:06:14 +0200
Subject: [PATCH 87/89] runs -> triggered

---
 examples/animation/animation_events.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/animation/animation_events.rs b/examples/animation/animation_events.rs
index 85e94a8af70b0..95f73e89b5cbb 100644
--- a/examples/animation/animation_events.rs
+++ b/examples/animation/animation_events.rs
@@ -26,7 +26,7 @@ struct MessageEvent {
 }
 
 // AnimationEvent can also be derived, but doing so will
-// trigger it as an observer event which runs in PostUpdate.
+// trigger it as an observer event which is triggered in PostUpdate.
 // We need to set the message text before that so it is
 // updated before rendering without a one frame delay.
 impl AnimationEvent for MessageEvent {

From ea0294041c7f23ea23fe965427858dd0b56112bf Mon Sep 17 00:00:00 2001
From: rosefarts <gonesbird@gmail.com>
Date: Sat, 5 Oct 2024 14:25:36 +0200
Subject: [PATCH 88/89] `AnimationEvent` doc example

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

diff --git a/crates/bevy_animation/src/animation_event.rs b/crates/bevy_animation/src/animation_event.rs
index d923348bdcb97..825ad8e362f49 100644
--- a/crates/bevy_animation/src/animation_event.rs
+++ b/crates/bevy_animation/src/animation_event.rs
@@ -26,6 +26,43 @@ pub(crate) fn trigger_animation_event(
 /// It can be derived to trigger as an observer event,
 /// if you need more complex behaviour, consider
 /// a manual implementation.
+///
+/// # Example
+///
+/// ```rust
+/// # use bevy_animation::prelude::*;
+/// # use bevy_ecs::prelude::*;
+/// # use bevy_reflect::prelude::*;
+/// # use bevy_asset::prelude::*;
+/// #
+/// #[derive(Event, AnimationEvent, Reflect, Clone)]
+/// struct Say(String);
+///
+/// fn on_say(trigger: Trigger<Say>) {
+///     println!("{}", trigger.event().0);
+/// }
+///
+/// fn setup_animation(
+///     mut commands: Commands,
+///     mut animations: ResMut<Assets<AnimationClip>>,
+///     mut graphs: ResMut<Assets<AnimationGraph>>,
+/// ) {
+///     // Create a new animation and add an event at 1.0s.
+///     let mut animation = AnimationClip::default();
+///     animation.add_event(1.0, Say("Hello".into()));
+///     
+///     // Create an animation graph.
+///     let (graph, animation_index) = AnimationGraph::from_clip(animations.add(animation));
+///
+///     // Start playing the animation.
+///     let mut player = AnimationPlayer::default();
+///     player.play(animation_index).repeat();
+///     
+///     commands.spawn((graphs.add(graph), player));
+/// }
+/// #
+/// # bevy_ecs::system::assert_is_system(setup_animation);
+/// ```
 #[reflect_trait]
 pub trait AnimationEvent: CloneableAnimationEvent + Reflect + Send + Sync {
     /// Trigger the event, targeting `entity`.

From 83a219ed5086333f87e86410f9c54a2a3ea24b57 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fran=C3=A7ois=20Mockers?= <francois.mockers@vleue.com>
Date: Sun, 6 Oct 2024 11:53:10 +0200
Subject: [PATCH 89/89] Update examples/animation/animated_fox.rs

---
 examples/animation/animated_fox.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/examples/animation/animated_fox.rs b/examples/animation/animated_fox.rs
index f9bd97dbd9c1c..043565cf0d49c 100644
--- a/examples/animation/animated_fox.rs
+++ b/examples/animation/animated_fox.rs
@@ -277,7 +277,6 @@ fn simulate_particles(
                 .velocity
                 .smooth_nudge(&Vec3::ZERO, 4.0, time.delta_seconds());
         }
-        if transform.scale.length_squared() < 0.01 {}
     }
 }