1mod lazy;
2mod meta;
3mod setup;
4
5pub use self::meta::{CastFrom, MetaTable};
6pub use lazy::Lazy;
7pub use setup::{DefaultSetupHandler, PanicHandler, SetupHandler};
8
9use std::ops::{Deref, DerefMut};
10
11use crate::{
12 access::{Read, ReadStorage, WriteStorage},
13 component::Component,
14 entity::{Entities, Entity, EntityBuilder},
15 resource::{Cell, Ref, RefMut, Resource, ResourceId, Resources},
16 storage::MaskedStorage,
17 system::SystemData,
18};
19
20pub struct World(Resources);
21
22impl World {
23 pub fn register_component<T: Component>(&mut self)
24 where
25 T::Storage: Default,
26 {
27 self.register_component_with_storage::<T, _>(Default::default);
28 }
29
30 pub fn register_component_with_storage<T, F>(&mut self, storage: F)
31 where
32 T: Component,
33 F: FnOnce() -> T::Storage,
34 {
35 self.entry()
36 .or_insert_with(move || MaskedStorage::<T>::new(storage()));
37 self.entry::<MetaTable<dyn AnyStorage>>()
38 .or_insert_with(Default::default);
39 self.resource_mut::<MetaTable<dyn AnyStorage>>()
40 .register(&*self.resource::<MaskedStorage<T>>());
41 }
42
43 pub fn register_resource<T: Resource>(&mut self, res: T) {
44 self.0.insert(res);
45 }
46
47 pub fn resource<T: Resource>(&self) -> Ref<T> {
48 self.0.borrow()
49 }
50
51 pub fn resource_mut<T: Resource>(&self) -> RefMut<T> {
52 self.0.borrow_mut()
53 }
54
55 pub fn resource_raw(&self, id: &ResourceId) -> Option<&Cell<Box<dyn Resource>>> {
56 self.0.get_raw(id)
57 }
58
59 pub fn entities(&self) -> Read<Entities> {
60 Read::fetch(&self)
61 }
62
63 pub fn entities_mut(&self) -> RefMut<Entities> {
64 self.resource_mut()
65 }
66
67 pub fn lazy(&self) -> Read<Lazy> {
68 Read::fetch(&self)
69 }
70
71 pub fn component<T: Component>(&self) -> ReadStorage<T> {
72 ReadStorage::fetch(&self)
73 }
74
75 pub fn component_mut<T: Component>(&self) -> WriteStorage<T> {
76 WriteStorage::fetch(&self)
77 }
78
79 pub fn create_entity(&mut self) -> EntityBuilder {
80 EntityBuilder::new(self)
81 }
82
83 pub fn is_alive(&self, entity: Entity) -> bool {
84 self.entities().is_alive(entity)
85 }
86
87 pub async fn maintain(&mut self) {
88 let lazy = self.resource_mut::<Lazy>().clone();
89 lazy.maintain(self).await;
90
91 let deleted = self.entities_mut().maintain();
92 if !deleted.is_empty() {
93 self.entry::<MetaTable<dyn AnyStorage>>()
94 .or_insert_with(Default::default);
95 for storage in self
96 .resource_mut::<MetaTable<dyn AnyStorage>>()
97 .iter_mut(&self)
98 {
99 storage.drop(&deleted);
100 }
101 }
102 }
103}
104
105impl Default for World {
106 fn default() -> Self {
107 let mut resources = Resources::default();
108
109 resources.insert(Entities::default());
110 resources.insert(Lazy::default());
111 resources.insert(MetaTable::<dyn AnyStorage>::default());
112
113 Self(resources)
114 }
115}
116
117impl Deref for World {
118 type Target = Resources;
119
120 fn deref(&self) -> &Self::Target {
121 &self.0
122 }
123}
124
125impl DerefMut for World {
126 fn deref_mut(&mut self) -> &mut Self::Target {
127 &mut self.0
128 }
129}
130
131pub trait AnyStorage {
134 fn drop(&mut self, entities: &[Entity]);
135}
136
137unsafe impl<T> CastFrom<T> for dyn AnyStorage
138where
139 T: AnyStorage + 'static,
140{
141 fn cast(t: &T) -> &Self {
142 t
143 }
144
145 fn cast_mut(t: &mut T) -> &mut Self {
146 t
147 }
148}
149
150impl<T> AnyStorage for MaskedStorage<T>
151where
152 T: Component,
153{
154 fn drop(&mut self, entities: &[Entity]) {
155 for entity in entities {
156 MaskedStorage::drop(self, entity.index());
157 }
158 }
159}