bevy_defer 0.18.0

A simple asynchronous runtime for executing async coroutines.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use std::time::Duration;

use bevy::prelude::*;
use bevy_defer::{
    access::AsyncWorld, cancellation::Cancellation, tween::Playback, AsyncExtension, AsyncPlugin,
};

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_plugins(AsyncPlugin::default_settings())
        .add_systems(Startup, setup)
        .spawn_task(async {
            let world = AsyncWorld;
            let entity = world.spawn_bundle(Sprite {
                color: Color::srgb(0., 0., 1.),
                custom_size: Some(Vec2::splat(40.0)),
                ..Default::default()
            });
            entity
                .component::<Transform>()
                .interpolate_to(
                    Vec3::new(-100.0, -100.0, 0.0),
                    |t| t.translation,
                    |t, v| t.translation = v,
                    |x| x * x,
                    2.0,
                    (),
                )
                .await
                .unwrap();
            entity
                .component::<Transform>()
                .interpolate_to(
                    Vec3::new(-100.0, 100.0, 0.0),
                    |t| t.translation,
                    |t, v| t.translation = v,
                    |x| x * x,
                    2.0,
                    (),
                )
                .await
                .unwrap();
            entity
                .component::<Transform>()
                .interpolate_to(
                    Vec3::new(100.0, 0.0, 0.0),
                    |t| t.translation,
                    |t, v| t.translation = v,
                    |x| x * x,
                    2.0,
                    (),
                )
                .await
                .unwrap();
            entity
                .component::<Transform>()
                .interpolate_to(
                    Vec3::new(0.0, 0.0, 0.0),
                    |t| t.translation,
                    |t, v| t.translation = v,
                    |x| x * x,
                    2.0,
                    (),
                )
                .await
                .unwrap();
            Ok(())
        })
        .spawn_task(async {
            let world = AsyncWorld;
            let entity = world.spawn_bundle((
                Sprite {
                    color: Color::srgb(0., 1., 0.),
                    custom_size: Some(Vec2::splat(40.0)),
                    ..Default::default()
                },
                Transform::from_translation(Vec3::new(0.0, 200.0, 0.0)),
            ));
            let cancel = Cancellation::new();
            let comp = entity.component::<Transform>();
            AsyncWorld.spawn_any(comp.interpolate(
                |x| Vec3::new(0.0, 200.0, 0.0).lerp(Vec3::new(0.0, -200.0, 0.0), x),
                |t, v| t.translation = v,
                |x| x * x,
                2.0,
                Playback::Bounce,
                &cancel,
            ));
            world.sleep(Duration::from_secs(6)).await;
            cancel.cancel();
            comp.interpolate_to(
                Vec3::new(0.0, 0.0, 0.0),
                |t| t.translation,
                |t, v| t.translation = v,
                |x| x * x,
                2.0,
                (),
            )
            .await
            .unwrap();

            let cancel = Cancellation::new();
            let comp = entity.component::<Transform>();
            AsyncWorld.spawn_any(comp.interpolate(
                |x| Vec3::new(0.0, 0.0, 0.0).lerp(Vec3::new(200.0, 0.0, 0.0), x),
                |t, v| t.translation = v,
                |x| x,
                2.0,
                Playback::Loop,
                &cancel,
            ));
            world.sleep(Duration::from_secs(6)).await;
            cancel.cancel();
            world.quit();
            Ok(())
        })
        .run();
}

fn setup(mut commands: Commands) {
    commands.spawn(Camera2d);
}