update plugin crates

Author: maniwani

crates/bevy_asset/src/io/embedded/mod.rs

@@ -224,7 +224,7 @@ macro_rules! embedded_asset {
 
     ($app: ident, $source_path: expr, $path: expr) => {{
         let mut embedded = $app
-            .world
+            .world_mut()
             .resource_mut::<$crate::io::embedded::EmbeddedAssetRegistry>();
         let path = $crate::embedded_path!($source_path, $path);
         let watched_path = $crate::io::embedded::watched_path(file!(), $path);
@@ -253,7 +253,7 @@ pub fn watched_path(_source_file_path: &'static str, _asset_path: &'static str)
 #[macro_export]
 macro_rules! load_internal_asset {
     ($app: ident, $handle: expr, $path_str: expr, $loader: expr) => {{
-        let mut assets = $app.world.resource_mut::<$crate::Assets<_>>();
+        let mut assets = $app.world_mut().resource_mut::<$crate::Assets<_>>();
         assets.insert($handle.id(), ($loader)(
             include_str!($path_str),
             std::path::Path::new(file!())
@@ -265,7 +265,7 @@ macro_rules! load_internal_asset {
     }};
     // we can't support params without variadic arguments, so internal assets with additional params can't be hot-reloaded
     ($app: ident, $handle: ident, $path_str: expr, $loader: expr $(, $param:expr)+) => {{
-        let mut assets = $app.world.resource_mut::<$crate::Assets<_>>();
+        let mut assets = $app.world_mut().resource_mut::<$crate::Assets<_>>();
         assets.insert($handle.id(), ($loader)(
             include_str!($path_str),
             std::path::Path::new(file!())
@@ -282,7 +282,7 @@ macro_rules! load_internal_asset {
 #[macro_export]
 macro_rules! load_internal_binary_asset {
     ($app: ident, $handle: expr, $path_str: expr, $loader: expr) => {{
-        let mut assets = $app.world.resource_mut::<$crate::Assets<_>>();
+        let mut assets = $app.world_mut().resource_mut::<$crate::Assets<_>>();
         assets.insert(
             $handle.id(),
             ($loader)(

crates/bevy_asset/src/lib.rs

@@ -153,7 +153,7 @@ impl Plugin for AssetPlugin {
         let embedded = EmbeddedAssetRegistry::default();
         {
             let mut sources = app
-                .world
+                .world_mut()
                 .get_resource_or_insert_with::<AssetSourceBuilders>(Default::default);
             sources.init_default_source(
                 &self.file_path,
@@ -169,10 +169,10 @@ impl Plugin for AssetPlugin {
             }
             match self.mode {
                 AssetMode::Unprocessed => {
-                    let mut builders = app.world.resource_mut::<AssetSourceBuilders>();
+                    let mut builders = app.world_mut().resource_mut::<AssetSourceBuilders>();
                     let sources = builders.build_sources(watch, false);
                     let meta_check = app
-                        .world
+                        .world()
                         .get_resource::<AssetMetaCheck>()
                         .cloned()
                         .unwrap_or_else(AssetMetaCheck::default);
@@ -187,7 +187,7 @@ impl Plugin for AssetPlugin {
                 AssetMode::Processed => {
                     #[cfg(feature = "asset_processor")]
                     {
-                        let mut builders = app.world.resource_mut::<AssetSourceBuilders>();
+                        let mut builders = app.world_mut().resource_mut::<AssetSourceBuilders>();
                         let processor = AssetProcessor::new(&mut builders);
                         let mut sources = builders.build_sources(false, watch);
                         sources.gate_on_processor(processor.data.clone());
@@ -204,7 +204,7 @@ impl Plugin for AssetPlugin {
                     }
                     #[cfg(not(feature = "asset_processor"))]
                     {
-                        let mut builders = app.world.resource_mut::<AssetSourceBuilders>();
+                        let mut builders = app.world_mut().resource_mut::<AssetSourceBuilders>();
                         let sources = builders.build_sources(false, watch);
                         app.insert_resource(AssetServer::new_with_meta_check(
                             sources,
@@ -318,12 +318,14 @@ pub trait AssetApp {
 
 impl AssetApp for App {
     fn register_asset_loader<L: AssetLoader>(&mut self, loader: L) -> &mut Self {
-        self.world.resource::<AssetServer>().register_loader(loader);
+        self.world()
+            .resource::<AssetServer>()
+            .register_loader(loader);
         self
     }
 
     fn register_asset_processor<P: Process>(&mut self, processor: P) -> &mut Self {
-        if let Some(asset_processor) = self.world.get_resource::<AssetProcessor>() {
+        if let Some(asset_processor) = self.world().get_resource::<AssetProcessor>() {
             asset_processor.register_processor(processor);
         }
         self
@@ -335,13 +337,13 @@ impl AssetApp for App {
         source: AssetSourceBuilder,
     ) -> &mut Self {
         let id = id.into();
-        if self.world.get_resource::<AssetServer>().is_some() {
+        if self.world().get_resource::<AssetServer>().is_some() {
             error!("{} must be registered before `AssetPlugin` (typically added as part of `DefaultPlugins`)", id);
         }
 
         {
             let mut sources = self
-                .world
+                .world_mut()
                 .get_resource_or_insert_with(AssetSourceBuilders::default);
             sources.insert(id, source);
         }
@@ -350,22 +352,24 @@ impl AssetApp for App {
     }
 
     fn set_default_asset_processor<P: Process>(&mut self, extension: &str) -> &mut Self {
-        if let Some(asset_processor) = self.world.get_resource::<AssetProcessor>() {
+        if let Some(asset_processor) = self.world().get_resource::<AssetProcessor>() {
             asset_processor.set_default_processor::<P>(extension);
         }
         self
     }
 
     fn init_asset_loader<L: AssetLoader + FromWorld>(&mut self) -> &mut Self {
-        let loader = L::from_world(&mut self.world);
+        let loader = L::from_world(self.world_mut());
         self.register_asset_loader(loader)
     }
 
     fn init_asset<A: Asset>(&mut self) -> &mut Self {
         let assets = Assets::<A>::default();
-        self.world.resource::<AssetServer>().register_asset(&assets);
-        if self.world.contains_resource::<AssetProcessor>() {
-            let processor = self.world.resource::<AssetProcessor>();
+        self.world()
+            .resource::<AssetServer>()
+            .register_asset(&assets);
+        if self.world().contains_resource::<AssetProcessor>() {
+            let processor = self.world().resource::<AssetProcessor>();
             // The processor should have its own handle provider separate from the Asset storage
             // to ensure the id spaces are entirely separate. Not _strictly_ necessary, but
             // desirable.
@@ -394,7 +398,7 @@ impl AssetApp for App {
     where
         A: Asset + Reflect + FromReflect + GetTypeRegistration,
     {
-        let type_registry = self.world.resource::<AppTypeRegistry>();
+        let type_registry = self.world().resource::<AppTypeRegistry>();
         {
             let mut type_registry = type_registry.write();
 
@@ -408,7 +412,7 @@ impl AssetApp for App {
     }
 
     fn preregister_asset_loader<L: AssetLoader>(&mut self, extensions: &[&str]) -> &mut Self {
-        self.world
+        self.world_mut()
             .resource_mut::<AssetServer>()
             .preregister_loader::<L>(extensions);
         self
@@ -628,7 +632,7 @@ mod tests {
     pub fn run_app_until(app: &mut App, mut predicate: impl FnMut(&mut World) -> Option<()>) {
         for _ in 0..LARGE_ITERATION_COUNT {
             app.update();
-            if predicate(&mut app.world).is_some() {
+            if predicate(app.world_mut()).is_some() {
                 return;
             }
         }
@@ -718,13 +722,13 @@ mod tests {
             .init_resource::<StoredEvents>()
             .register_asset_loader(CoolTextLoader)
             .add_systems(Update, store_asset_events);
-        let asset_server = app.world.resource::<AssetServer>().clone();
+        let asset_server = app.world().resource::<AssetServer>().clone();
         let handle: Handle<CoolText> = asset_server.load(a_path);
         let a_id = handle.id();
-        let entity = app.world.spawn(handle).id();
+        let entity = app.world_mut().spawn(handle).id();
         app.update();
         {
-            let a_text = get::<CoolText>(&app.world, a_id);
+            let a_text = get::<CoolText>(app.world(), a_id);
             let (a_load, a_deps, a_rec_deps) = asset_server.get_load_states(a_id).unwrap();
             assert!(a_text.is_none(), "a's asset should not exist yet");
             assert_eq!(a_load, LoadState::Loading, "a should still be loading");
@@ -906,27 +910,27 @@ mod tests {
         });
 
         {
-            let mut texts = app.world.resource_mut::<Assets<CoolText>>();
+            let mut texts = app.world_mut().resource_mut::<Assets<CoolText>>();
             let a = texts.get_mut(a_id).unwrap();
             a.text = "Changed".to_string();
         }
 
-        app.world.despawn(entity);
+        app.world_mut().despawn(entity);
         app.update();
         assert_eq!(
-            app.world.resource::<Assets<CoolText>>().len(),
+            app.world().resource::<Assets<CoolText>>().len(),
             0,
             "CoolText asset entities should be despawned when no more handles exist"
         );
         app.update();
         // this requires a second update because the parent asset was freed in the previous app.update()
         assert_eq!(
-            app.world.resource::<Assets<SubText>>().len(),
+            app.world().resource::<Assets<SubText>>().len(),
             0,
             "SubText asset entities should be despawned when no more handles exist"
         );
-        let events = app.world.remove_resource::<StoredEvents>().unwrap();
-        let id_results = app.world.remove_resource::<IdResults>().unwrap();
+        let events = app.world_mut().remove_resource::<StoredEvents>().unwrap();
+        let id_results = app.world_mut().remove_resource::<IdResults>().unwrap();
         let expected_events = vec![
             AssetEvent::Added { id: a_id },
             AssetEvent::LoadedWithDependencies {
@@ -1030,7 +1034,7 @@ mod tests {
         let (mut app, gate_opener) = test_app(dir);
         app.init_asset::<CoolText>()
             .register_asset_loader(CoolTextLoader);
-        let asset_server = app.world.resource::<AssetServer>().clone();
+        let asset_server = app.world().resource::<AssetServer>().clone();
         let handle: Handle<CoolText> = asset_server.load(a_path);
         let a_id = handle.id();
         {
@@ -1046,7 +1050,7 @@ mod tests {
             );
         }
 
-        app.world.spawn(handle);
+        app.world_mut().spawn(handle);
         gate_opener.open(a_path);
         gate_opener.open(b_path);
         gate_opener.open(c_path);
@@ -1117,23 +1121,23 @@ mod tests {
 
         let id = {
             let handle = {
-                let mut texts = app.world.resource_mut::<Assets<CoolText>>();
+                let mut texts = app.world_mut().resource_mut::<Assets<CoolText>>();
                 let handle = texts.add(CoolText::default());
                 texts.get_strong_handle(handle.id()).unwrap()
             };
 
             app.update();
 
             {
-                let text = app.world.resource::<Assets<CoolText>>().get(&handle);
+                let text = app.world().resource::<Assets<CoolText>>().get(&handle);
                 assert!(text.is_some());
             }
             handle.id()
         };
         // handle is dropped
         app.update();
         assert!(
-            app.world.resource::<Assets<CoolText>>().get(id).is_none(),
+            app.world().resource::<Assets<CoolText>>().get(id).is_none(),
             "asset has no handles, so it should have been dropped last update"
         );
     }
@@ -1161,7 +1165,7 @@ mod tests {
 
         let id = {
             let handle = {
-                let mut texts = app.world.resource_mut::<Assets<CoolText>>();
+                let mut texts = app.world_mut().resource_mut::<Assets<CoolText>>();
                 texts.add(CoolText {
                     text: hello.clone(),
                     embedded: empty.clone(),
@@ -1174,7 +1178,7 @@ mod tests {
 
             {
                 let text = app
-                    .world
+                    .world()
                     .resource::<Assets<CoolText>>()
                     .get(&handle)
                     .unwrap();
@@ -1185,40 +1189,40 @@ mod tests {
         // handle is dropped
         app.update();
         assert!(
-            app.world.resource::<Assets<CoolText>>().get(id).is_none(),
+            app.world().resource::<Assets<CoolText>>().get(id).is_none(),
             "asset has no handles, so it should have been dropped last update"
         );
         // remove event is emitted
         app.update();
-        let events = std::mem::take(&mut app.world.resource_mut::<StoredEvents>().0);
+        let events = std::mem::take(&mut app.world_mut().resource_mut::<StoredEvents>().0);
         let expected_events = vec![
             AssetEvent::Added { id },
             AssetEvent::Unused { id },
             AssetEvent::Removed { id },
         ];
         assert_eq!(events, expected_events);
 
-        let dep_handle = app.world.resource::<AssetServer>().load(dep_path);
+        let dep_handle = app.world().resource::<AssetServer>().load(dep_path);
         let a = CoolText {
             text: "a".to_string(),
             embedded: empty,
             // this dependency is behind a manual load gate, which should prevent 'a' from emitting a LoadedWithDependencies event
             dependencies: vec![dep_handle.clone()],
             sub_texts: Vec::new(),
         };
-        let a_handle = app.world.resource::<AssetServer>().load_asset(a);
+        let a_handle = app.world().resource::<AssetServer>().load_asset(a);
         app.update();
         // TODO: ideally it doesn't take two updates for the added event to emit
         app.update();
 
-        let events = std::mem::take(&mut app.world.resource_mut::<StoredEvents>().0);
+        let events = std::mem::take(&mut app.world_mut().resource_mut::<StoredEvents>().0);
         let expected_events = vec![AssetEvent::Added { id: a_handle.id() }];
         assert_eq!(events, expected_events);
 
         gate_opener.open(dep_path);
         loop {
             app.update();
-            let events = std::mem::take(&mut app.world.resource_mut::<StoredEvents>().0);
+            let events = std::mem::take(&mut app.world_mut().resource_mut::<StoredEvents>().0);
             if events.is_empty() {
                 continue;
             }
@@ -1232,7 +1236,7 @@ mod tests {
             break;
         }
         app.update();
-        let events = std::mem::take(&mut app.world.resource_mut::<StoredEvents>().0);
+        let events = std::mem::take(&mut app.world_mut().resource_mut::<StoredEvents>().0);
         let expected_events = vec![AssetEvent::Added {
             id: dep_handle.id(),
         }];
@@ -1283,7 +1287,7 @@ mod tests {
         app.init_asset::<CoolText>()
             .init_asset::<SubText>()
             .register_asset_loader(CoolTextLoader);
-        let asset_server = app.world.resource::<AssetServer>().clone();
+        let asset_server = app.world().resource::<AssetServer>().clone();
         let handle: Handle<LoadedFolder> = asset_server.load_folder("text");
         gate_opener.open(a_path);
         gate_opener.open(b_path);
@@ -1438,12 +1442,12 @@ mod tests {
             (asset_event_handler, asset_load_error_event_handler).chain(),
         );
 
-        let asset_server = app.world.resource::<AssetServer>().clone();
+        let asset_server = app.world().resource::<AssetServer>().clone();
         let a_path = format!("unstable://{a_path}");
         let a_handle: Handle<CoolText> = asset_server.load(a_path);
         let a_id = a_handle.id();
 
-        app.world.spawn(a_handle);
+        app.world_mut().spawn(a_handle);
 
         run_app_until(&mut app, |world| {
             let tracker = world.resource::<ErrorTracker>();
@@ -1476,7 +1480,7 @@ mod tests {
         });
 
         // running schedule does not error on ambiguity between the 2 uses_assets systems
-        app.world.run_schedule(Update);
+        app.world_mut().run_schedule(Update);
     }
 
     // validate the Asset derive macro for various asset types