bevy_sorting 0.4.0

Sorting bevy systems based on reads and writes
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
124
125
126
127
128
129
130
131
132
133
134
135
136

use std::{
    any::TypeId,
    fmt::{self, Debug, Formatter},
    hash::{Hash, Hasher},
    marker::PhantomData,
};

use bevy::{
    ecs::{
        label,
        schedule::{graph::GraphInfo, Chain, Schedulable, ScheduleConfigs},
    },
    prelude::{IntoScheduleConfigs, SystemSet},
};
use tynm::type_name;

/// System set marking all systems that reads value of T
pub struct Reads<T: 'static>(PhantomData<fn() -> T>);

impl<T: 'static> Default for Reads<T> {
    fn default() -> Self {
        Self(PhantomData)
    }
}

impl<T> Debug for Reads<T> {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        f.debug_tuple("Reads").field(&type_name::<T>()).finish()
    }
}

impl<T> Hash for Reads<T> {
    fn hash<H: Hasher>(&self, _state: &mut H) {}
}

impl<T> Clone for Reads<T> {
    fn clone(&self) -> Self {
        *self
    }
}

impl<T> Copy for Reads<T> {}

impl<T> PartialEq for Reads<T> {
    fn eq(&self, _other: &Self) -> bool {
        true
    }
}

impl<T> Eq for Reads<T> {}

impl<T> SystemSet for Reads<T> {
    fn dyn_clone(&self) -> Box<dyn SystemSet> {
        Box::new(*self)
    }

    fn as_dyn_eq(&self) -> &dyn label::DynEq {
        self
    }

    fn dyn_hash(&self, mut state: &mut dyn Hasher) {
        TypeId::of::<Self>().hash(&mut state);
    }
}

/// System set for all systems that writes to T
pub struct Writes<T: 'static>(PhantomData<fn() -> T>);

impl<T: 'static> Default for Writes<T> {
    fn default() -> Self {
        Self(PhantomData)
    }
}

impl<T> Debug for Writes<T> {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        f.debug_tuple("Writes").field(&type_name::<T>()).finish()
    }
}

impl<T> Hash for Writes<T> {
    fn hash<H: Hasher>(&self, _state: &mut H) {}
}

impl<T> Clone for Writes<T> {
    fn clone(&self) -> Self {
        *self
    }
}

impl<T> Copy for Writes<T> {}

impl<T> PartialEq for Writes<T> {
    fn eq(&self, _other: &Self) -> bool {
        true
    }
}

impl<T> Eq for Writes<T> {}

impl<T> SystemSet for Writes<T> {
    fn dyn_clone(&self) -> Box<dyn SystemSet> {
        Box::new(*self)
    }

    fn as_dyn_eq(&self) -> &dyn label::DynEq {
        self
    }

    fn dyn_hash(&self, mut state: &mut dyn Hasher) {
        TypeId::of::<Self>().hash(&mut state);
    }
}

/// Extension trait for systems allowing to clearly specify read and write constraint
pub trait IntoSystemRW<S, M>: IntoScheduleConfigs<S, M>
where
    S: Schedulable<Metadata = GraphInfo, GroupMetadata = Chain>,
{
    /// Specifies that system reads from T
    fn reads<T: 'static>(self) -> ScheduleConfigs<S> {
        self.in_set(Reads::<T>::default())
    }

    /// Specifies that system writes to T
    fn writes<T: 'static>(self) -> ScheduleConfigs<S> {
        self.in_set(Writes::<T>::default())
    }
}

impl<M, S, I> IntoSystemRW<S, M> for I
where
    S: Schedulable<Metadata = GraphInfo, GroupMetadata = Chain>,
    I: IntoScheduleConfigs<S, M>,
{
}