async-ecs 0.1.0

Async Parallel Entity Component System for Rust
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

mod system_data;

pub use system_data::{DynamicSystemData, SystemData};

use futures::future::BoxFuture;

use crate::{
    access::{Accessor, AccessorCow, AccessorType},
    world::World,
};

/// A `System`, executed with a set of required [`Resource`]s.
///
/// [`Resource`]: trait.Resource.html
pub trait System<'a>: Sized {
    /// The resource bundle required to execute a system.
    ///
    /// You will mostly use a tuple of system data (which also implements
    /// `SystemData`). You can also create such a resource bundle by simply
    /// deriving `SystemData` for a struct.
    ///
    /// Every `SystemData` is also a `DynamicSystemData`.
    type SystemData: DynamicSystemData<'a>;

    /// Initialize the systems.
    fn init(&mut self) {}

    /// Executes the system with the required system data.
    fn run(&mut self, data: Self::SystemData);

    /// Return the accessor from the [`SystemData`].
    fn accessor<'b>(&'b self) -> AccessorCow<'a, 'b, Self::SystemData> {
        AccessorCow::Owned(
            AccessorType::<'a, Self::SystemData>::try_new()
                .expect("Missing implementation for `accessor`"),
        )
    }

    /// Sets up the `World` using `Self::SystemData::setup`.
    fn setup(&mut self, world: &mut World) {
        self.init();

        <Self::SystemData as DynamicSystemData>::setup(&self.accessor(), world)
    }

    /// Performs clean up that requires resources from the `World`.
    /// This commonly removes components from `world` which depend on external
    /// resources.
    fn dispose(self, world: &mut World)
    where
        Self: Sized,
    {
        let _ = world;
    }
}

/// A `System`, executed with a set of required [`Resource`]s asynchronous.
///
/// [`Resource`]: trait.Resource.html
pub trait AsyncSystem<'a>: Sized {
    /// The resource bundle required to execute a system.
    ///
    /// You will mostly use a tuple of system data (which also implements
    /// `SystemData`). You can also create such a resource bundle by simply
    /// deriving `SystemData` for a struct.
    ///
    /// Every `SystemData` is also a `DynamicSystemData`.
    type SystemData: DynamicSystemData<'a>;

    /// Initialize the systems.
    fn init(&mut self) {}

    /// Executes the system with the required system data asynchronous.
    fn run_async(&mut self, data: Self::SystemData) -> BoxFuture<'a, ()>;

    /// Return the accessor from the [`SystemData`].
    fn accessor<'b>(&'b self) -> AccessorCow<'a, 'b, Self::SystemData> {
        AccessorCow::Owned(
            AccessorType::<'a, Self::SystemData>::try_new()
                .expect("Missing implementation for `accessor`"),
        )
    }

    /// Sets up the `World` using `Self::SystemData::setup`.
    fn setup(&mut self, world: &mut World) {
        self.init();

        <Self::SystemData as DynamicSystemData>::setup(&self.accessor(), world)
    }

    /// Performs clean up that requires resources from the `World`.
    /// This commonly removes components from `world` which depend on external
    /// resources.
    fn dispose(self, world: &mut World)
    where
        Self: Sized,
    {
        let _ = world;
    }
}