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
|
use std::any::{type_name, Any, TypeId};
use std::ops::{Deref, DerefMut};
use crate::component::Component;
use crate::system::{ComponentRefMut, NoInitParamFlag, Param as SystemParam, System};
use crate::tuple::FilterExclude as TupleFilterExclude;
use crate::WorldData;
/// Holds a component which has a single instance and is shared globally.
#[derive(Debug)]
pub struct Single<'world, SingleComponent: Component>
{
single_component: ComponentRefMut<'world, SingleComponent>,
}
unsafe impl<'world, SingleComponent> SystemParam<'world>
for Single<'world, SingleComponent>
where
SingleComponent: Component,
{
type Flags = NoInitParamFlag;
type Input = TupleFilterExclude;
fn initialize<SystemImpl>(
_system: &mut impl System<'world, SystemImpl>,
_input: Self::Input,
)
{
}
fn new<SystemImpl>(
_system: &'world impl System<'world, SystemImpl>,
world_data: &'world WorldData,
) -> Self
{
let single_component = world_data
.single_component_storage
.get::<SingleComponent>()
.expect("Single component was not found in world")
.write_nonblock()
.unwrap_or_else(|_| {
panic!(
"Failed to aquire read-write lock to single component {}",
type_name::<SingleComponent>()
)
});
Self {
single_component: ComponentRefMut::new(single_component),
}
}
fn is_compatible<Other: SystemParam<'world>>() -> bool
{
let other_comparable = Other::get_comparable();
let Some(comparable) = other_comparable.downcast_ref::<Comparable>() else {
// The other system param is not Single
return true;
};
TypeId::of::<SingleComponent>() != comparable.single_component_type_id
}
fn get_comparable() -> Box<dyn Any>
{
Box::new(Comparable {
single_component_type_id: TypeId::of::<SingleComponent>(),
})
}
}
impl<'world, SingleComponent> Deref for Single<'world, SingleComponent>
where
SingleComponent: Component,
{
type Target = SingleComponent;
fn deref(&self) -> &Self::Target
{
&self.single_component
}
}
impl<'world, SingleComponent> DerefMut for Single<'world, SingleComponent>
where
SingleComponent: Component,
{
fn deref_mut(&mut self) -> &mut Self::Target
{
&mut self.single_component
}
}
struct Comparable
{
single_component_type_id: TypeId,
}
|
