Module bevy_tween::tween

source ·
Expand description

Module containing implementations for tween

§Tween

Components:

Systems

Targets:

See available interpolators in interpolate.

§Registering systems

In order for your custom interpolators to work. You have to register systems to actually have something happening. The DefaultTweenPlugins will already register some systems for you already to get started. Check DefaultInterpolatorsPlugin or DefaultDynInterpolatorsPlugin.

This crate contains generic systems tweening components, assets, and resources, allowing you to quickly register your custom interpolators.

Systems:

Let’s say you have some custom components with multiple interpolators.

use bevy::prelude::*;
use bevy_tween::prelude::*;

#[derive(Component)]
pub struct Foo {
    a: f32,
    b: f32,
    c: f32,
}

mod my_interpolate {
    use bevy::prelude::*;
    use bevy_tween::prelude::*;

    pub struct FooA {
        /* ... */
    }

    impl Interpolator for FooA {
        /* ... */
    }

    pub struct FooB {
        /* ... */
    }

    impl Interpolator for FooB {
        /* ... */
    }

    pub struct FooC {
        /* ... */
    }

    impl Interpolator for FooC {
        /* ... */
    }
}

There’s 2 kind of system you might want to register.

§Registering system for generic interpolator

Generic interpolator means we’re not using any dynamic dispatch. We’ve to register this system for every individual interpolator.

fn main() {
    use bevy_tween::component_tween_system;
    use my_interpolate::*;

    App::new().add_tween_systems((
        component_tween_system::<FooA>(),
        component_tween_system::<FooB>(),
        component_tween_system::<FooC>(),
    ));
}

§Registering system for dynamic interpolator

Dynamic interpolator means we’re using dynamic dispatch or trait object. We don’t have to register system for every interpolator, we only have to register this system just for every individual component/asset/resource.

fn main() {
    use my_interpolate::*;
    use bevy_tween::component_dyn_tween_system;

    // One system to rule them all
    // Note that we're only using the `Foo` type, not `FooA`, `FooB`,
    // and `FooC`!
    App::new().add_tween_systems(component_dyn_tween_system::<Foo>());
    // `component_dyn_tween_system` is just an alias for
    // `component_tween_system::<Box<dyn Interpolator<Item = ...>>>`
}

Structs§

Enums§

  • TargetAssetbevy_asset
    Tell the tween what asset of what type to tween.
  • TargetComponent
    Tell the tween what component of what entity to tween.

Traits§

  • IntoTarget
    Trait for type to convert into a target type.

Functions§

Type Aliases§