Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/multirious/bevy_tween

Flexible tweening plugin library for Bevy.
https://github.com/multirious/bevy_tween

animation animator bevy bevy-plugin rust tween tweener tweening tweening-library

Last synced: 20 days ago
JSON representation

Flexible tweening plugin library for Bevy.

Host: GitHub
URL: https://github.com/multirious/bevy_tween
Owner: Multirious
License: apache-2.0
Created: 2024-03-02T16:58:52.000Z (9 months ago)
Default Branch: main
Last Pushed: 2024-06-09T09:02:13.000Z (5 months ago)
Last Synced: 2024-06-09T14:10:15.898Z (5 months ago)
Topics: animation, animator, bevy, bevy-plugin, rust, tween, tweener, tweening, tweening-library
Language: Rust
Homepage:
Size: 10.1 MB
Stars: 48
Watchers: 1
Forks: 1
Open Issues: 4
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- License: LICENSE-APACHE

Awesome Lists containing this project

README

        

[![Crates.io Version](https://img.shields.io/crates/v/bevy_tween?style=for-the-badge)](https://crates.io/crates/bevy_tween)

[![Crates.io License](https://img.shields.io/crates/l/bevy_tween?style=for-the-badge)](https://github.com/Multirious/bevy_tween/blob/main/README.md#license)

[![Docs.rs](https://img.shields.io/docsrs/bevy_tween?style=for-the-badge)](https://docs.rs/bevy_tween)

# `bevy_tween`

[Bevy](https://github.com/bevyengine/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](CHANGELOG.md).

## Features

- **Ergonomic and user-friendly API**: You can always spawn the animator manually but this crate provide

  APIs that abstracted over most boilerplate code.

  Animation can be built using the builder with function combinators.

  

  Example

  ```rust

  let sprite_id = commands.spawn(SpriteBundle { ... }).id();

  let sprite = sprite_id.into_target();

  commands.animation()

      .insert(tween(

          Duration::from_secs(1),

          EaseFunction::Linear,

          sprite.with(translation(pos0, pos1))

      ));

  ```

  You can also abstract animation!

  ```rust

  fn my_animation(

      target: TargetComponent,

      duration: Duration

  ) -> impl FnOnce(&mut AnimationCommands, &mut Duration) {

      parallel((

          tween(duration, EaseFunction::QuadraticOut, target.with(translation(...))),

          tween(duration, EaseFunction::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`](https://github.com/Multirious/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](#Demos)

Goals:

- [x] Flexible 🎉

- integration with other crates (?)

  - [ ] `bevy_animation`

  - [x] `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`](https://github.com/djeedai/bevy_tweening) or [`bevy_easings`](https://github.com/vleue/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:

1. By building on top of [`bevy_time_runner`](https://github.com/Multirious/bevy_time_runner), an animator is a tree of entities.

2. The parent is [`TimeRunner`](https://docs.rs/bevy_time_runner/latest/bevy_time_runner/struct.TimeRunner.html).

  This entity handles all the timing and progress of its children.

3. The children can be any combination of any components, such as tweens by this crate.

4. 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.

  - `bevy_eventlistener`


    Add entity-targeted events with bevy_eventlistener.

- Optional

  - `bevy_lookup_curve`.


    Adds interpolation implementation using [`bevy_lookup_curve`](https://github.com/villor/bevy_lookup_curve).

## Bevy Version Support

|`bevy`|`bevy_tween`|

|------|------------|

|0.14  |0.6         |

|0.13  |0.2–0.5     |

## Credits

- [`bevy_tweening`](https://github.com/djeedai/bevy_tweening)

  The first crate I discovered and tried to do tweening with in Bevy.

  Their method of `Lens` is great and so it's present in this crate.

  Now called `Interpolator`. Usages may be similar but is

  implemented differently.

- [`godot`](https://github.com/godotengine/godot)

  Godot's tween make it simple to animate something which is the

  inspiration for this crate. The multi-entity architecture is mainly inspired by

  Godot's node child-parent hierarchy system and that most of the engine APIs

  utilizes this to define behavior.

## Contributions

Contributions are welcome!

## License

Licensed under either of

 * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)

 * MIT license ([LICENSE-MIT](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.



## Demos

`cargo run --example follow -F bevy/bevy_winit`


A square will follow your circle with configurable animation.


https://github.com/Multirious/bevy_tween/assets/77918086/d582c2de-0f54-4b22-be03-e3bff3348deb

---

`cargo run --example click -F bevy/bevy_winit`


Click left to spawn a circle. Hold right click to repetitively spawn a circle every frame.


https://github.com/Multirious/bevy_tween/assets/77918086/fd0fe9d3-13a2-4261-880c-cc2609b875ba

---

`cargo run --example hold -F bevy/bevy_winit`


Hold left click to increase the effect intensitiy.


https://github.com/Multirious/bevy_tween/assets/77918086/33a297a6-19f2-4146-a906-1a88ff037ab3

---

`cargo run --example event -F bevy/bevy_winit`


Showcasing the tween event feature.


https://github.com/Multirious/bevy_tween/assets/77918086/9507c467-6428-4aed-bd00-511f05e6e951

---

`cargo run --example sprite_sheet -F bevy/bevy_winit`


Sprite Sheet animation.


https://github.com/Multirious/bevy_tween/assets/77918086/e3997b06-38e6-4add-85f5-a885b69c6687