Vendor dependencies for 0.3.0 release

vendor/bevy/examples/animation/animated_mesh.rs

@@ -0,0 +1,129 @@
+//! Plays an animation on a skinned glTF model of a fox.
+
+use std::f32::consts::PI;
+
+use bevy::{pbr::CascadeShadowConfigBuilder, prelude::*, scene::SceneInstanceReady};
+
+// An example asset that contains a mesh and animation.
+const GLTF_PATH: &str = "models/animated/Fox.glb";
+
+fn main() {
+    App::new()
+        .insert_resource(AmbientLight {
+            color: Color::WHITE,
+            brightness: 2000.,
+            ..default()
+        })
+        .add_plugins(DefaultPlugins)
+        .add_systems(Startup, setup_mesh_and_animation)
+        .add_systems(Startup, setup_camera_and_environment)
+        .run();
+}
+
+// A component that stores a reference to an animation we want to play. This is
+// created when we start loading the mesh (see `setup_mesh_and_animation`) and
+// read when the mesh has spawned (see `play_animation_once_loaded`).
+#[derive(Component)]
+struct AnimationToPlay {
+    graph_handle: Handle<AnimationGraph>,
+    index: AnimationNodeIndex,
+}
+
+fn setup_mesh_and_animation(
+    mut commands: Commands,
+    asset_server: Res<AssetServer>,
+    mut graphs: ResMut<Assets<AnimationGraph>>,
+) {
+    // Create an animation graph containing a single animation. We want the "run"
+    // animation from our example asset, which has an index of two.
+    let (graph, index) = AnimationGraph::from_clip(
+        asset_server.load(GltfAssetLabel::Animation(2).from_asset(GLTF_PATH)),
+    );
+
+    // Store the animation graph as an asset.
+    let graph_handle = graphs.add(graph);
+
+    // Create a component that stores a reference to our animation.
+    let animation_to_play = AnimationToPlay {
+        graph_handle,
+        index,
+    };
+
+    // Start loading the asset as a scene and store a reference to it in a
+    // SceneRoot component. This component will automatically spawn a scene
+    // containing our mesh once it has loaded.
+    let mesh_scene = SceneRoot(asset_server.load(GltfAssetLabel::Scene(0).from_asset(GLTF_PATH)));
+
+    // Spawn an entity with our components, and connect it to an observer that
+    // will trigger when the scene is loaded and spawned.
+    commands
+        .spawn((animation_to_play, mesh_scene))
+        .observe(play_animation_when_ready);
+}
+
+fn play_animation_when_ready(
+    trigger: Trigger<SceneInstanceReady>,
+    mut commands: Commands,
+    children: Query<&Children>,
+    animations_to_play: Query<&AnimationToPlay>,
+    mut players: Query<&mut AnimationPlayer>,
+) {
+    // The entity we spawned in `setup_mesh_and_animation` is the trigger's target.
+    // Start by finding the AnimationToPlay component we added to that entity.
+    if let Ok(animation_to_play) = animations_to_play.get(trigger.target()) {
+        // The SceneRoot component will have spawned the scene as a hierarchy
+        // of entities parented to our entity. Since the asset contained a skinned
+        // mesh and animations, it will also have spawned an animation player
+        // component. Search our entity's descendants to find the animation player.
+        for child in children.iter_descendants(trigger.target()) {
+            if let Ok(mut player) = players.get_mut(child) {
+                // Tell the animation player to start the animation and keep
+                // repeating it.
+                //
+                // If you want to try stopping and switching animations, see the
+                // `animated_mesh_control.rs` example.
+                player.play(animation_to_play.index).repeat();
+
+                // Add the animation graph. This only needs to be done once to
+                // connect the animation player to the mesh.
+                commands
+                    .entity(child)
+                    .insert(AnimationGraphHandle(animation_to_play.graph_handle.clone()));
+            }
+        }
+    }
+}
+
+// Spawn a camera and a simple environment with a ground plane and light.
+fn setup_camera_and_environment(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    // Camera
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(100.0, 100.0, 150.0).looking_at(Vec3::new(0.0, 20.0, 0.0), Vec3::Y),
+    ));
+
+    // 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: 200.0,
+            maximum_distance: 400.0,
+            ..default()
+        }
+        .build(),
+    ));
+}

vendor/bevy/examples/animation/animated_mesh_control.rs

@@ -0,0 +1,210 @@
+//! Plays animations from a skinned glTF.
+
+use std::{f32::consts::PI, time::Duration};
+
+use bevy::{animation::RepeatAnimation, pbr::CascadeShadowConfigBuilder, prelude::*};
+
+const FOX_PATH: &str = "models/animated/Fox.glb";
+
+fn main() {
+    App::new()
+        .insert_resource(AmbientLight {
+            color: Color::WHITE,
+            brightness: 2000.,
+            ..default()
+        })
+        .add_plugins(DefaultPlugins)
+        .add_systems(Startup, setup)
+        .add_systems(Update, setup_scene_once_loaded)
+        .add_systems(Update, keyboard_control)
+        .run();
+}
+
+#[derive(Resource)]
+struct Animations {
+    animations: Vec<AnimationNodeIndex>,
+    graph_handle: Handle<AnimationGraph>,
+}
+
+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(2).from_asset(FOX_PATH)),
+        asset_server.load(GltfAssetLabel::Animation(1).from_asset(FOX_PATH)),
+        asset_server.load(GltfAssetLabel::Animation(0).from_asset(FOX_PATH)),
+    ]);
+
+    // Keep our animation graph in a Resource so that it can be inserted onto
+    // the correct entity once the scene actually loads.
+    let graph_handle = graphs.add(graph);
+    commands.insert_resource(Animations {
+        animations: node_indices,
+        graph_handle,
+    });
+
+    // Camera
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(100.0, 100.0, 150.0).looking_at(Vec3::new(0.0, 20.0, 0.0), Vec3::Y),
+    ));
+
+    // 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: 200.0,
+            maximum_distance: 400.0,
+            ..default()
+        }
+        .build(),
+    ));
+
+    // Fox
+    commands.spawn(SceneRoot(
+        asset_server.load(GltfAssetLabel::Scene(0).from_asset(FOX_PATH)),
+    ));
+
+    // Instructions
+
+    commands.spawn((
+        Text::new(concat!(
+            "space: play / pause\n",
+            "up / down: playback speed\n",
+            "left / right: seek\n",
+            "1-3: play N times\n",
+            "L: loop forever\n",
+            "return: change animation\n",
+        )),
+        Node {
+            position_type: PositionType::Absolute,
+            top: Val::Px(12.0),
+            left: Val::Px(12.0),
+            ..default()
+        },
+    ));
+}
+
+// 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 players: Query<(Entity, &mut AnimationPlayer), Added<AnimationPlayer>>,
+) {
+    for (entity, mut player) in &mut players {
+        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.animations[0], Duration::ZERO)
+            .repeat();
+
+        commands
+            .entity(entity)
+            .insert(AnimationGraphHandle(animations.graph_handle.clone()))
+            .insert(transitions);
+    }
+}
+
+fn keyboard_control(
+    keyboard_input: Res<ButtonInput<KeyCode>>,
+    mut animation_players: Query<(&mut AnimationPlayer, &mut AnimationTransitions)>,
+    animations: Res<Animations>,
+    mut current_animation: Local<usize>,
+) {
+    for (mut player, mut transitions) in &mut animation_players {
+        let Some((&playing_animation_index, _)) = player.playing_animations().next() else {
+            continue;
+        };
+
+        if keyboard_input.just_pressed(KeyCode::Space) {
+            let playing_animation = player.animation_mut(playing_animation_index).unwrap();
+            if playing_animation.is_paused() {
+                playing_animation.resume();
+            } else {
+                playing_animation.pause();
+            }
+        }
+
+        if keyboard_input.just_pressed(KeyCode::ArrowUp) {
+            let playing_animation = player.animation_mut(playing_animation_index).unwrap();
+            let speed = playing_animation.speed();
+            playing_animation.set_speed(speed * 1.2);
+        }
+
+        if keyboard_input.just_pressed(KeyCode::ArrowDown) {
+            let playing_animation = player.animation_mut(playing_animation_index).unwrap();
+            let speed = playing_animation.speed();
+            playing_animation.set_speed(speed * 0.8);
+        }
+
+        if keyboard_input.just_pressed(KeyCode::ArrowLeft) {
+            let playing_animation = player.animation_mut(playing_animation_index).unwrap();
+            let elapsed = playing_animation.seek_time();
+            playing_animation.seek_to(elapsed - 0.1);
+        }
+
+        if keyboard_input.just_pressed(KeyCode::ArrowRight) {
+            let playing_animation = player.animation_mut(playing_animation_index).unwrap();
+            let elapsed = playing_animation.seek_time();
+            playing_animation.seek_to(elapsed + 0.1);
+        }
+
+        if keyboard_input.just_pressed(KeyCode::Enter) {
+            *current_animation = (*current_animation + 1) % animations.animations.len();
+
+            transitions
+                .play(
+                    &mut player,
+                    animations.animations[*current_animation],
+                    Duration::from_millis(250),
+                )
+                .repeat();
+        }
+
+        if keyboard_input.just_pressed(KeyCode::Digit1) {
+            let playing_animation = player.animation_mut(playing_animation_index).unwrap();
+            playing_animation
+                .set_repeat(RepeatAnimation::Count(1))
+                .replay();
+        }
+
+        if keyboard_input.just_pressed(KeyCode::Digit2) {
+            let playing_animation = player.animation_mut(playing_animation_index).unwrap();
+            playing_animation
+                .set_repeat(RepeatAnimation::Count(2))
+                .replay();
+        }
+
+        if keyboard_input.just_pressed(KeyCode::Digit3) {
+            let playing_animation = player.animation_mut(playing_animation_index).unwrap();
+            playing_animation
+                .set_repeat(RepeatAnimation::Count(3))
+                .replay();
+        }
+
+        if keyboard_input.just_pressed(KeyCode::KeyL) {
+            let playing_animation = player.animation_mut(playing_animation_index).unwrap();
+            playing_animation.set_repeat(RepeatAnimation::Forever);
+        }
+    }
+}

vendor/bevy/examples/animation/animated_mesh_events.rs

@@ -0,0 +1,292 @@
+//! Plays animations from a skinned glTF.
+
+use std::{f32::consts::PI, time::Duration};
+
+use bevy::{
+    animation::AnimationTargetId, color::palettes::css::WHITE, pbr::CascadeShadowConfigBuilder,
+    prelude::*,
+};
+use rand::{Rng, SeedableRng};
+use rand_chacha::ChaCha8Rng;
+
+const FOX_PATH: &str = "models/animated/Fox.glb";
+
+fn main() {
+    App::new()
+        .insert_resource(AmbientLight {
+            color: Color::WHITE,
+            brightness: 2000.,
+            ..default()
+        })
+        .add_plugins(DefaultPlugins)
+        .init_resource::<ParticleAssets>()
+        .init_resource::<FoxFeetTargets>()
+        .add_systems(Startup, setup)
+        .add_systems(Update, setup_scene_once_loaded)
+        .add_systems(Update, simulate_particles)
+        .add_observer(observe_on_step)
+        .run();
+}
+
+#[derive(Resource)]
+struct SeededRng(ChaCha8Rng);
+
+#[derive(Resource)]
+struct Animations {
+    index: AnimationNodeIndex,
+    graph_handle: Handle<AnimationGraph>,
+}
+
+#[derive(Event, Reflect, Clone)]
+struct OnStep;
+
+fn observe_on_step(
+    trigger: Trigger<OnStep>,
+    particle: Res<ParticleAssets>,
+    mut commands: Commands,
+    transforms: Query<&GlobalTransform>,
+    mut seeded_rng: ResMut<SeededRng>,
+) {
+    let translation = transforms.get(trigger.target()).unwrap().translation();
+    // Spawn a bunch of particles.
+    for _ in 0..14 {
+        let horizontal = seeded_rng.0.r#gen::<Dir2>() * seeded_rng.0.gen_range(8.0..12.0);
+        let vertical = seeded_rng.0.gen_range(0.0..4.0);
+        let size = seeded_rng.0.gen_range(0.2..1.0);
+
+        commands.spawn((
+            Particle {
+                lifetime_timer: Timer::from_seconds(
+                    seeded_rng.0.gen_range(0.2..0.6),
+                    TimerMode::Once,
+                ),
+                size,
+                velocity: Vec3::new(horizontal.x, vertical, horizontal.y) * 10.0,
+            },
+            Mesh3d(particle.mesh.clone()),
+            MeshMaterial3d(particle.material.clone()),
+            Transform {
+                translation,
+                scale: Vec3::splat(size),
+                ..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, index) = AnimationGraph::from_clip(
+        // We specifically want the "run" animation, which is the third one.
+        asset_server.load(GltfAssetLabel::Animation(2).from_asset(FOX_PATH)),
+    );
+
+    // Insert a resource with the current scene information
+    let graph_handle = graphs.add(graph);
+    commands.insert_resource(Animations {
+        index,
+        graph_handle,
+    });
+
+    // Camera
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(100.0, 100.0, 150.0).looking_at(Vec3::new(0.0, 20.0, 0.0), Vec3::Y),
+    ));
+
+    // 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: 200.0,
+            maximum_distance: 400.0,
+            ..default()
+        }
+        .build(),
+    ));
+
+    // Fox
+    commands.spawn(SceneRoot(
+        asset_server.load(GltfAssetLabel::Scene(0).from_asset(FOX_PATH)),
+    ));
+
+    // We're seeding the PRNG here to make this example deterministic for testing purposes.
+    // This isn't strictly required in practical use unless you need your app to be deterministic.
+    let seeded_rng = ChaCha8Rng::seed_from_u64(19878367467712);
+    commands.insert_resource(SeededRng(seeded_rng));
+}
+
+// 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<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 = match &node.node_type {
+            AnimationNodeType::Clip(handle) => clips.get_mut(handle),
+            _ => unreachable!(),
+        };
+        clip.unwrap()
+    }
+
+    for (entity, mut player) in &mut players {
+        // Send `OnStep` events once the fox feet hits the ground in the running animation.
+
+        let graph = graphs.get(&animations.graph_handle).unwrap();
+        let running_animation = get_clip(animations.index, graph, &mut clips);
+
+        // You can determine the time an event should trigger if you know witch frame it occurs and
+        // 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);
+        running_animation.add_event_to_target(feet.back_right, 0.125, OnStep);
+
+        // Start the animation
+
+        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.index, Duration::ZERO)
+            .repeat();
+
+        commands
+            .entity(entity)
+            .insert(AnimationGraphHandle(animations.graph_handle.clone()))
+            .insert(transitions);
+    }
+}
+
+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.lifetime_timer.tick(time.delta()).just_finished() {
+            commands.entity(entity).despawn();
+            return;
+        }
+
+        transform.translation += particle.velocity * time.delta_secs();
+        transform.scale = Vec3::splat(particle.size.lerp(0.0, particle.lifetime_timer.fraction()));
+        particle
+            .velocity
+            .smooth_nudge(&Vec3::ZERO, 4.0, time.delta_secs());
+    }
+}
+
+#[derive(Component)]
+struct Particle {
+    lifetime_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.add_asset::<Mesh>(Sphere::new(10.0)),
+            material: world.add_asset::<StandardMaterial>(StandardMaterial {
+                base_color: WHITE.into(),
+                ..Default::default()
+            }),
+        }
+    }
+}
+
+/// Stores the `AnimationTargetId`s of the fox's feet
+#[derive(Resource)]
+struct FoxFeetTargets {
+    front_right: AnimationTargetId,
+    front_left: AnimationTargetId,
+    back_left: AnimationTargetId,
+    back_right: AnimationTargetId,
+}
+
+impl Default for FoxFeetTargets {
+    fn default() -> Self {
+        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),
+        }
+    }
+}

vendor/bevy/examples/animation/animated_transform.rs

@@ -0,0 +1,185 @@
+//! Create and play an animation defined by code that operates on the [`Transform`] component.
+
+use std::f32::consts::PI;
+
+use bevy::{
+    animation::{animated_field, AnimationTarget, AnimationTargetId},
+    prelude::*,
+};
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .insert_resource(AmbientLight {
+            color: Color::WHITE,
+            brightness: 150.0,
+            ..default()
+        })
+        .add_systems(Startup, setup)
+        .run();
+}
+
+fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+    mut animations: ResMut<Assets<AnimationClip>>,
+    mut graphs: ResMut<Assets<AnimationGraph>>,
+) {
+    // Camera
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(-2.0, 2.5, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+
+    // Light
+    commands.spawn((
+        PointLight {
+            intensity: 500_000.0,
+            ..default()
+        },
+        Transform::from_xyz(0.0, 2.5, 0.0),
+    ));
+
+    // Let's use the `Name` component to target entities. We can use anything we
+    // like, but names are convenient.
+    let planet = Name::new("planet");
+    let orbit_controller = Name::new("orbit_controller");
+    let satellite = Name::new("satellite");
+
+    // Creating the animation
+    let mut animation = AnimationClip::default();
+    // A curve can modify a single part of a transform: here, the translation.
+    let planet_animation_target_id = AnimationTargetId::from_name(&planet);
+    animation.add_curve_to_target(
+        planet_animation_target_id,
+        AnimatableCurve::new(
+            animated_field!(Transform::translation),
+            UnevenSampleAutoCurve::new([0.0, 1.0, 2.0, 3.0, 4.0].into_iter().zip([
+                Vec3::new(1.0, 0.0, 1.0),
+                Vec3::new(-1.0, 0.0, 1.0),
+                Vec3::new(-1.0, 0.0, -1.0),
+                Vec3::new(1.0, 0.0, -1.0),
+                // in case seamless looping is wanted, the last keyframe should
+                // be the same as the first one
+                Vec3::new(1.0, 0.0, 1.0),
+            ]))
+            .expect("should be able to build translation curve because we pass in valid samples"),
+        ),
+    );
+    // Or it can modify the rotation of the transform.
+    // To find the entity to modify, the hierarchy will be traversed looking for
+    // an entity with the right name at each level.
+    let orbit_controller_animation_target_id =
+        AnimationTargetId::from_names([planet.clone(), orbit_controller.clone()].iter());
+    animation.add_curve_to_target(
+        orbit_controller_animation_target_id,
+        AnimatableCurve::new(
+            animated_field!(Transform::rotation),
+            UnevenSampleAutoCurve::new([0.0, 1.0, 2.0, 3.0, 4.0].into_iter().zip([
+                Quat::IDENTITY,
+                Quat::from_axis_angle(Vec3::Y, PI / 2.),
+                Quat::from_axis_angle(Vec3::Y, PI / 2. * 2.),
+                Quat::from_axis_angle(Vec3::Y, PI / 2. * 3.),
+                Quat::IDENTITY,
+            ]))
+            .expect("Failed to build rotation curve"),
+        ),
+    );
+    // If a curve in an animation is shorter than the other, it will not repeat
+    // until all other curves are finished. In that case, another animation should
+    // be created for each part that would have a different duration / period.
+    let satellite_animation_target_id = AnimationTargetId::from_names(
+        [planet.clone(), orbit_controller.clone(), satellite.clone()].iter(),
+    );
+    animation.add_curve_to_target(
+        satellite_animation_target_id,
+        AnimatableCurve::new(
+            animated_field!(Transform::scale),
+            UnevenSampleAutoCurve::new(
+                [0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0]
+                    .into_iter()
+                    .zip([
+                        Vec3::splat(0.8),
+                        Vec3::splat(1.2),
+                        Vec3::splat(0.8),
+                        Vec3::splat(1.2),
+                        Vec3::splat(0.8),
+                        Vec3::splat(1.2),
+                        Vec3::splat(0.8),
+                        Vec3::splat(1.2),
+                        Vec3::splat(0.8),
+                    ]),
+            )
+            .expect("Failed to build scale curve"),
+        ),
+    );
+    // There can be more than one curve targeting the same entity path.
+    animation.add_curve_to_target(
+        AnimationTargetId::from_names(
+            [planet.clone(), orbit_controller.clone(), satellite.clone()].iter(),
+        ),
+        AnimatableCurve::new(
+            animated_field!(Transform::rotation),
+            UnevenSampleAutoCurve::new([0.0, 1.0, 2.0, 3.0, 4.0].into_iter().zip([
+                Quat::IDENTITY,
+                Quat::from_axis_angle(Vec3::Y, PI / 2.),
+                Quat::from_axis_angle(Vec3::Y, PI / 2. * 2.),
+                Quat::from_axis_angle(Vec3::Y, PI / 2. * 3.),
+                Quat::IDENTITY,
+            ]))
+            .expect("should be able to build translation curve because we pass in valid samples"),
+        ),
+    );
+
+    // Create the animation graph
+    let (graph, animation_index) = AnimationGraph::from_clip(animations.add(animation));
+
+    // Create the animation player, and set it to repeat
+    let mut player = AnimationPlayer::default();
+    player.play(animation_index).repeat();
+
+    // Create the scene that will be animated
+    // First entity is the planet
+    let planet_entity = commands
+        .spawn((
+            Mesh3d(meshes.add(Sphere::default())),
+            MeshMaterial3d(materials.add(Color::srgb(0.8, 0.7, 0.6))),
+            // Add the animation graph and player
+            planet,
+            AnimationGraphHandle(graphs.add(graph)),
+            player,
+        ))
+        .id();
+    commands
+        .entity(planet_entity)
+        .insert(AnimationTarget {
+            id: planet_animation_target_id,
+            player: planet_entity,
+        })
+        .with_children(|p| {
+            // This entity is just used for animation, but doesn't display anything
+            p.spawn((
+                Transform::default(),
+                Visibility::default(),
+                orbit_controller,
+                AnimationTarget {
+                    id: orbit_controller_animation_target_id,
+                    player: planet_entity,
+                },
+            ))
+            .with_children(|p| {
+                // The satellite, placed at a distance of the planet
+                p.spawn((
+                    Mesh3d(meshes.add(Cuboid::new(0.5, 0.5, 0.5))),
+                    MeshMaterial3d(materials.add(Color::srgb(0.3, 0.9, 0.3))),
+                    Transform::from_xyz(1.5, 0.0, 0.0),
+                    AnimationTarget {
+                        id: satellite_animation_target_id,
+                        player: planet_entity,
+                    },
+                    satellite,
+                ));
+            });
+        });
+}

vendor/bevy/examples/animation/animated_ui.rs

@@ -0,0 +1,197 @@
+//! Shows how to use animation clips to animate UI properties.
+
+use bevy::{
+    animation::{
+        animated_field, AnimationEntityMut, AnimationEvaluationError, AnimationTarget,
+        AnimationTargetId,
+    },
+    prelude::*,
+};
+use std::any::TypeId;
+
+// Holds information about the animation we programmatically create.
+struct AnimationInfo {
+    // The name of the animation target (in this case, the text).
+    target_name: Name,
+    // The ID of the animation target, derived from the name.
+    target_id: AnimationTargetId,
+    // The animation graph asset.
+    graph: Handle<AnimationGraph>,
+    // The index of the node within that graph.
+    node_index: AnimationNodeIndex,
+}
+
+// The entry point.
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        // Note that we don't need any systems other than the setup system,
+        // because Bevy automatically updates animations every frame.
+        .add_systems(Startup, setup)
+        .run();
+}
+
+impl AnimationInfo {
+    // Programmatically creates the UI animation.
+    fn create(
+        animation_graphs: &mut Assets<AnimationGraph>,
+        animation_clips: &mut Assets<AnimationClip>,
+    ) -> AnimationInfo {
+        // Create an ID that identifies the text node we're going to animate.
+        let animation_target_name = Name::new("Text");
+        let animation_target_id = AnimationTargetId::from_name(&animation_target_name);
+
+        // Allocate an animation clip.
+        let mut animation_clip = AnimationClip::default();
+
+        // Create a curve that animates font size.
+        animation_clip.add_curve_to_target(
+            animation_target_id,
+            AnimatableCurve::new(
+                animated_field!(TextFont::font_size),
+                AnimatableKeyframeCurve::new(
+                    [0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0]
+                        .into_iter()
+                        .zip([24.0, 80.0, 24.0, 80.0, 24.0, 80.0, 24.0]),
+                )
+                .expect(
+                    "should be able to build translation curve because we pass in valid samples",
+                ),
+            ),
+        );
+
+        // Create a curve that animates font color. Note that this should have
+        // the same time duration as the previous curve.
+        //
+        // This time we use a "custom property", which in this case animates TextColor under the assumption
+        // that it is in the "srgba" format.
+        animation_clip.add_curve_to_target(
+            animation_target_id,
+            AnimatableCurve::new(
+                TextColorProperty,
+                AnimatableKeyframeCurve::new([0.0, 1.0, 2.0, 3.0].into_iter().zip([
+                    Srgba::RED,
+                    Srgba::GREEN,
+                    Srgba::BLUE,
+                    Srgba::RED,
+                ]))
+                .expect(
+                    "should be able to build translation curve because we pass in valid samples",
+                ),
+            ),
+        );
+
+        // Save our animation clip as an asset.
+        let animation_clip_handle = animation_clips.add(animation_clip);
+
+        // Create an animation graph with that clip.
+        let (animation_graph, animation_node_index) =
+            AnimationGraph::from_clip(animation_clip_handle);
+        let animation_graph_handle = animation_graphs.add(animation_graph);
+
+        AnimationInfo {
+            target_name: animation_target_name,
+            target_id: animation_target_id,
+            graph: animation_graph_handle,
+            node_index: animation_node_index,
+        }
+    }
+}
+
+// Creates all the entities in the scene.
+fn setup(
+    mut commands: Commands,
+    asset_server: Res<AssetServer>,
+    mut animation_graphs: ResMut<Assets<AnimationGraph>>,
+    mut animation_clips: ResMut<Assets<AnimationClip>>,
+) {
+    // Create the animation.
+    let AnimationInfo {
+        target_name: animation_target_name,
+        target_id: animation_target_id,
+        graph: animation_graph,
+        node_index: animation_node_index,
+    } = AnimationInfo::create(&mut animation_graphs, &mut animation_clips);
+
+    // Build an animation player that automatically plays the UI animation.
+    let mut animation_player = AnimationPlayer::default();
+    animation_player.play(animation_node_index).repeat();
+
+    // Add a camera.
+    commands.spawn(Camera2d);
+
+    // Build the UI. We have a parent node that covers the whole screen and
+    // contains the `AnimationPlayer`, as well as a child node that contains the
+    // text to be animated.
+    commands
+        .spawn((
+            // Cover the whole screen, and center contents.
+            Node {
+                position_type: PositionType::Absolute,
+                top: Val::Px(0.0),
+                left: Val::Px(0.0),
+                right: Val::Px(0.0),
+                bottom: Val::Px(0.0),
+                justify_content: JustifyContent::Center,
+                align_items: AlignItems::Center,
+                ..default()
+            },
+            animation_player,
+            AnimationGraphHandle(animation_graph),
+        ))
+        .with_children(|builder| {
+            // Build the text node.
+            let player = builder.target_entity();
+            builder
+                .spawn((
+                    Text::new("Bevy"),
+                    TextFont {
+                        font: asset_server.load("fonts/FiraSans-Bold.ttf"),
+                        font_size: 24.0,
+                        ..default()
+                    },
+                    TextColor(Color::Srgba(Srgba::RED)),
+                    TextLayout::new_with_justify(JustifyText::Center),
+                ))
+                // Mark as an animation target.
+                .insert(AnimationTarget {
+                    id: animation_target_id,
+                    player,
+                })
+                .insert(animation_target_name);
+        });
+}
+
+// A type that represents the color of the first text section.
+//
+// We implement `AnimatableProperty` on this to define custom property accessor logic
+#[derive(Clone)]
+struct TextColorProperty;
+
+impl AnimatableProperty for TextColorProperty {
+    type Property = Srgba;
+
+    fn evaluator_id(&self) -> EvaluatorId {
+        EvaluatorId::Type(TypeId::of::<Self>())
+    }
+
+    fn get_mut<'a>(
+        &self,
+        entity: &'a mut AnimationEntityMut,
+    ) -> Result<&'a mut Self::Property, AnimationEvaluationError> {
+        let text_color = entity
+            .get_mut::<TextColor>()
+            .ok_or(AnimationEvaluationError::ComponentNotPresent(TypeId::of::<
+                TextColor,
+            >(
+            )))?
+            .into_inner();
+        match text_color.0 {
+            Color::Srgba(ref mut color) => Ok(color),
+            _ => Err(AnimationEvaluationError::PropertyNotPresent(TypeId::of::<
+                Srgba,
+            >(
+            ))),
+        }
+    }
+}

vendor/bevy/examples/animation/animation_events.rs

@@ -0,0 +1,104 @@
+//! Demonstrate how to use animation events.
+
+use bevy::{
+    color::palettes::css::{ALICE_BLUE, BLACK, CRIMSON},
+    core_pipeline::bloom::Bloom,
+    prelude::*,
+};
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_event::<MessageEvent>()
+        .add_systems(Startup, setup)
+        .add_systems(Update, animate_text_opacity)
+        .add_observer(edit_message)
+        .run();
+}
+
+#[derive(Component)]
+struct MessageText;
+
+#[derive(Event, Clone)]
+struct MessageEvent {
+    value: String,
+    color: Color,
+}
+
+fn edit_message(
+    trigger: Trigger<MessageEvent>,
+    text: Single<(&mut Text2d, &mut TextColor), With<MessageText>>,
+) {
+    let (mut text, mut color) = text.into_inner();
+    text.0 = trigger.event().value.clone();
+    color.0 = trigger.event().color;
+}
+
+fn setup(
+    mut commands: Commands,
+    mut animations: ResMut<Assets<AnimationClip>>,
+    mut graphs: ResMut<Assets<AnimationGraph>>,
+) {
+    // Camera
+    commands.spawn((
+        Camera2d,
+        Camera {
+            clear_color: ClearColorConfig::Custom(BLACK.into()),
+            hdr: true,
+            ..Default::default()
+        },
+        Bloom {
+            intensity: 0.4,
+            ..Bloom::NATURAL
+        },
+    ));
+
+    // The text that will be changed by animation events.
+    commands.spawn((
+        MessageText,
+        Text2d::default(),
+        TextFont {
+            font_size: 119.0,
+            ..default()
+        },
+        TextColor(Color::NONE),
+    ));
+
+    // 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,
+        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));
+    let mut player = AnimationPlayer::default();
+    player.play(animation_index).repeat();
+
+    commands.spawn((AnimationGraphHandle(graphs.add(graph)), player));
+}
+
+// Slowly fade out the text opacity.
+fn animate_text_opacity(mut colors: Query<&mut TextColor>, time: Res<Time>) {
+    for mut color in &mut colors {
+        let a = color.0.alpha();
+        color.0.set_alpha(a - time.delta_secs());
+    }
+}

vendor/bevy/examples/animation/animation_graph.rs

@@ -0,0 +1,557 @@
+//! Demonstrates animation blending with animation graphs.
+//!
+//! The animation graph is shown on screen. You can change the weights of the
+//! playing animations by clicking and dragging left or right within the nodes.
+
+use bevy::{
+    color::palettes::{
+        basic::WHITE,
+        css::{ANTIQUE_WHITE, DARK_GREEN},
+    },
+    prelude::*,
+    ui::RelativeCursorPosition,
+};
+
+use argh::FromArgs;
+
+#[cfg(not(target_arch = "wasm32"))]
+use {
+    bevy::{asset::io::file::FileAssetReader, tasks::IoTaskPool},
+    ron::ser::PrettyConfig,
+    std::{fs::File, path::Path},
+};
+
+/// Where to find the serialized animation graph.
+static ANIMATION_GRAPH_PATH: &str = "animation_graphs/Fox.animgraph.ron";
+
+/// The indices of the nodes containing animation clips in the graph.
+static CLIP_NODE_INDICES: [u32; 3] = [2, 3, 4];
+
+/// The help text in the upper left corner.
+static HELP_TEXT: &str = "Click and drag an animation clip node to change its weight";
+
+/// The node widgets in the UI.
+static NODE_TYPES: [NodeType; 5] = [
+    NodeType::Clip(ClipNode::new("Idle", 0)),
+    NodeType::Clip(ClipNode::new("Walk", 1)),
+    NodeType::Blend("Root"),
+    NodeType::Blend("Blend\n0.5"),
+    NodeType::Clip(ClipNode::new("Run", 2)),
+];
+
+/// The positions of the node widgets in the UI.
+///
+/// These are in the same order as [`NODE_TYPES`] above.
+static NODE_RECTS: [NodeRect; 5] = [
+    NodeRect::new(10.00, 10.00, 97.64, 48.41),
+    NodeRect::new(10.00, 78.41, 97.64, 48.41),
+    NodeRect::new(286.08, 78.41, 97.64, 48.41),
+    NodeRect::new(148.04, 112.61, 97.64, 48.41), // was 44.20
+    NodeRect::new(10.00, 146.82, 97.64, 48.41),
+];
+
+/// The positions of the horizontal lines in the UI.
+static HORIZONTAL_LINES: [Line; 6] = [
+    Line::new(107.64, 34.21, 158.24),
+    Line::new(107.64, 102.61, 20.20),
+    Line::new(107.64, 171.02, 20.20),
+    Line::new(127.84, 136.82, 20.20),
+    Line::new(245.68, 136.82, 20.20),
+    Line::new(265.88, 102.61, 20.20),
+];
+
+/// The positions of the vertical lines in the UI.
+static VERTICAL_LINES: [Line; 2] = [
+    Line::new(127.83, 102.61, 68.40),
+    Line::new(265.88, 34.21, 102.61),
+];
+
+/// Initializes the app.
+fn main() {
+    #[cfg(not(target_arch = "wasm32"))]
+    let args: Args = argh::from_env();
+    #[cfg(target_arch = "wasm32")]
+    let args = Args::from_args(&[], &[]).unwrap();
+
+    App::new()
+        .add_plugins(DefaultPlugins.set(WindowPlugin {
+            primary_window: Some(Window {
+                title: "Bevy Animation Graph Example".into(),
+                ..default()
+            }),
+            ..default()
+        }))
+        .add_systems(Startup, (setup_assets, setup_scene, setup_ui))
+        .add_systems(Update, init_animations)
+        .add_systems(
+            Update,
+            (handle_weight_drag, update_ui, sync_weights).chain(),
+        )
+        .insert_resource(args)
+        .insert_resource(AmbientLight {
+            color: WHITE.into(),
+            brightness: 100.0,
+            ..default()
+        })
+        .run();
+}
+
+/// Demonstrates animation blending with animation graphs
+#[derive(FromArgs, Resource)]
+struct Args {
+    /// disables loading of the animation graph asset from disk
+    #[argh(switch)]
+    no_load: bool,
+    /// regenerates the asset file; implies `--no-load`
+    #[argh(switch)]
+    save: bool,
+}
+
+/// The [`AnimationGraph`] asset, which specifies how the animations are to
+/// be blended together.
+#[derive(Clone, Resource)]
+struct ExampleAnimationGraph(Handle<AnimationGraph>);
+
+/// The current weights of the three playing animations.
+#[derive(Component)]
+struct ExampleAnimationWeights {
+    /// The weights of the three playing animations.
+    weights: [f32; 3],
+}
+
+/// Initializes the scene.
+fn setup_assets(
+    mut commands: Commands,
+    mut asset_server: ResMut<AssetServer>,
+    mut animation_graphs: ResMut<Assets<AnimationGraph>>,
+    args: Res<Args>,
+) {
+    // Create or load the assets.
+    if args.no_load || args.save {
+        setup_assets_programmatically(
+            &mut commands,
+            &mut asset_server,
+            &mut animation_graphs,
+            args.save,
+        );
+    } else {
+        setup_assets_via_serialized_animation_graph(&mut commands, &mut asset_server);
+    }
+}
+
+fn setup_ui(mut commands: Commands) {
+    setup_help_text(&mut commands);
+    setup_node_rects(&mut commands);
+    setup_node_lines(&mut commands);
+}
+
+/// Creates the assets programmatically, including the animation graph.
+/// Optionally saves them to disk if `save` is present (corresponding to the
+/// `--save` option).
+fn setup_assets_programmatically(
+    commands: &mut Commands,
+    asset_server: &mut AssetServer,
+    animation_graphs: &mut Assets<AnimationGraph>,
+    _save: bool,
+) {
+    // Create the nodes.
+    let mut animation_graph = AnimationGraph::new();
+    let blend_node = animation_graph.add_blend(0.5, animation_graph.root);
+    animation_graph.add_clip(
+        asset_server.load(GltfAssetLabel::Animation(0).from_asset("models/animated/Fox.glb")),
+        1.0,
+        animation_graph.root,
+    );
+    animation_graph.add_clip(
+        asset_server.load(GltfAssetLabel::Animation(1).from_asset("models/animated/Fox.glb")),
+        1.0,
+        blend_node,
+    );
+    animation_graph.add_clip(
+        asset_server.load(GltfAssetLabel::Animation(2).from_asset("models/animated/Fox.glb")),
+        1.0,
+        blend_node,
+    );
+
+    // If asked to save, do so.
+    #[cfg(not(target_arch = "wasm32"))]
+    if _save {
+        let animation_graph = animation_graph.clone();
+
+        IoTaskPool::get()
+            .spawn(async move {
+                let mut animation_graph_writer = File::create(Path::join(
+                    &FileAssetReader::get_base_path(),
+                    Path::join(Path::new("assets"), Path::new(ANIMATION_GRAPH_PATH)),
+                ))
+                .expect("Failed to open the animation graph asset");
+                ron::ser::to_writer_pretty(
+                    &mut animation_graph_writer,
+                    &animation_graph,
+                    PrettyConfig::default(),
+                )
+                .expect("Failed to serialize the animation graph");
+            })
+            .detach();
+    }
+
+    // Add the graph.
+    let handle = animation_graphs.add(animation_graph);
+
+    // Save the assets in a resource.
+    commands.insert_resource(ExampleAnimationGraph(handle));
+}
+
+fn setup_assets_via_serialized_animation_graph(
+    commands: &mut Commands,
+    asset_server: &mut AssetServer,
+) {
+    commands.insert_resource(ExampleAnimationGraph(
+        asset_server.load(ANIMATION_GRAPH_PATH),
+    ));
+}
+
+/// Spawns the animated fox.
+fn setup_scene(
+    mut commands: Commands,
+    asset_server: Res<AssetServer>,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(-10.0, 5.0, 13.0).looking_at(Vec3::new(0., 1., 0.), Vec3::Y),
+    ));
+
+    commands.spawn((
+        PointLight {
+            intensity: 10_000_000.0,
+            shadows_enabled: true,
+            ..default()
+        },
+        Transform::from_xyz(-4.0, 8.0, 13.0),
+    ));
+
+    commands.spawn((
+        SceneRoot(
+            asset_server.load(GltfAssetLabel::Scene(0).from_asset("models/animated/Fox.glb")),
+        ),
+        Transform::from_scale(Vec3::splat(0.07)),
+    ));
+
+    // Ground
+
+    commands.spawn((
+        Mesh3d(meshes.add(Circle::new(7.0))),
+        MeshMaterial3d(materials.add(Color::srgb(0.3, 0.5, 0.3))),
+        Transform::from_rotation(Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2)),
+    ));
+}
+
+/// Places the help text at the top left of the window.
+fn setup_help_text(commands: &mut Commands) {
+    commands.spawn((
+        Text::new(HELP_TEXT),
+        Node {
+            position_type: PositionType::Absolute,
+            top: Val::Px(12.0),
+            left: Val::Px(12.0),
+            ..default()
+        },
+    ));
+}
+
+/// Initializes the node UI widgets.
+fn setup_node_rects(commands: &mut Commands) {
+    for (node_rect, node_type) in NODE_RECTS.iter().zip(NODE_TYPES.iter()) {
+        let node_string = match *node_type {
+            NodeType::Clip(ref clip) => clip.text,
+            NodeType::Blend(text) => text,
+        };
+
+        let text = commands
+            .spawn((
+                Text::new(node_string),
+                TextFont {
+                    font_size: 16.0,
+                    ..default()
+                },
+                TextColor(ANTIQUE_WHITE.into()),
+                TextLayout::new_with_justify(JustifyText::Center),
+            ))
+            .id();
+
+        let container = {
+            let mut container = commands.spawn((
+                Node {
+                    position_type: PositionType::Absolute,
+                    bottom: Val::Px(node_rect.bottom),
+                    left: Val::Px(node_rect.left),
+                    height: Val::Px(node_rect.height),
+                    width: Val::Px(node_rect.width),
+                    align_items: AlignItems::Center,
+                    justify_items: JustifyItems::Center,
+                    align_content: AlignContent::Center,
+                    justify_content: JustifyContent::Center,
+                    ..default()
+                },
+                BorderColor(WHITE.into()),
+                Outline::new(Val::Px(1.), Val::ZERO, Color::WHITE),
+            ));
+
+            if let NodeType::Clip(clip) = node_type {
+                container.insert((
+                    Interaction::None,
+                    RelativeCursorPosition::default(),
+                    (*clip).clone(),
+                ));
+            }
+
+            container.id()
+        };
+
+        // Create the background color.
+        if let NodeType::Clip(_) = node_type {
+            let background = commands
+                .spawn((
+                    Node {
+                        position_type: PositionType::Absolute,
+                        top: Val::Px(0.),
+                        left: Val::Px(0.),
+                        height: Val::Px(node_rect.height),
+                        width: Val::Px(node_rect.width),
+                        ..default()
+                    },
+                    BackgroundColor(DARK_GREEN.into()),
+                ))
+                .id();
+
+            commands.entity(container).add_child(background);
+        }
+
+        commands.entity(container).add_child(text);
+    }
+}
+
+/// Creates boxes for the horizontal and vertical lines.
+///
+/// This is a bit hacky: it uses 1-pixel-wide and 1-pixel-high boxes to draw
+/// vertical and horizontal lines, respectively.
+fn setup_node_lines(commands: &mut Commands) {
+    for line in &HORIZONTAL_LINES {
+        commands.spawn((
+            Node {
+                position_type: PositionType::Absolute,
+                bottom: Val::Px(line.bottom),
+                left: Val::Px(line.left),
+                height: Val::Px(0.0),
+                width: Val::Px(line.length),
+                border: UiRect::bottom(Val::Px(1.0)),
+                ..default()
+            },
+            BorderColor(WHITE.into()),
+        ));
+    }
+
+    for line in &VERTICAL_LINES {
+        commands.spawn((
+            Node {
+                position_type: PositionType::Absolute,
+                bottom: Val::Px(line.bottom),
+                left: Val::Px(line.left),
+                height: Val::Px(line.length),
+                width: Val::Px(0.0),
+                border: UiRect::left(Val::Px(1.0)),
+                ..default()
+            },
+            BorderColor(WHITE.into()),
+        ));
+    }
+}
+
+/// Attaches the animation graph to the scene, and plays all three animations.
+fn init_animations(
+    mut commands: Commands,
+    mut query: Query<(Entity, &mut AnimationPlayer)>,
+    animation_graph: Res<ExampleAnimationGraph>,
+    mut done: Local<bool>,
+) {
+    if *done {
+        return;
+    }
+
+    for (entity, mut player) in query.iter_mut() {
+        commands.entity(entity).insert((
+            AnimationGraphHandle(animation_graph.0.clone()),
+            ExampleAnimationWeights::default(),
+        ));
+        for &node_index in &CLIP_NODE_INDICES {
+            player.play(node_index.into()).repeat();
+        }
+
+        *done = true;
+    }
+}
+
+/// Read cursor position relative to clip nodes, allowing the user to change weights
+/// when dragging the node UI widgets.
+fn handle_weight_drag(
+    mut interaction_query: Query<(&Interaction, &RelativeCursorPosition, &ClipNode)>,
+    mut animation_weights_query: Query<&mut ExampleAnimationWeights>,
+) {
+    for (interaction, relative_cursor, clip_node) in &mut interaction_query {
+        if !matches!(*interaction, Interaction::Pressed) {
+            continue;
+        }
+
+        let Some(pos) = relative_cursor.normalized else {
+            continue;
+        };
+
+        for mut animation_weights in animation_weights_query.iter_mut() {
+            animation_weights.weights[clip_node.index] = pos.x.clamp(0., 1.);
+        }
+    }
+}
+
+// Updates the UI based on the weights that the user has chosen.
+fn update_ui(
+    mut text_query: Query<&mut Text>,
+    mut background_query: Query<&mut Node, Without<Text>>,
+    container_query: Query<(&Children, &ClipNode)>,
+    animation_weights_query: Query<&ExampleAnimationWeights, Changed<ExampleAnimationWeights>>,
+) {
+    for animation_weights in animation_weights_query.iter() {
+        for (children, clip_node) in &container_query {
+            // Draw the green background color to visually indicate the weight.
+            let mut bg_iter = background_query.iter_many_mut(children);
+            if let Some(mut node) = bg_iter.fetch_next() {
+                // All nodes are the same width, so `NODE_RECTS[0]` is as good as any other.
+                node.width =
+                    Val::Px(NODE_RECTS[0].width * animation_weights.weights[clip_node.index]);
+            }
+
+            // Update the node labels with the current weights.
+            let mut text_iter = text_query.iter_many_mut(children);
+            if let Some(mut text) = text_iter.fetch_next() {
+                **text = format!(
+                    "{}\n{:.2}",
+                    clip_node.text, animation_weights.weights[clip_node.index]
+                );
+            }
+        }
+    }
+}
+
+/// Takes the weights that were set in the UI and assigns them to the actual
+/// playing animation.
+fn sync_weights(mut query: Query<(&mut AnimationPlayer, &ExampleAnimationWeights)>) {
+    for (mut animation_player, animation_weights) in query.iter_mut() {
+        for (&animation_node_index, &animation_weight) in CLIP_NODE_INDICES
+            .iter()
+            .zip(animation_weights.weights.iter())
+        {
+            // If the animation happens to be no longer active, restart it.
+            if !animation_player.is_playing_animation(animation_node_index.into()) {
+                animation_player.play(animation_node_index.into());
+            }
+
+            // Set the weight.
+            if let Some(active_animation) =
+                animation_player.animation_mut(animation_node_index.into())
+            {
+                active_animation.set_weight(animation_weight);
+            }
+        }
+    }
+}
+
+/// An on-screen representation of a node.
+#[derive(Debug)]
+struct NodeRect {
+    /// The number of pixels that this rectangle is from the left edge of the
+    /// window.
+    left: f32,
+    /// The number of pixels that this rectangle is from the bottom edge of the
+    /// window.
+    bottom: f32,
+    /// The width of this rectangle in pixels.
+    width: f32,
+    /// The height of this rectangle in pixels.
+    height: f32,
+}
+
+/// Either a straight horizontal or a straight vertical line on screen.
+///
+/// The line starts at (`left`, `bottom`) and goes either right (if the line is
+/// horizontal) or down (if the line is vertical).
+struct Line {
+    /// The number of pixels that the start of this line is from the left edge
+    /// of the screen.
+    left: f32,
+    /// The number of pixels that the start of this line is from the bottom edge
+    /// of the screen.
+    bottom: f32,
+    /// The length of the line.
+    length: f32,
+}
+
+/// The type of each node in the UI: either a clip node or a blend node.
+enum NodeType {
+    /// A clip node, which specifies an animation.
+    Clip(ClipNode),
+    /// A blend node with no animation and a string label.
+    Blend(&'static str),
+}
+
+/// The label for the UI representation of a clip node.
+#[derive(Clone, Component)]
+struct ClipNode {
+    /// The string label of the node.
+    text: &'static str,
+    /// Which of the three animations this UI widget represents.
+    index: usize,
+}
+
+impl Default for ExampleAnimationWeights {
+    fn default() -> Self {
+        Self { weights: [1.0; 3] }
+    }
+}
+
+impl ClipNode {
+    /// Creates a new [`ClipNodeText`] from a label and the animation index.
+    const fn new(text: &'static str, index: usize) -> Self {
+        Self { text, index }
+    }
+}
+
+impl NodeRect {
+    /// Creates a new [`NodeRect`] from the lower-left corner and size.
+    ///
+    /// Note that node rectangles are anchored in the *lower*-left corner. The
+    /// `bottom` parameter specifies vertical distance from the *bottom* of the
+    /// window.
+    const fn new(left: f32, bottom: f32, width: f32, height: f32) -> NodeRect {
+        NodeRect {
+            left,
+            bottom,
+            width,
+            height,
+        }
+    }
+}
+
+impl Line {
+    /// Creates a new [`Line`], either horizontal or vertical.
+    ///
+    /// Note that the line's start point is anchored in the lower-*left* corner,
+    /// and that the `length` extends either to the right or downward.
+    const fn new(left: f32, bottom: f32, length: f32) -> Self {
+        Self {
+            left,
+            bottom,
+            length,
+        }
+    }
+}

vendor/bevy/examples/animation/animation_masks.rs

@@ -0,0 +1,496 @@
+//! Demonstrates how to use masks to limit the scope of animations.
+
+use bevy::{
+    animation::{AnimationTarget, AnimationTargetId},
+    color::palettes::css::{LIGHT_GRAY, WHITE},
+    prelude::*,
+};
+use std::collections::HashSet;
+
+// IDs of the mask groups we define for the running fox model.
+//
+// Each mask group defines a set of bones for which animations can be toggled on
+// and off.
+const MASK_GROUP_HEAD: u32 = 0;
+const MASK_GROUP_LEFT_FRONT_LEG: u32 = 1;
+const MASK_GROUP_RIGHT_FRONT_LEG: u32 = 2;
+const MASK_GROUP_LEFT_HIND_LEG: u32 = 3;
+const MASK_GROUP_RIGHT_HIND_LEG: u32 = 4;
+const MASK_GROUP_TAIL: u32 = 5;
+
+// The width in pixels of the small buttons that allow the user to toggle a mask
+// group on or off.
+const MASK_GROUP_BUTTON_WIDTH: f32 = 250.0;
+
+// The names of the bones that each mask group consists of. Each mask group is
+// defined as a (prefix, suffix) tuple. The mask group consists of a single
+// bone chain rooted at the prefix. For example, if the chain's prefix is
+// "A/B/C" and the suffix is "D/E", then the bones that will be included in the
+// mask group are "A/B/C", "A/B/C/D", and "A/B/C/D/E".
+//
+// The fact that our mask groups are single chains of bones isn't an engine
+// requirement; it just so happens to be the case for the model we're using. A
+// mask group can consist of any set of animation targets, regardless of whether
+// they form a single chain.
+const MASK_GROUP_PATHS: [(&str, &str); 6] = [
+    // Head
+    (
+        "root/_rootJoint/b_Root_00/b_Hip_01/b_Spine01_02/b_Spine02_03",
+        "b_Neck_04/b_Head_05",
+    ),
+    // Left front leg
+    (
+        "root/_rootJoint/b_Root_00/b_Hip_01/b_Spine01_02/b_Spine02_03/b_LeftUpperArm_09",
+        "b_LeftForeArm_010/b_LeftHand_011",
+    ),
+    // Right front leg
+    (
+        "root/_rootJoint/b_Root_00/b_Hip_01/b_Spine01_02/b_Spine02_03/b_RightUpperArm_06",
+        "b_RightForeArm_07/b_RightHand_08",
+    ),
+    // Left hind leg
+    (
+        "root/_rootJoint/b_Root_00/b_Hip_01/b_LeftLeg01_015",
+        "b_LeftLeg02_016/b_LeftFoot01_017/b_LeftFoot02_018",
+    ),
+    // Right hind leg
+    (
+        "root/_rootJoint/b_Root_00/b_Hip_01/b_RightLeg01_019",
+        "b_RightLeg02_020/b_RightFoot01_021/b_RightFoot02_022",
+    ),
+    // Tail
+    (
+        "root/_rootJoint/b_Root_00/b_Hip_01/b_Tail01_012",
+        "b_Tail02_013/b_Tail03_014",
+    ),
+];
+
+#[derive(Clone, Copy, Component)]
+struct AnimationControl {
+    // The ID of the mask group that this button controls.
+    group_id: u32,
+    label: AnimationLabel,
+}
+
+#[derive(Clone, Copy, Component, PartialEq, Debug)]
+enum AnimationLabel {
+    Idle = 0,
+    Walk = 1,
+    Run = 2,
+    Off = 3,
+}
+
+#[derive(Clone, Debug, Resource)]
+struct AnimationNodes([AnimationNodeIndex; 3]);
+
+#[derive(Clone, Copy, Debug, Resource)]
+struct AppState([MaskGroupState; 6]);
+
+#[derive(Clone, Copy, Debug)]
+struct MaskGroupState {
+    clip: u8,
+}
+
+// The application entry point.
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins.set(WindowPlugin {
+            primary_window: Some(Window {
+                title: "Bevy Animation Masks Example".into(),
+                ..default()
+            }),
+            ..default()
+        }))
+        .add_systems(Startup, (setup_scene, setup_ui))
+        .add_systems(Update, setup_animation_graph_once_loaded)
+        .add_systems(Update, handle_button_toggles)
+        .add_systems(Update, update_ui)
+        .insert_resource(AmbientLight {
+            color: WHITE.into(),
+            brightness: 100.0,
+            ..default()
+        })
+        .init_resource::<AppState>()
+        .run();
+}
+
+// Spawns the 3D objects in the scene, and loads the fox animation from the glTF
+// file.
+fn setup_scene(
+    mut commands: Commands,
+    asset_server: Res<AssetServer>,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    // Spawn the camera.
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(-15.0, 10.0, 20.0).looking_at(Vec3::new(0., 1., 0.), Vec3::Y),
+    ));
+
+    // Spawn the light.
+    commands.spawn((
+        PointLight {
+            intensity: 10_000_000.0,
+            shadows_enabled: true,
+            ..default()
+        },
+        Transform::from_xyz(-4.0, 8.0, 13.0),
+    ));
+
+    // Spawn the fox.
+    commands.spawn((
+        SceneRoot(
+            asset_server.load(GltfAssetLabel::Scene(0).from_asset("models/animated/Fox.glb")),
+        ),
+        Transform::from_scale(Vec3::splat(0.07)),
+    ));
+
+    // Spawn the ground.
+    commands.spawn((
+        Mesh3d(meshes.add(Circle::new(7.0))),
+        MeshMaterial3d(materials.add(Color::srgb(0.3, 0.5, 0.3))),
+        Transform::from_rotation(Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2)),
+    ));
+}
+
+// Creates the UI.
+fn setup_ui(mut commands: Commands) {
+    // Add help text.
+    commands.spawn((
+        Text::new("Click on a button to toggle animations for its associated bones"),
+        Node {
+            position_type: PositionType::Absolute,
+            left: Val::Px(12.0),
+            top: Val::Px(12.0),
+            ..default()
+        },
+    ));
+
+    // Add the buttons that allow the user to toggle mask groups on and off.
+    commands
+        .spawn(Node {
+            flex_direction: FlexDirection::Column,
+            position_type: PositionType::Absolute,
+            row_gap: Val::Px(6.0),
+            left: Val::Px(12.0),
+            bottom: Val::Px(12.0),
+            ..default()
+        })
+        .with_children(|parent| {
+            let row_node = Node {
+                flex_direction: FlexDirection::Row,
+                column_gap: Val::Px(6.0),
+                ..default()
+            };
+
+            add_mask_group_control(parent, "Head", Val::Auto, MASK_GROUP_HEAD);
+
+            parent.spawn(row_node.clone()).with_children(|parent| {
+                add_mask_group_control(
+                    parent,
+                    "Left Front Leg",
+                    Val::Px(MASK_GROUP_BUTTON_WIDTH),
+                    MASK_GROUP_LEFT_FRONT_LEG,
+                );
+                add_mask_group_control(
+                    parent,
+                    "Right Front Leg",
+                    Val::Px(MASK_GROUP_BUTTON_WIDTH),
+                    MASK_GROUP_RIGHT_FRONT_LEG,
+                );
+            });
+
+            parent.spawn(row_node).with_children(|parent| {
+                add_mask_group_control(
+                    parent,
+                    "Left Hind Leg",
+                    Val::Px(MASK_GROUP_BUTTON_WIDTH),
+                    MASK_GROUP_LEFT_HIND_LEG,
+                );
+                add_mask_group_control(
+                    parent,
+                    "Right Hind Leg",
+                    Val::Px(MASK_GROUP_BUTTON_WIDTH),
+                    MASK_GROUP_RIGHT_HIND_LEG,
+                );
+            });
+
+            add_mask_group_control(parent, "Tail", Val::Auto, MASK_GROUP_TAIL);
+        });
+}
+
+// Adds a button that allows the user to toggle a mask group on and off.
+//
+// The button will automatically become a child of the parent that owns the
+// given `ChildSpawnerCommands`.
+fn add_mask_group_control(
+    parent: &mut ChildSpawnerCommands,
+    label: &str,
+    width: Val,
+    mask_group_id: u32,
+) {
+    let button_text_style = (
+        TextFont {
+            font_size: 14.0,
+            ..default()
+        },
+        TextColor::WHITE,
+    );
+    let selected_button_text_style = (button_text_style.0.clone(), TextColor::BLACK);
+    let label_text_style = (
+        button_text_style.0.clone(),
+        TextColor(Color::Srgba(LIGHT_GRAY)),
+    );
+
+    parent
+        .spawn((
+            Node {
+                border: UiRect::all(Val::Px(1.0)),
+                width,
+                flex_direction: FlexDirection::Column,
+                justify_content: JustifyContent::Center,
+                align_items: AlignItems::Center,
+                padding: UiRect::ZERO,
+                margin: UiRect::ZERO,
+                ..default()
+            },
+            BorderColor(Color::WHITE),
+            BorderRadius::all(Val::Px(3.0)),
+            BackgroundColor(Color::BLACK),
+        ))
+        .with_children(|builder| {
+            builder
+                .spawn((
+                    Node {
+                        border: UiRect::ZERO,
+                        width: Val::Percent(100.0),
+                        justify_content: JustifyContent::Center,
+                        align_items: AlignItems::Center,
+                        padding: UiRect::ZERO,
+                        margin: UiRect::ZERO,
+                        ..default()
+                    },
+                    BackgroundColor(Color::BLACK),
+                ))
+                .with_child((
+                    Text::new(label),
+                    label_text_style.clone(),
+                    Node {
+                        margin: UiRect::vertical(Val::Px(3.0)),
+                        ..default()
+                    },
+                ));
+
+            builder
+                .spawn((
+                    Node {
+                        width: Val::Percent(100.0),
+                        flex_direction: FlexDirection::Row,
+                        justify_content: JustifyContent::Center,
+                        align_items: AlignItems::Center,
+                        border: UiRect::top(Val::Px(1.0)),
+                        ..default()
+                    },
+                    BorderColor(Color::WHITE),
+                ))
+                .with_children(|builder| {
+                    for (index, label) in [
+                        AnimationLabel::Run,
+                        AnimationLabel::Walk,
+                        AnimationLabel::Idle,
+                        AnimationLabel::Off,
+                    ]
+                    .iter()
+                    .enumerate()
+                    {
+                        builder
+                            .spawn((
+                                Button,
+                                BackgroundColor(if index > 0 {
+                                    Color::BLACK
+                                } else {
+                                    Color::WHITE
+                                }),
+                                Node {
+                                    flex_grow: 1.0,
+                                    border: if index > 0 {
+                                        UiRect::left(Val::Px(1.0))
+                                    } else {
+                                        UiRect::ZERO
+                                    },
+                                    ..default()
+                                },
+                                BorderColor(Color::WHITE),
+                                AnimationControl {
+                                    group_id: mask_group_id,
+                                    label: *label,
+                                },
+                            ))
+                            .with_child((
+                                Text(format!("{:?}", label)),
+                                if index > 0 {
+                                    button_text_style.clone()
+                                } else {
+                                    selected_button_text_style.clone()
+                                },
+                                TextLayout::new_with_justify(JustifyText::Center),
+                                Node {
+                                    flex_grow: 1.0,
+                                    margin: UiRect::vertical(Val::Px(3.0)),
+                                    ..default()
+                                },
+                            ));
+                    }
+                });
+        });
+}
+
+// Builds up the animation graph, including the mask groups, and adds it to the
+// entity with the `AnimationPlayer` that the glTF loader created.
+fn setup_animation_graph_once_loaded(
+    mut commands: Commands,
+    asset_server: Res<AssetServer>,
+    mut animation_graphs: ResMut<Assets<AnimationGraph>>,
+    mut players: Query<(Entity, &mut AnimationPlayer), Added<AnimationPlayer>>,
+    targets: Query<(Entity, &AnimationTarget)>,
+) {
+    for (entity, mut player) in &mut players {
+        // Load the animation clip from the glTF file.
+        let mut animation_graph = AnimationGraph::new();
+        let blend_node = animation_graph.add_additive_blend(1.0, animation_graph.root);
+
+        let animation_graph_nodes: [AnimationNodeIndex; 3] =
+            std::array::from_fn(|animation_index| {
+                let handle = asset_server.load(
+                    GltfAssetLabel::Animation(animation_index)
+                        .from_asset("models/animated/Fox.glb"),
+                );
+                let mask = if animation_index == 0 { 0 } else { 0x3f };
+                animation_graph.add_clip_with_mask(handle, mask, 1.0, blend_node)
+            });
+
+        // Create each mask group.
+        let mut all_animation_target_ids = HashSet::new();
+        for (mask_group_index, (mask_group_prefix, mask_group_suffix)) in
+            MASK_GROUP_PATHS.iter().enumerate()
+        {
+            // Split up the prefix and suffix, and convert them into `Name`s.
+            let prefix: Vec<_> = mask_group_prefix.split('/').map(Name::new).collect();
+            let suffix: Vec<_> = mask_group_suffix.split('/').map(Name::new).collect();
+
+            // Add each bone in the chain to the appropriate mask group.
+            for chain_length in 0..=suffix.len() {
+                let animation_target_id = AnimationTargetId::from_names(
+                    prefix.iter().chain(suffix[0..chain_length].iter()),
+                );
+                animation_graph
+                    .add_target_to_mask_group(animation_target_id, mask_group_index as u32);
+                all_animation_target_ids.insert(animation_target_id);
+            }
+        }
+
+        // We're doing constructing the animation graph. Add it as an asset.
+        let animation_graph = animation_graphs.add(animation_graph);
+        commands
+            .entity(entity)
+            .insert(AnimationGraphHandle(animation_graph));
+
+        // Remove animation targets that aren't in any of the mask groups. If we
+        // don't do that, those bones will play all animations at once, which is
+        // ugly.
+        for (target_entity, target) in &targets {
+            if !all_animation_target_ids.contains(&target.id) {
+                commands.entity(target_entity).remove::<AnimationTarget>();
+            }
+        }
+
+        // Play the animation.
+        for animation_graph_node in animation_graph_nodes {
+            player.play(animation_graph_node).repeat();
+        }
+
+        // Record the graph nodes.
+        commands.insert_resource(AnimationNodes(animation_graph_nodes));
+    }
+}
+
+// A system that handles requests from the user to toggle mask groups on and
+// off.
+fn handle_button_toggles(
+    mut interactions: Query<(&Interaction, &mut AnimationControl), Changed<Interaction>>,
+    mut animation_players: Query<&AnimationGraphHandle, With<AnimationPlayer>>,
+    mut animation_graphs: ResMut<Assets<AnimationGraph>>,
+    mut animation_nodes: Option<ResMut<AnimationNodes>>,
+    mut app_state: ResMut<AppState>,
+) {
+    let Some(ref mut animation_nodes) = animation_nodes else {
+        return;
+    };
+
+    for (interaction, animation_control) in interactions.iter_mut() {
+        // We only care about press events.
+        if *interaction != Interaction::Pressed {
+            continue;
+        }
+
+        // Toggle the state of the clip.
+        app_state.0[animation_control.group_id as usize].clip = animation_control.label as u8;
+
+        // Now grab the animation player. (There's only one in our case, but we
+        // iterate just for clarity's sake.)
+        for animation_graph_handle in animation_players.iter_mut() {
+            // The animation graph needs to have loaded.
+            let Some(animation_graph) = animation_graphs.get_mut(animation_graph_handle) else {
+                continue;
+            };
+
+            for (clip_index, &animation_node_index) in animation_nodes.0.iter().enumerate() {
+                let Some(animation_node) = animation_graph.get_mut(animation_node_index) else {
+                    continue;
+                };
+
+                if animation_control.label as usize == clip_index {
+                    animation_node.mask &= !(1 << animation_control.group_id);
+                } else {
+                    animation_node.mask |= 1 << animation_control.group_id;
+                }
+            }
+        }
+    }
+}
+
+// A system that updates the UI based on the current app state.
+fn update_ui(
+    mut animation_controls: Query<(&AnimationControl, &mut BackgroundColor, &Children)>,
+    texts: Query<Entity, With<Text>>,
+    mut writer: TextUiWriter,
+    app_state: Res<AppState>,
+) {
+    for (animation_control, mut background_color, kids) in animation_controls.iter_mut() {
+        let enabled =
+            app_state.0[animation_control.group_id as usize].clip == animation_control.label as u8;
+
+        *background_color = if enabled {
+            BackgroundColor(Color::WHITE)
+        } else {
+            BackgroundColor(Color::BLACK)
+        };
+
+        for &kid in kids {
+            let Ok(text) = texts.get(kid) else {
+                continue;
+            };
+
+            writer.for_each_color(text, |mut color| {
+                color.0 = if enabled { Color::BLACK } else { Color::WHITE };
+            });
+        }
+    }
+}
+
+impl Default for AppState {
+    fn default() -> Self {
+        AppState([MaskGroupState { clip: 0 }; 6])
+    }
+}

vendor/bevy/examples/animation/color_animation.rs

@@ -0,0 +1,124 @@
+//! Demonstrates how to animate colors in different color spaces using mixing and splines.
+
+use bevy::{math::VectorSpace, prelude::*};
+
+// We define this trait so we can reuse the same code for multiple color types that may be implemented using curves.
+trait CurveColor: VectorSpace + Into<Color> + Send + Sync + 'static {}
+impl<T: VectorSpace + Into<Color> + Send + Sync + 'static> CurveColor for T {}
+
+// We define this trait so we can reuse the same code for multiple color types that may be implemented using mixing.
+trait MixedColor: Mix + Into<Color> + Send + Sync + 'static {}
+impl<T: Mix + Into<Color> + Send + Sync + 'static> MixedColor for T {}
+
+#[derive(Debug, Component)]
+struct Curve<T: CurveColor>(CubicCurve<T>);
+
+#[derive(Debug, Component)]
+struct Mixed<T: MixedColor>([T; 4]);
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_systems(Startup, setup)
+        .add_systems(
+            Update,
+            (
+                animate_curve::<LinearRgba>,
+                animate_curve::<Oklaba>,
+                animate_curve::<Xyza>,
+                animate_mixed::<Hsla>,
+                animate_mixed::<Srgba>,
+                animate_mixed::<Oklcha>,
+            ),
+        )
+        .run();
+}
+
+fn setup(mut commands: Commands) {
+    commands.spawn(Camera2d);
+
+    // The color spaces `Oklaba`, `Laba`, `LinearRgba`, `Srgba` and `Xyza` all are either perceptually or physically linear.
+    // This property allows us to define curves, e.g. bezier curves through these spaces.
+
+    // Define the control points for the curve.
+    // For more information, please see the cubic curve example.
+    let colors = [
+        LinearRgba::WHITE,
+        LinearRgba::rgb(1., 1., 0.), // Yellow
+        LinearRgba::RED,
+        LinearRgba::BLACK,
+    ];
+    // Spawn a sprite using the provided colors as control points.
+    spawn_curve_sprite(&mut commands, 275., colors);
+
+    // Spawn another sprite using the provided colors as control points after converting them to the `Xyza` color space.
+    spawn_curve_sprite(&mut commands, 175., colors.map(Xyza::from));
+
+    spawn_curve_sprite(&mut commands, 75., colors.map(Oklaba::from));
+
+    // Other color spaces like `Srgba` or `Hsva` are neither perceptually nor physically linear.
+    // As such, we cannot use curves in these spaces.
+    // However, we can still mix these colors and animate that way. In fact, mixing colors works in any color space.
+
+    // Spawn a sprite using the provided colors for mixing.
+    spawn_mixed_sprite(&mut commands, -75., colors.map(Hsla::from));
+
+    spawn_mixed_sprite(&mut commands, -175., colors.map(Srgba::from));
+
+    spawn_mixed_sprite(&mut commands, -275., colors.map(Oklcha::from));
+}
+
+fn spawn_curve_sprite<T: CurveColor>(commands: &mut Commands, y: f32, points: [T; 4]) {
+    commands.spawn((
+        Sprite::sized(Vec2::new(75., 75.)),
+        Transform::from_xyz(0., y, 0.),
+        Curve(CubicBezier::new([points]).to_curve().unwrap()),
+    ));
+}
+
+fn spawn_mixed_sprite<T: MixedColor>(commands: &mut Commands, y: f32, colors: [T; 4]) {
+    commands.spawn((
+        Transform::from_xyz(0., y, 0.),
+        Sprite::sized(Vec2::new(75., 75.)),
+        Mixed(colors),
+    ));
+}
+
+fn animate_curve<T: CurveColor>(
+    time: Res<Time>,
+    mut query: Query<(&mut Transform, &mut Sprite, &Curve<T>)>,
+) {
+    let t = (ops::sin(time.elapsed_secs()) + 1.) / 2.;
+
+    for (mut transform, mut sprite, cubic_curve) in &mut query {
+        // position takes a point from the curve where 0 is the initial point
+        // and 1 is the last point
+        sprite.color = cubic_curve.0.position(t).into();
+        transform.translation.x = 600. * (t - 0.5);
+    }
+}
+
+fn animate_mixed<T: MixedColor>(
+    time: Res<Time>,
+    mut query: Query<(&mut Transform, &mut Sprite, &Mixed<T>)>,
+) {
+    let t = (ops::sin(time.elapsed_secs()) + 1.) / 2.;
+
+    for (mut transform, mut sprite, mixed) in &mut query {
+        sprite.color = {
+            // First, we determine the amount of intervals between colors.
+            // For four colors, there are three intervals between those colors;
+            let intervals = (mixed.0.len() - 1) as f32;
+
+            // Next we determine the index of the first of the two colors to mix.
+            let start_i = (t * intervals).floor().min(intervals - 1.);
+
+            // Lastly we determine the 'local' value of t in this interval.
+            let local_t = (t * intervals) - start_i;
+
+            let color = mixed.0[start_i as usize].mix(&mixed.0[start_i as usize + 1], local_t);
+            color.into()
+        };
+        transform.translation.x = 600. * (t - 0.5);
+    }
+}

vendor/bevy/examples/animation/custom_skinned_mesh.rs

@@ -0,0 +1,235 @@
+//! Skinned mesh example with mesh and joints data defined in code.
+//! Example taken from <https://github.com/KhronosGroup/glTF-Tutorials/blob/master/gltfTutorial/gltfTutorial_019_SimpleSkin.md>
+
+use std::f32::consts::*;
+
+use bevy::{
+    math::ops,
+    prelude::*,
+    render::{
+        mesh::{
+            skinning::{SkinnedMesh, SkinnedMeshInverseBindposes},
+            Indices, PrimitiveTopology, VertexAttributeValues,
+        },
+        render_asset::RenderAssetUsages,
+    },
+};
+use rand::{Rng, SeedableRng};
+use rand_chacha::ChaCha8Rng;
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .insert_resource(AmbientLight {
+            brightness: 3000.0,
+            ..default()
+        })
+        .add_systems(Startup, setup)
+        .add_systems(Update, joint_animation)
+        .run();
+}
+
+/// Used to mark a joint to be animated in the [`joint_animation`] system.
+#[derive(Component)]
+struct AnimatedJoint(isize);
+
+/// Construct a mesh and a skeleton with 2 joints for that mesh,
+///   and mark the second joint to be animated.
+/// It is similar to the scene defined in `models/SimpleSkin/SimpleSkin.gltf`
+fn setup(
+    mut commands: Commands,
+    asset_server: Res<AssetServer>,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+    mut skinned_mesh_inverse_bindposes_assets: ResMut<Assets<SkinnedMeshInverseBindposes>>,
+) {
+    // Create a camera
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(2.5, 2.5, 9.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+
+    // Create inverse bindpose matrices for a skeleton consists of 2 joints
+    let inverse_bindposes = skinned_mesh_inverse_bindposes_assets.add(vec![
+        Mat4::from_translation(Vec3::new(-0.5, -1.0, 0.0)),
+        Mat4::from_translation(Vec3::new(-0.5, -1.0, 0.0)),
+    ]);
+
+    // Create a mesh
+    let mesh = Mesh::new(
+        PrimitiveTopology::TriangleList,
+        RenderAssetUsages::RENDER_WORLD,
+    )
+    // Set mesh vertex positions
+    .with_inserted_attribute(
+        Mesh::ATTRIBUTE_POSITION,
+        vec![
+            [0.0, 0.0, 0.0],
+            [1.0, 0.0, 0.0],
+            [0.0, 0.5, 0.0],
+            [1.0, 0.5, 0.0],
+            [0.0, 1.0, 0.0],
+            [1.0, 1.0, 0.0],
+            [0.0, 1.5, 0.0],
+            [1.0, 1.5, 0.0],
+            [0.0, 2.0, 0.0],
+            [1.0, 2.0, 0.0],
+        ],
+    )
+    // Add UV coordinates that map the left half of the texture since its a 1 x
+    // 2 rectangle.
+    .with_inserted_attribute(
+        Mesh::ATTRIBUTE_UV_0,
+        vec![
+            [0.0, 0.00],
+            [0.5, 0.00],
+            [0.0, 0.25],
+            [0.5, 0.25],
+            [0.0, 0.50],
+            [0.5, 0.50],
+            [0.0, 0.75],
+            [0.5, 0.75],
+            [0.0, 1.00],
+            [0.5, 1.00],
+        ],
+    )
+    // Set mesh vertex normals
+    .with_inserted_attribute(Mesh::ATTRIBUTE_NORMAL, vec![[0.0, 0.0, 1.0]; 10])
+    // Set mesh vertex joint indices for mesh skinning.
+    // Each vertex gets 4 indices used to address the `JointTransforms` array in the vertex shader
+    //  as well as `SkinnedMeshJoint` array in the `SkinnedMesh` component.
+    // This means that a maximum of 4 joints can affect a single vertex.
+    .with_inserted_attribute(
+        Mesh::ATTRIBUTE_JOINT_INDEX,
+        // Need to be explicit here as [u16; 4] could be either Uint16x4 or Unorm16x4.
+        VertexAttributeValues::Uint16x4(vec![
+            [0, 0, 0, 0],
+            [0, 0, 0, 0],
+            [0, 1, 0, 0],
+            [0, 1, 0, 0],
+            [0, 1, 0, 0],
+            [0, 1, 0, 0],
+            [0, 1, 0, 0],
+            [0, 1, 0, 0],
+            [0, 1, 0, 0],
+            [0, 1, 0, 0],
+        ]),
+    )
+    // Set mesh vertex joint weights for mesh skinning.
+    // Each vertex gets 4 joint weights corresponding to the 4 joint indices assigned to it.
+    // The sum of these weights should equal to 1.
+    .with_inserted_attribute(
+        Mesh::ATTRIBUTE_JOINT_WEIGHT,
+        vec![
+            [1.00, 0.00, 0.0, 0.0],
+            [1.00, 0.00, 0.0, 0.0],
+            [0.75, 0.25, 0.0, 0.0],
+            [0.75, 0.25, 0.0, 0.0],
+            [0.50, 0.50, 0.0, 0.0],
+            [0.50, 0.50, 0.0, 0.0],
+            [0.25, 0.75, 0.0, 0.0],
+            [0.25, 0.75, 0.0, 0.0],
+            [0.00, 1.00, 0.0, 0.0],
+            [0.00, 1.00, 0.0, 0.0],
+        ],
+    )
+    // Tell bevy to construct triangles from a list of vertex indices,
+    // where each 3 vertex indices form a triangle.
+    .with_inserted_indices(Indices::U16(vec![
+        0, 1, 3, 0, 3, 2, 2, 3, 5, 2, 5, 4, 4, 5, 7, 4, 7, 6, 6, 7, 9, 6, 9, 8,
+    ]));
+
+    let mesh = meshes.add(mesh);
+
+    // We're seeding the PRNG here to make this example deterministic for testing purposes.
+    // This isn't strictly required in practical use unless you need your app to be deterministic.
+    let mut rng = ChaCha8Rng::seed_from_u64(42);
+
+    for i in -5..5 {
+        // Create joint entities
+        let joint_0 = commands
+            .spawn(Transform::from_xyz(
+                i as f32 * 1.5,
+                0.0,
+                // Move quads back a small amount to avoid Z-fighting and not
+                // obscure the transform gizmos.
+                -(i as f32 * 0.01).abs(),
+            ))
+            .id();
+        let joint_1 = commands.spawn((AnimatedJoint(i), Transform::IDENTITY)).id();
+
+        // Set joint_1 as a child of joint_0.
+        commands.entity(joint_0).add_children(&[joint_1]);
+
+        // Each joint in this vector corresponds to each inverse bindpose matrix in `SkinnedMeshInverseBindposes`.
+        let joint_entities = vec![joint_0, joint_1];
+
+        // Create skinned mesh renderer. Note that its transform doesn't affect the position of the mesh.
+        commands.spawn((
+            Mesh3d(mesh.clone()),
+            MeshMaterial3d(materials.add(StandardMaterial {
+                base_color: Color::srgb(
+                    rng.gen_range(0.0..1.0),
+                    rng.gen_range(0.0..1.0),
+                    rng.gen_range(0.0..1.0),
+                ),
+                base_color_texture: Some(asset_server.load("textures/uv_checker_bw.png")),
+                ..default()
+            })),
+            SkinnedMesh {
+                inverse_bindposes: inverse_bindposes.clone(),
+                joints: joint_entities,
+            },
+        ));
+    }
+}
+
+/// Animate the joint marked with [`AnimatedJoint`] component.
+fn joint_animation(
+    time: Res<Time>,
+    mut query: Query<(&mut Transform, &AnimatedJoint)>,
+    mut gizmos: Gizmos,
+) {
+    for (mut transform, animated_joint) in &mut query {
+        match animated_joint.0 {
+            -5 => {
+                transform.rotation =
+                    Quat::from_rotation_x(FRAC_PI_2 * ops::sin(time.elapsed_secs()));
+            }
+            -4 => {
+                transform.rotation =
+                    Quat::from_rotation_y(FRAC_PI_2 * ops::sin(time.elapsed_secs()));
+            }
+            -3 => {
+                transform.rotation =
+                    Quat::from_rotation_z(FRAC_PI_2 * ops::sin(time.elapsed_secs()));
+            }
+            -2 => {
+                transform.scale.x = ops::sin(time.elapsed_secs()) + 1.0;
+            }
+            -1 => {
+                transform.scale.y = ops::sin(time.elapsed_secs()) + 1.0;
+            }
+            0 => {
+                transform.translation.x = 0.5 * ops::sin(time.elapsed_secs());
+                transform.translation.y = ops::cos(time.elapsed_secs());
+            }
+            1 => {
+                transform.translation.y = ops::sin(time.elapsed_secs());
+                transform.translation.z = ops::cos(time.elapsed_secs());
+            }
+            2 => {
+                transform.translation.x = ops::sin(time.elapsed_secs());
+            }
+            3 => {
+                transform.translation.y = ops::sin(time.elapsed_secs());
+                transform.scale.x = ops::sin(time.elapsed_secs()) + 1.0;
+            }
+            _ => (),
+        }
+        // Show transform
+        let mut axis = *transform;
+        axis.translation.x += animated_joint.0 as f32 * 1.5;
+        gizmos.axes(axis, 1.0);
+    }
+}

vendor/bevy/examples/animation/eased_motion.rs

@@ -0,0 +1,154 @@
+//! Demonstrates the application of easing curves to animate a transition.
+
+use std::f32::consts::FRAC_PI_2;
+
+use bevy::{
+    animation::{animated_field, AnimationTarget, AnimationTargetId},
+    color::palettes::css::{ORANGE, SILVER},
+    math::vec3,
+    prelude::*,
+};
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_systems(Startup, setup)
+        .run();
+}
+
+fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+    mut animation_graphs: ResMut<Assets<AnimationGraph>>,
+    mut animation_clips: ResMut<Assets<AnimationClip>>,
+) {
+    // Create the animation:
+    let AnimationInfo {
+        target_name: animation_target_name,
+        target_id: animation_target_id,
+        graph: animation_graph,
+        node_index: animation_node_index,
+    } = AnimationInfo::create(&mut animation_graphs, &mut animation_clips);
+
+    // Build an animation player that automatically plays the animation.
+    let mut animation_player = AnimationPlayer::default();
+    animation_player.play(animation_node_index).repeat();
+
+    // A cube together with the components needed to animate it
+    let cube_entity = commands
+        .spawn((
+            Mesh3d(meshes.add(Cuboid::from_length(2.0))),
+            MeshMaterial3d(materials.add(Color::from(ORANGE))),
+            Transform::from_translation(vec3(-6., 2., 0.)),
+            animation_target_name,
+            animation_player,
+            AnimationGraphHandle(animation_graph),
+        ))
+        .id();
+
+    commands.entity(cube_entity).insert(AnimationTarget {
+        id: animation_target_id,
+        player: cube_entity,
+    });
+
+    // Some light to see something
+    commands.spawn((
+        PointLight {
+            shadows_enabled: true,
+            intensity: 10_000_000.,
+            range: 100.0,
+            ..default()
+        },
+        Transform::from_xyz(8., 16., 8.),
+    ));
+
+    // Ground plane
+    commands.spawn((
+        Mesh3d(meshes.add(Plane3d::default().mesh().size(50., 50.))),
+        MeshMaterial3d(materials.add(Color::from(SILVER))),
+    ));
+
+    // The camera
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(0., 6., 12.).looking_at(Vec3::new(0., 1.5, 0.), Vec3::Y),
+    ));
+}
+
+// Holds information about the animation we programmatically create.
+struct AnimationInfo {
+    // The name of the animation target (in this case, the text).
+    target_name: Name,
+    // The ID of the animation target, derived from the name.
+    target_id: AnimationTargetId,
+    // The animation graph asset.
+    graph: Handle<AnimationGraph>,
+    // The index of the node within that graph.
+    node_index: AnimationNodeIndex,
+}
+
+impl AnimationInfo {
+    // Programmatically creates the UI animation.
+    fn create(
+        animation_graphs: &mut Assets<AnimationGraph>,
+        animation_clips: &mut Assets<AnimationClip>,
+    ) -> AnimationInfo {
+        // Create an ID that identifies the text node we're going to animate.
+        let animation_target_name = Name::new("Cube");
+        let animation_target_id = AnimationTargetId::from_name(&animation_target_name);
+
+        // Allocate an animation clip.
+        let mut animation_clip = AnimationClip::default();
+
+        // Each leg of the translation motion should take 3 seconds.
+        let animation_domain = interval(0.0, 3.0).unwrap();
+
+        // The easing curve is parametrized over [0, 1], so we reparametrize it and
+        // then ping-pong, which makes it spend another 3 seconds on the return journey.
+        let translation_curve = EasingCurve::new(
+            vec3(-6., 2., 0.),
+            vec3(6., 2., 0.),
+            EaseFunction::CubicInOut,
+        )
+        .reparametrize_linear(animation_domain)
+        .expect("this curve has bounded domain, so this should never fail")
+        .ping_pong()
+        .expect("this curve has bounded domain, so this should never fail");
+
+        // Something similar for rotation. The repetition here is an illusion caused
+        // by the symmetry of the cube; it rotates on the forward journey and never
+        // rotates back.
+        let rotation_curve = EasingCurve::new(
+            Quat::IDENTITY,
+            Quat::from_rotation_y(FRAC_PI_2),
+            EaseFunction::ElasticInOut,
+        )
+        .reparametrize_linear(interval(0.0, 4.0).unwrap())
+        .expect("this curve has bounded domain, so this should never fail");
+
+        animation_clip.add_curve_to_target(
+            animation_target_id,
+            AnimatableCurve::new(animated_field!(Transform::translation), translation_curve),
+        );
+        animation_clip.add_curve_to_target(
+            animation_target_id,
+            AnimatableCurve::new(animated_field!(Transform::rotation), rotation_curve),
+        );
+
+        // Save our animation clip as an asset.
+        let animation_clip_handle = animation_clips.add(animation_clip);
+
+        // Create an animation graph with that clip.
+        let (animation_graph, animation_node_index) =
+            AnimationGraph::from_clip(animation_clip_handle);
+        let animation_graph_handle = animation_graphs.add(animation_graph);
+
+        AnimationInfo {
+            target_name: animation_target_name,
+            target_id: animation_target_id,
+            graph: animation_graph_handle,
+            node_index: animation_node_index,
+        }
+    }
+}

vendor/bevy/examples/animation/easing_functions.rs

@@ -0,0 +1,188 @@
+//! Demonstrates the behavior of the built-in easing functions.
+
+use bevy::prelude::*;
+
+#[derive(Component)]
+#[require(Visibility, Transform)]
+struct EaseFunctionPlot(EaseFunction, Color);
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_systems(Startup, setup)
+        .add_systems(Update, display_curves)
+        .run();
+}
+
+const COLS: usize = 12;
+const EXTENT: Vec2 = Vec2::new(1172.0, 520.0);
+const PLOT_SIZE: Vec2 = Vec2::splat(80.0);
+
+fn setup(mut commands: Commands) {
+    commands.spawn(Camera2d);
+
+    let text_font = TextFont {
+        font_size: 10.0,
+        ..default()
+    };
+
+    let chunks = [
+        // "In" row
+        EaseFunction::SineIn,
+        EaseFunction::QuadraticIn,
+        EaseFunction::CubicIn,
+        EaseFunction::QuarticIn,
+        EaseFunction::QuinticIn,
+        EaseFunction::SmoothStepIn,
+        EaseFunction::SmootherStepIn,
+        EaseFunction::CircularIn,
+        EaseFunction::ExponentialIn,
+        EaseFunction::ElasticIn,
+        EaseFunction::BackIn,
+        EaseFunction::BounceIn,
+        // "Out" row
+        EaseFunction::SineOut,
+        EaseFunction::QuadraticOut,
+        EaseFunction::CubicOut,
+        EaseFunction::QuarticOut,
+        EaseFunction::QuinticOut,
+        EaseFunction::SmoothStepOut,
+        EaseFunction::SmootherStepOut,
+        EaseFunction::CircularOut,
+        EaseFunction::ExponentialOut,
+        EaseFunction::ElasticOut,
+        EaseFunction::BackOut,
+        EaseFunction::BounceOut,
+        // "InOut" row
+        EaseFunction::SineInOut,
+        EaseFunction::QuadraticInOut,
+        EaseFunction::CubicInOut,
+        EaseFunction::QuarticInOut,
+        EaseFunction::QuinticInOut,
+        EaseFunction::SmoothStep,
+        EaseFunction::SmootherStep,
+        EaseFunction::CircularInOut,
+        EaseFunction::ExponentialInOut,
+        EaseFunction::ElasticInOut,
+        EaseFunction::BackInOut,
+        EaseFunction::BounceInOut,
+        // "Other" row
+        EaseFunction::Linear,
+        EaseFunction::Steps(4, JumpAt::End),
+        EaseFunction::Steps(4, JumpAt::Start),
+        EaseFunction::Steps(4, JumpAt::Both),
+        EaseFunction::Steps(4, JumpAt::None),
+        EaseFunction::Elastic(50.0),
+    ]
+    .chunks(COLS);
+
+    let max_rows = chunks.clone().count();
+
+    let half_extent = EXTENT / 2.;
+    let half_size = PLOT_SIZE / 2.;
+
+    for (row, functions) in chunks.enumerate() {
+        for (col, function) in functions.iter().enumerate() {
+            let color = Hsla::hsl(col as f32 / COLS as f32 * 360.0, 0.8, 0.75).into();
+            commands
+                .spawn((
+                    EaseFunctionPlot(*function, color),
+                    Transform::from_xyz(
+                        -half_extent.x + EXTENT.x / (COLS - 1) as f32 * col as f32,
+                        half_extent.y - EXTENT.y / (max_rows - 1) as f32 * row as f32,
+                        0.0,
+                    ),
+                ))
+                .with_children(|p| {
+                    // Marks the y value on the right side of the plot
+                    p.spawn((
+                        Sprite::from_color(color, Vec2::splat(5.0)),
+                        Transform::from_xyz(half_size.x + 5.0, -half_size.y, 0.0),
+                    ));
+                    // Marks the x and y value inside the plot
+                    p.spawn((
+                        Sprite::from_color(color, Vec2::splat(4.0)),
+                        Transform::from_xyz(-half_size.x, -half_size.y, 0.0),
+                    ));
+
+                    // Label
+                    p.spawn((
+                        Text2d(format!("{:?}", function)),
+                        text_font.clone(),
+                        TextColor(color),
+                        Transform::from_xyz(0.0, -half_size.y - 15.0, 0.0),
+                    ));
+                });
+        }
+    }
+    commands.spawn((
+        Text::default(),
+        Node {
+            position_type: PositionType::Absolute,
+            top: Val::Px(12.0),
+            left: Val::Px(12.0),
+            ..default()
+        },
+    ));
+}
+
+fn display_curves(
+    mut gizmos: Gizmos,
+    ease_functions: Query<(&EaseFunctionPlot, &Transform, &Children)>,
+    mut transforms: Query<&mut Transform, Without<EaseFunctionPlot>>,
+    mut ui_text: Single<&mut Text>,
+    time: Res<Time>,
+) {
+    let samples = 100;
+    let duration = 2.5;
+    let time_margin = 0.5;
+
+    let now = ((time.elapsed_secs() % (duration + time_margin * 2.0) - time_margin) / duration)
+        .clamp(0.0, 1.0);
+
+    ui_text.0 = format!("Progress: {:.2}", now);
+
+    for (EaseFunctionPlot(function, color), transform, children) in &ease_functions {
+        let center = transform.translation.xy();
+        let half_size = PLOT_SIZE / 2.0;
+
+        // Draw a box around the curve
+        gizmos.linestrip_2d(
+            [
+                center + half_size,
+                center + half_size * Vec2::new(-1., 1.),
+                center + half_size * Vec2::new(-1., -1.),
+                center + half_size * Vec2::new(1., -1.),
+                center + half_size,
+            ],
+            color.darker(0.4),
+        );
+
+        // Draw the curve
+        let f = EasingCurve::new(0.0, 1.0, *function);
+        let drawn_curve = f
+            .by_ref()
+            .graph()
+            .map(|(x, y)| center - half_size + Vec2::new(x, y) * PLOT_SIZE);
+        gizmos.curve_2d(
+            &drawn_curve,
+            drawn_curve.domain().spaced_points(samples).unwrap(),
+            *color,
+        );
+
+        // Show progress along the curve for the current time
+        let y = f.sample(now).unwrap() * PLOT_SIZE.y;
+        transforms.get_mut(children[0]).unwrap().translation.y = -half_size.y + y;
+        transforms.get_mut(children[1]).unwrap().translation =
+            -half_size.extend(0.0) + Vec3::new(now * PLOT_SIZE.x, y, 0.0);
+
+        // Show horizontal bar at y value
+        gizmos.linestrip_2d(
+            [
+                center - half_size + Vec2::Y * y,
+                center - half_size + Vec2::new(PLOT_SIZE.x, y),
+            ],
+            color.darker(0.2),
+        );
+    }
+}

vendor/bevy/examples/animation/gltf_skinned_mesh.rs

@@ -0,0 +1,71 @@
+//! Skinned mesh example with mesh and joints data loaded from a glTF file.
+//! Example taken from <https://github.com/KhronosGroup/glTF-Tutorials/blob/master/gltfTutorial/gltfTutorial_019_SimpleSkin.md>
+
+use std::f32::consts::*;
+
+use bevy::{math::ops, prelude::*, render::mesh::skinning::SkinnedMesh};
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .insert_resource(AmbientLight {
+            brightness: 750.0,
+            ..default()
+        })
+        .add_systems(Startup, setup)
+        .add_systems(Update, joint_animation)
+        .run();
+}
+
+fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
+    // Create a camera
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(-2.0, 2.5, 5.0).looking_at(Vec3::new(0.0, 1.0, 0.0), Vec3::Y),
+    ));
+
+    // Spawn the first scene in `models/SimpleSkin/SimpleSkin.gltf`
+    commands.spawn(SceneRoot(asset_server.load(
+        GltfAssetLabel::Scene(0).from_asset("models/SimpleSkin/SimpleSkin.gltf"),
+    )));
+}
+
+/// The scene hierarchy currently looks somewhat like this:
+///
+/// ```text
+/// <Parent entity>
+///   + Mesh node (without `Mesh3d` or `SkinnedMesh` component)
+///     + Skinned mesh entity (with `Mesh3d` and `SkinnedMesh` component, created by glTF loader)
+///     + First joint
+///       + Second joint
+/// ```
+///
+/// In this example, we want to get and animate the second joint.
+/// It is similar to the animation defined in `models/SimpleSkin/SimpleSkin.gltf`.
+fn joint_animation(
+    time: Res<Time>,
+    children: Query<&ChildOf, With<SkinnedMesh>>,
+    parents: Query<&Children>,
+    mut transform_query: Query<&mut Transform>,
+) {
+    // Iter skinned mesh entity
+    for child_of in &children {
+        // Mesh node is the parent of the skinned mesh entity.
+        let mesh_node_entity = child_of.parent();
+        // Get `Children` in the mesh node.
+        let mesh_node_parent = parents.get(mesh_node_entity).unwrap();
+
+        // First joint is the second child of the mesh node.
+        let first_joint_entity = mesh_node_parent[1];
+        // Get `Children` in the first joint.
+        let first_joint_children = parents.get(first_joint_entity).unwrap();
+
+        // Second joint is the first child of the first joint.
+        let second_joint_entity = first_joint_children[0];
+        // Get `Transform` in the second joint.
+        let mut second_joint_transform = transform_query.get_mut(second_joint_entity).unwrap();
+
+        second_joint_transform.rotation =
+            Quat::from_rotation_z(FRAC_PI_2 * ops::sin(time.elapsed_secs()));
+    }
+}

vendor/bevy/examples/animation/morph_targets.rs

@@ -0,0 +1,112 @@
+//! Controls morph targets in a loaded scene.
+//!
+//! Illustrates:
+//!
+//! - How to access and modify individual morph target weights.
+//!   See the `update_weights` system for details.
+//! - How to read morph target names in `name_morphs`.
+//! - How to play morph target animations in `setup_animations`.
+
+use bevy::prelude::*;
+use std::f32::consts::PI;
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins.set(WindowPlugin {
+            primary_window: Some(Window {
+                title: "morph targets".to_string(),
+                ..default()
+            }),
+            ..default()
+        }))
+        .insert_resource(AmbientLight {
+            brightness: 150.0,
+            ..default()
+        })
+        .add_systems(Startup, setup)
+        .add_systems(Update, (name_morphs, setup_animations))
+        .run();
+}
+
+#[derive(Resource)]
+struct MorphData {
+    the_wave: Handle<AnimationClip>,
+    mesh: Handle<Mesh>,
+}
+
+fn setup(asset_server: Res<AssetServer>, mut commands: Commands) {
+    commands.insert_resource(MorphData {
+        the_wave: asset_server
+            .load(GltfAssetLabel::Animation(2).from_asset("models/animated/MorphStressTest.gltf")),
+        mesh: asset_server.load(
+            GltfAssetLabel::Primitive {
+                mesh: 0,
+                primitive: 0,
+            }
+            .from_asset("models/animated/MorphStressTest.gltf"),
+        ),
+    });
+    commands.spawn(SceneRoot(asset_server.load(
+        GltfAssetLabel::Scene(0).from_asset("models/animated/MorphStressTest.gltf"),
+    )));
+    commands.spawn((
+        DirectionalLight::default(),
+        Transform::from_rotation(Quat::from_rotation_z(PI / 2.0)),
+    ));
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(3.0, 2.1, 10.2).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+}
+
+/// Plays an [`AnimationClip`] from the loaded [`Gltf`] on the [`AnimationPlayer`] created by the spawned scene.
+fn setup_animations(
+    mut has_setup: Local<bool>,
+    mut commands: Commands,
+    mut players: Query<(Entity, &Name, &mut AnimationPlayer)>,
+    morph_data: Res<MorphData>,
+    mut graphs: ResMut<Assets<AnimationGraph>>,
+) {
+    if *has_setup {
+        return;
+    }
+    for (entity, name, mut player) in &mut players {
+        // The name of the entity in the GLTF scene containing the AnimationPlayer for our morph targets is "Main"
+        if name.as_str() != "Main" {
+            continue;
+        }
+
+        let (graph, animation) = AnimationGraph::from_clip(morph_data.the_wave.clone());
+        commands
+            .entity(entity)
+            .insert(AnimationGraphHandle(graphs.add(graph)));
+
+        player.play(animation).repeat();
+        *has_setup = true;
+    }
+}
+
+/// You can get the target names in their corresponding [`Mesh`].
+/// They are in the order of the weights.
+fn name_morphs(
+    mut has_printed: Local<bool>,
+    morph_data: Res<MorphData>,
+    meshes: Res<Assets<Mesh>>,
+) {
+    if *has_printed {
+        return;
+    }
+
+    let Some(mesh) = meshes.get(&morph_data.mesh) else {
+        return;
+    };
+    let Some(names) = mesh.morph_target_names() else {
+        return;
+    };
+
+    info!("Target names:");
+    for name in names {
+        info!("  {name}");
+    }
+    *has_printed = true;
+}