Merge pull request amethyst#2612 from jlowry/prefabs-with-modified-de…

…pendencies

Fixing and refactoring prefabs

amethyst_assets/src/prefab/system.rs

@@ -28,48 +28,41 @@ pub fn prefab_spawning_tick(world: &mut World, resources: &mut Resources) {
         &legion_prefab::CookedPrefab,
         u32,
         HashMap<Entity, Entity, EntityHasher>,
-        Handle<Prefab>,
     )> = Vec::new();
 
     let mut entity_query = <(Entity,)>::query();
 
     <(Entity, &Handle<Prefab>, TryWrite<PrefabInstance>)>::query().for_each_mut(
         world,
         |(entity, handle, instance)| {
-            if let Some(prefab) = prefab_storage.get(handle) {
-                if let Some(cooked_prefab) = prefab.cooked.as_ref() {
-                    if let Some(instance) = instance {
-                        if instance.version < prefab.version {
-                            log::debug!("Updating existing prefab.");
-                            if let Some((root_entity,)) =
-                                entity_query.iter(&cooked_prefab.world).next()
-                            {
-                                instance.entity_map.insert(*root_entity, *entity);
-                            };
-
-                            prefabs.push((
-                                *entity,
-                                cooked_prefab,
-                                prefab.version,
-                                instance.entity_map.clone(),
-                                handle.clone(),
-                            ));
-                        }
-                    } else {
-                        log::debug!("Spawning new prefab.");
-                        let mut map = HashMap::<Entity, Entity, EntityHasher>::default();
+            if let Some(Prefab {
+                cooked: Some(cooked_prefab),
+                version: prefab_version,
+                ..
+            }) = prefab_storage.get(handle)
+            {
+                let instance_version = instance
+                    .as_ref()
+                    .map(|instance| instance.version)
+                    .unwrap_or(0);
+                if instance_version < *prefab_version {
+                    let mut entity_map = instance
+                        .as_ref()
+                        .map(|instance| instance.entity_map.clone())
+                        .unwrap_or_default();
+                    if entity_map.is_empty() {
                         if let Some((root_entity,)) = entity_query.iter(&cooked_prefab.world).next()
                         {
-                            map.insert(*root_entity, *entity);
-                        };
-                        prefabs.push((*entity, cooked_prefab, prefab.version, map, handle.clone()));
+                            entity_map.insert(*root_entity, *entity);
+                        }
                     }
+                    prefabs.push((*entity, cooked_prefab, *prefab_version, entity_map));
                 }
             }
         },
     );
 
-    for (entity, prefab, version, prev_entity_map, handle) in prefabs.into_iter() {
+    for (entity, prefab, version, prev_entity_map) in prefabs.into_iter() {
         let entity_map = world.clone_from(
             &prefab.world,
             &query::any(),
@@ -82,8 +75,8 @@ pub fn prefab_spawning_tick(world: &mut World, resources: &mut Resources) {
         log::debug!("new entity_map: {:?}", entity_map);
         log::debug!("old entity map: {:?}", prev_entity_map);
 
-        for value in prev_entities.difference(&live_entities) {
-            if world.remove(*value) {
+        for value in prev_entities.difference(&live_entities).copied() {
+            if world.remove(value) {
                 log::debug!("Removed entity {:?}", value)
             }
         }
@@ -95,7 +88,6 @@ pub fn prefab_spawning_tick(world: &mut World, resources: &mut Resources) {
                 version,
                 entity_map,
             });
-            entry.add_component(handle);
         } else {
             log::error!("Could not update entity");
         }

amethyst_assets/src/processor.rs

@@ -43,6 +43,8 @@ where
                 .write_resource::<ProcessingQueue<A::Data>>()
                 .write_resource::<AssetStorage<A>>()
                 .build(|_, _, (queue, storage), _| {
+                    // drain the changed queue
+                    while let Some(_) = queue.changed.pop() {}
                     queue.process(storage, ProcessableAsset::process);
                     storage.process_custom_drop(|_| {});
                 }),

amethyst_assets/src/storage.rs

@@ -1,7 +1,6 @@
-use std::collections::HashMap;
-
 use atelier_assets::loader::{handle::AssetHandle, storage::IndirectionTable, LoadHandle};
 use crossbeam_queue::SegQueue;
+use fnv::FnvHashMap;
 
 struct AssetState<A> {
     version: u32,
@@ -14,8 +13,8 @@ struct AssetState<A> {
 ///
 /// * `A`: Asset Rust type.
 pub struct AssetStorage<A> {
-    assets: HashMap<LoadHandle, AssetState<A>>,
-    uncommitted: HashMap<LoadHandle, AssetState<A>>,
+    assets: FnvHashMap<LoadHandle, AssetState<A>>,
+    uncommitted: FnvHashMap<LoadHandle, AssetState<A>>,
     to_drop: SegQueue<A>,
     indirection_table: IndirectionTable,
 }
@@ -33,8 +32,12 @@ impl<A> AssetStorage<A> {
 
     /// Added to make api compatible with previous storage
     pub fn unload_all(&mut self) {
-        // FIXME do the unload correctly
-        self.assets.clear();
+        for (_, data) in self.uncommitted.drain() {
+            self.to_drop.push(data.asset);
+        }
+        for (_, data) in self.assets.drain() {
+            self.to_drop.push(data.asset);
+        }
     }
 
     pub(crate) fn update_asset(&mut self, handle: LoadHandle, asset: A, version: u32) {