rename existing ReflectMapEntities methods

Author: jrobsonchase

crates/bevy_ecs/src/reflect/map_entities.rs

@@ -13,8 +13,8 @@ use bevy_reflect::FromType;
 /// See [`SceneEntityMapper`] and [`MapEntities`] for more information.
 #[derive(Clone)]
 pub struct ReflectMapEntities {
-    map_all_entities: fn(&mut World, &mut SceneEntityMapper),
-    map_entities: fn(&mut World, &mut SceneEntityMapper, &[Entity]),
+    map_all_world_entities: fn(&mut World, &mut SceneEntityMapper),
+    map_world_entities: fn(&mut World, &mut SceneEntityMapper, &[Entity]),
 }
 
 impl ReflectMapEntities {
@@ -27,8 +27,12 @@ impl ReflectMapEntities {
     /// An example of this: A scene can be loaded with `Parent` components, but then a `Parent` component can be added
     /// to these entities after they have been loaded. If you reload the scene using [`map_all_entities`](Self::map_all_entities), those `Parent`
     /// components with already valid entity references could be updated to point at something else entirely.
-    pub fn map_all_entities(&self, world: &mut World, entity_map: &mut EntityHashMap<Entity>) {
-        SceneEntityMapper::world_scope(entity_map, world, self.map_all_entities);
+    pub fn map_all_world_entities(
+        &self,
+        world: &mut World,
+        entity_map: &mut EntityHashMap<Entity>,
+    ) {
+        SceneEntityMapper::world_scope(entity_map, world, self.map_all_world_entities);
     }
 
     /// A general method for applying [`MapEntities`] behavior to elements in an [`EntityHashMap<Entity>`]. Unlike
@@ -37,29 +41,29 @@ impl ReflectMapEntities {
     ///
     /// This is useful mostly for when you need to be careful not to update components that already contain valid entity
     /// values. See [`map_all_entities`](Self::map_all_entities) for more details.
-    pub fn map_entities(
+    pub fn map_world_entities(
         &self,
         world: &mut World,
         entity_map: &mut EntityHashMap<Entity>,
         entities: &[Entity],
     ) {
         SceneEntityMapper::world_scope(entity_map, world, |world, mapper| {
-            (self.map_entities)(world, mapper, entities);
+            (self.map_world_entities)(world, mapper, entities);
         });
     }
 }
 
 impl<C: Component + MapEntities> FromType<C> for ReflectMapEntities {
     fn from_type() -> Self {
         ReflectMapEntities {
-            map_entities: |world, entity_mapper, entities| {
+            map_world_entities: |world, entity_mapper, entities| {
                 for &entity in entities {
                     if let Some(mut component) = world.get_mut::<C>(entity) {
                         component.map_entities(entity_mapper);
                     }
                 }
             },
-            map_all_entities: |world, entity_mapper| {
+            map_all_world_entities: |world, entity_mapper| {
                 let entities = entity_mapper
                     .get_map()
                     .values()

crates/bevy_scene/src/dynamic_scene.rs

@@ -130,7 +130,7 @@ impl DynamicScene {
                 "we should be getting TypeId from this TypeRegistration in the first place",
             );
             if let Some(map_entities_reflect) = registration.data::<ReflectMapEntities>() {
-                map_entities_reflect.map_entities(world, entity_map, &entities);
+                map_entities_reflect.map_world_entities(world, entity_map, &entities);
             }
         }
 

crates/bevy_scene/src/scene.rs

@@ -127,7 +127,7 @@ impl Scene {
 
         for registration in type_registry.iter() {
             if let Some(map_entities_reflect) = registration.data::<ReflectMapEntities>() {
-                map_entities_reflect.map_all_entities(world, entity_map);
+                map_entities_reflect.map_all_world_entities(world, entity_map);
             }
         }