bevy-animation
Use when wiring `AnimationPlayer` + `AnimationGraphHandle`, building an `AnimationGraph` from glTF clips, blending state-driven animations with `AnimationTransitions::play`, isolating body parts with `AnimationMask`, firing gameplay sync via `#[derive(AnimationEvent)]` + `On<E>` observers, tweening with `AnimatableCurve` / `EaseFunction` / `CubicSegment::new_bezier_easing` from `bevy::curve`, or applying the 12 Basic Principles of Animation to 3D characters in Bevy 0.20.
How do I install this agent skill?
npx skills add https://github.com/chrisgliddon/bevy-skills --skill bevy-animationIs this agent skill safe to install?
- Gen Agent Trust Hubpass
The skill provides comprehensive documentation and code examples for the Bevy 0.20 animation system, including animation graphs, blending, events, and procedural animation. No security issues were detected.
- Socketpass
No alerts
- Snykpass
Risk: LOW · No issues
What does this agent skill do?
Bevy 0.20 — Animation (graphs, blending, events, 12 principles)
When to use this skill
- Loading a glTF clip and playing it on a character:
AnimationPlayer+AnimationGraphHandle. - Cross-fading between idle / walk / run via
AnimationTransitions::play(player, node, Duration). - Building an
AnimationGraphin code: blend nodes, additive nodes, weights,AnimationMask. - Triggering gameplay events from a clip timeline (footsteps, hitbox activation, VFX cues) with
#[derive(AnimationEvent)]+clip.add_event_to_target(...)+On<MyEvent>observers. - Procedural tweening without an
AnimationClip— sampling aCurveper frame viaEasingCurve+EaseFunctionorCubicSegment::new_bezier_easing. - Applying the 12 Basic Principles of Animation (Thomas & Johnston, 1981) to a Bevy character.
- Importing a Blender rig and finding bones aren't animated — usually the
Namerequirement forAnimationTargetId::from_name. - Fixing
bevy::math::curve/bevy::math::cubic_splinesimport errors after upgrading to 0.20.
Canonical end-to-end pattern
Verified against bevy = "0.20" — cargo check clean in bevy-skills-tester/examples/bevy_animation.rs.
use bevy::{
animation::{
animated_field,
animation_curves::{AnimatableCurve, AnimatableKeyframeCurve},
AnimationEvent, AnimationTargetId,
},
prelude::*,
};
use core::time::Duration;
#[derive(AnimationEvent, Clone)]
struct FootstepEvent { foot: u8 }
fn setup(
mut commands: Commands,
asset_server: Res<AssetServer>,
mut clips: ResMut<Assets<AnimationClip>>,
mut graphs: ResMut<Assets<AnimationGraph>>,
) {
// 1. Load a glTF clip
let walk: Handle<AnimationClip> =
asset_server.load("models/character.glb#Animation0");
// 2. Build a tiny procedural clip with a sample curve + an event
let bone = AnimationTargetId::from_name(&Name::new("Hips"));
let tween = AnimatableKeyframeCurve::new([
(0.0_f32, Vec3::ZERO),
(0.5, Vec3::new(0.0, 1.0, 0.0)),
(1.0, Vec3::ZERO),
]).expect("strictly-increasing times");
let curve = AnimatableCurve::new(animated_field!(Transform::translation), tween);
let mut proc = AnimationClip::default();
proc.add_curve_to_target(bone, curve);
proc.add_event(0.5, FootstepEvent { foot: 0 });
let proc = clips.add(proc);
// 3. Compose a graph: root → walk + additive(proc, mask=group 0 excluded)
const MASK_GROUP_0_BIT: u64 = 1 << 0;
let mut graph = AnimationGraph::new();
let root = graph.root;
let _walk_node = graph.add_clip(walk, 1.0, root);
let additive = graph.add_additive_blend(0.5, root);
let _proc_node = graph.add_clip_with_mask(proc, MASK_GROUP_0_BIT, 1.0, additive);
// 4. Spawn the player entity (bones come from the loaded glTF scene)
commands.spawn((
Name::new("AnimationRoot"),
AnimationPlayer::default(),
AnimationGraphHandle(graphs.add(graph)),
AnimationTransitions::new(),
));
}
fn start(mut q: Query<(&mut AnimationTransitions, &mut AnimationPlayer), Added<AnimationPlayer>>) {
use bevy::animation::{graph::AnimationNodeIndex, RepeatAnimation};
for (mut tx, mut player) in &mut q {
tx.play(&mut player, AnimationNodeIndex::new(1), Duration::from_millis(250))
.set_repeat(RepeatAnimation::Forever);
}
}
fn on_footstep(trigger: On<FootstepEvent>) {
let foot = trigger.foot; // On<E> derefs to &E
let _entity = trigger.trigger().target; // AnimationEventTrigger::target
let _ = foot;
}
fn main() {
App::new()
.add_plugins(DefaultPlugins) // gltf_animation is a default feature
.add_systems(Startup, setup)
.add_systems(Update, start)
.add_observer(on_footstep)
.run();
}
Topics
| Topic | Reference |
|---|---|
Building blend / additive graphs, AnimationMask, hot-swap | references/animation-graph.md |
Blender → glTF → Bevy import: Name, axis, multi-clip, morph targets, unsupported extensions | references/gltf-import.md |
Procedural animation in Update vs FixedUpdate, root-motion extraction | references/procedural-animation.md |
Idle / walk / run blending; AnimationTransitions::play + Bevy States integration | references/state-machines.md |
#[derive(AnimationEvent)], add_event_to_target, On<E> observer wiring | references/animation-events.md |
AnimatableCurve, EasingCurve, EaseFunction, cubic-bezier, UnevenSampleAutoCurve | references/curves-and-tweening.md |
AnimationPlayer cost, skin buffers, graph complexity, runtime graph swaps | references/performance.md |
| Principles — Slow In/Out, Timing, Anticipation → easing + duration | references/principles-easing-and-timing.md |
Principles — Squash & Stretch, Arc, Exaggeration → Transform keyframes | references/principles-transform-keyframes.md |
| Principles — Staging, Follow Through, Secondary Action → graph layering + masks | references/principles-graph-layering.md |
| Principles — Straight-Ahead vs Pose-to-Pose, Solid Drawing, Appeal → upstream authoring | references/principles-authoring.md |
The 12 Basic Principles of Animation
The four principles-*.md references group Thomas & Johnston's twelve principles by which Bevy primitive they actually exercise. Quick map:
- Easing & Timing — Slow In/Out, Timing, Anticipation map to
EaseFunction/EasingCurve/CubicSegment::new_bezier_easingand clip duration +ActiveAnimation::set_speed. - Transform keyframes — Squash & Stretch, Arc, Exaggeration are
AnimatableKeyframeCurveoverTransform::scale/::translationviaanimated_field!. - Graph layering — Staging, Follow Through & Overlapping Action, Secondary Action are
AnimationGraph::add_additive_blend+AnimationMaskgroup isolation. - Authoring — Straight-Ahead vs Pose-to-Pose, Solid Drawing, Appeal live in your DCC tool (Blender, Maya). Bevy plays whatever you authored.
Gotchas
- 0.20: curves moved to
bevy_curve.bevy::math::curve::{EasingCurve, EaseFunction}andbevy::math::cubic_splines::CubicSegmentare nowbevy::curve::{EasingCurve, EaseFunction}andbevy::curve::cubic_splines::CubicSegment.bevy::preludestill re-exports them, so most code only needs theuselines fixed. Signatures are unchanged (EasingCurve::new(start, end, ease_fn),CubicSegment::new_bezier_easing(p1, p2)). - 0.19:
AnimationTargetIdhash algorithm changed. Different joint hierarchies no longer collide. Regenerate any serialized target IDs; IDs computed at runtime withfrom_name/from_iterare fine. - 0.19: morph targets live in
Mesh.GltfAssetLabel::MorphTargetis gone;MeshMorphWeightscan reference an entity withMorphWeightsinstead of being auto-copied. Seereferences/gltf-import.md. - 0.20: observers lost the bundle generic.
On<E>is unchanged forAnimationEvents. Lifecycle observers on bone entities areOn<Add<AnimatedBy>>, notOn<Add, AnimatedBy>. - 0.17 → 0.18 split.
AnimationTarget { id, player }no longer exists. It's two components on each bone entity:AnimationTargetId(Uuid)+AnimatedBy(Entity). The glTF loader spawns these for you. gltf_animationis on by default. No opt-in needed unless you randefault-features = false.AnimationTransitions::play_with_transitiondoes NOT exist. The only method isplay(&mut self, player, node, Duration) -> &mut ActiveAnimation. Chain.set_repeat(RepeatAnimation::Forever)/.set_speed(f32)on the returned value.animated_field!andAnimatableCurveare not in the prelude. Import frombevy::animation::{animated_field, animation_curves::{AnimatableCurve, AnimatableKeyframeCurve}}.On<AnimationEvent>is not anEntityEventobserver.On<E>derefs to&E. The firing entity istrigger.trigger().target(AnimationEventTrigger::target)..target()/.entityare not available.Nameis required on bone entities forAnimationTargetId::from_name(&Name)to resolve. The glTF loader sets this; hand-built skeletons must too. Since 0.20Name::newfrom&strneeds'static; useStringfor runtime names.AnimationMaskbit polarity. A set bit means that node will not animate targets in that group. Register a bone viagraph.add_target_to_mask_group(target_id, group_u32). To restrict a node to one group, set every bit except that group's.- Schedule. Animation systems run in
PostUpdateinside theAnimationSystemsset (a unit set in 0.20), beforeTransformSystems::Propagate. Procedural systems that also writeTransformshould run inUpdateor order explicitly againstAnimationSystems. - Out of scope in 0.20 core animation. No built-in IK, no
KHR_animation_pointer(still unsupported bybevy_gltf0.20.1), particles are separate — seereferences/gltf-import.md.
See also
bevy-migration-0-19-to-0-20— thebevy_curvesplit and observer generic change in full.bevy-cameras— camera animation (panning, dolly, focus follow) uses the sameEaseFunction/EasingCurvetoolkit.bevy-core-concepts—UpdatevsFixedUpdatechoice for procedural animation; seeprocedural-animation.md.bevy-ecs-systems— observer wiring patterns (On<E>,add_observer) used forAnimationEvents.bevy-pbr-materials— material-parameter animation viaAnimatableCurvetargetingStandardMaterialfields.bevy-custom-assets—AssetLoaderpatterns if you serialiseAnimationGraphto RON and load it as an asset.
How can the creator link this skill?
Add the canonical catalog link to the repository README so users can inspect current installs and available audits. The publishing guide covers the complete discovery path.
<a href="https://skillzs.dev/skills/chrisgliddon/bevy-skills/bevy-animation">View bevy-animation on skillZs</a>