bevy_tween

Crates.io	bevy_tween
lib.rs	bevy_tween
version
source	src
created_at	2024-03-04 11:22:37.335703
updated_at	2024-12-09 09:24:59.044623
description	Flexible tweening plugin library for Bevy
homepage	https://github.com/Multirious/bevy_tween
repository	https://github.com/Multirious/bevy_tween
max_upload_size
id	1161616
Cargo.toml error:	TOML parse error at line 18, column 1 \| 18 \| autolib = false \| ^^^^^^^ unknown field `autolib`, expected one of `name`, `version`, `edition`, `authors`, `description`, `readme`, `license`, `repository`, `homepage`, `documentation`, `build`, `resolver`, `links`, `default-run`, `default_dash_run`, `rust-version`, `rust_dash_version`, `rust_version`, `license-file`, `license_dash_file`, `license_file`, `licenseFile`, `license_capital_file`, `forced-target`, `forced_dash_target`, `autobins`, `autotests`, `autoexamples`, `autobenches`, `publish`, `metadata`, `keywords`, `categories`, `exclude`, `include`
size	0

Multirious (Multirious)

documentation

https://docs.rs/bevy_tween

README

`bevy_tween`

Bevy procedural and keyframe animation library.

This is a young plugin and APIs are to be fleshed out. Breaking changes are to be expected!

See changelog here.

Features

Ergonomic and user-friendly API: This crate provides functional animation framework, inspired by nom and other functional languages, which allows for declarative animation.

Example

let sprite_id = commands.spawn(SpriteBundle { ... }).id();
let sprite = sprite_id.into_target();
commands.animation()
    .insert(tween(
        Duration::from_secs(1),
        EaseKind::Linear,
        sprite.with(translation(pos0, pos1))
    ));

Many functional techniques are available such as decoupling and composition.

fn my_animation(
    target: TargetComponent,
    duration: Duration
) -> impl FnOnce(&mut AnimationCommands, &mut Duration) {
    parallel((
        tween(duration, EaseKind::QuadraticOut, target.with(translation(...))),
        tween(duration, EaseKind::QuadraticOut, target.with(rotation(...))),
    ))
}

let sprite_id = commands.spawn(Sprite { ... }).id();
let sprite = sprite_id.into_target();
commands.animation().insert(my_animation(sprite, Duration::from_secs(1)))

Flexible and Extensible: This crate is built on top of bevy_time_runner which mean we can extend this crate by adding any components and systems.
- Tween anything from anywhere, built-in or custom system.
- Interpolate with any curve, built-in or custom system.
- Anything else.
Parallelism: Tweens are typed and can be query over by their typed system which increase chances for system parallelism.
Rich timer control:
- Looping
- Time scaling
- Skip backward or forward
- Jumping to anywhen

See demos

Goals:

Flexible 🎉
integration with other crates (?)
- bevy_animation
- bevy_lookup_curve
Editor. While the original goal for this crate is tweening from code, this crate absolutely has the capability to work on any complex animations. The editor will aid in such jobs.
- Real-time display at any point in time in the animation.
- Editing path from point A to point B with arbitary curve.

Differences and how it works

This crate chose a different approach to storing tween data/input to solve flexibility issues present in bevy_tweening or bevy_easings, like difficulty tweening in parallel or sequence of multiple types.

This approach offers:

As mentioned above, capability to tween in parallel, sequence, or overlapping of any types.
Extendability. And not just for tweening. For example, this crate adds a custom event plugin that can emit arbitrary events anytime in the animation by just building off the same system.

How it works:

By building on top of bevy_time_runner, an animator is a tree of entities.
The parent is TimeRunner. This entity handles all the timing and progress of its children.
The children can be any combination of any components, such as tweens by this crate.
Systems are then run in a pipeline, communicating through various dependency-injected components.

Feature gates

Defaults
- bevy_asset
  Add tweening systems for asset.
- bevy_render
  Currently add nothing but required by the bevy_sprite feature.
- bevy_sprite
  Add some built-in interpolators related to sprite.
- bevy_ui
  Add some built-in interpolators related to ui.
Optional
- bevy_lookup_curve.
  Adds interpolation implementation using bevy_lookup_curve.

Bevy Version Support

`bevy`	`bevy_tween`
0.15	0.7
0.14	0.6
0.13	0.2–0.5

Credits

bevy_tweening

The first crate that I've learned and improve this crate upon.
godot

There are one common pattern in Godot to uses Node as composition interface which inspired how bevy_time_runner works.
nom

nom provides function parser combinator framework that inspried this crate's animation framework.

Contributions

Contributions are welcome!

License

Licensed under either of

Apache License, Version 2.0, (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT)

at your option.

Your contributions

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.