Merge pull request #671 from aws-lumberyard-dev/Prefabs/AssetPreload

Asset Preload fix for json serialization and prefab game mode
2021-05-11 09:35:06 -07:00
parent 02d88bc8da 286a1aafa9
commit 2e32b2ee57
15 changed files with 236 additions and 23 deletions
@@ -13,6 +13,7 @@
 #include <AzCore/Component/Entity.h>
 #include <AzCore/Component/TransformBus.h>
 #include <AzCore/Script/ScriptSystemBus.h>
+#include <AzCore/Serialization/Utils.h>
 #include <AzFramework/API/ApplicationAPI.h>
 #include <AzFramework/Entity/GameEntityContextBus.h>
 #include <AzFramework/Spawnable/RootSpawnableInterface.h>
@@ -342,6 +343,65 @@ namespace AzToolsFramework
        m_validateEntitiesCallback = AZStd::move(validateEntitiesCallback);
    }

+    void PrefabEditorEntityOwnershipService::LoadReferencedAssets(AZStd::vector<AZ::Data::Asset<AZ::Data::AssetData>>& referencedAssets)
+    {
+        // Start our loads on all assets by calling GetAsset from the AssetManager
+        for (AZ::Data::Asset<AZ::Data::AssetData>& asset : referencedAssets)
+        {
+            if (!asset.GetId().IsValid())
+            {
+                AZ_Error("Prefab", false, "Invalid asset found referenced in scene while entering game mode");
+                continue;
+            }
+
+            const AZ::Data::AssetLoadBehavior loadBehavior = asset.GetAutoLoadBehavior();
+
+            if (loadBehavior == AZ::Data::AssetLoadBehavior::NoLoad)
+            {
+                continue;
+            }
+
+            AZ::Data::AssetId assetId = asset.GetId();
+            AZ::Data::AssetType assetType = asset.GetType();
+
+            asset = AZ::Data::AssetManager::Instance().GetAsset(assetId, assetType, loadBehavior);
+
+            if (!asset.GetId().IsValid())
+            {
+                AZ_Error("Prefab", false, "Invalid asset found referenced in scene while entering game mode");
+                continue;
+            }
+        }
+
+        // For all Preload assets we block until they're ready
+        // We do this as a seperate pass so that we don't interrupt queuing up all other asset loads
+        for (AZ::Data::Asset<AZ::Data::AssetData>& asset : referencedAssets)
+        {
+            if (!asset.GetId().IsValid())
+            {
+                AZ_Error("Prefab", false, "Invalid asset found referenced in scene while entering game mode");
+                continue;
+            }
+
+            const AZ::Data::AssetLoadBehavior loadBehavior = asset.GetAutoLoadBehavior();
+
+            if (loadBehavior != AZ::Data::AssetLoadBehavior::PreLoad)
+            {
+                continue;
+            }
+
+            asset.BlockUntilLoadComplete();
+
+            if (asset.IsError())
+            {
+                AZ_Error("Prefab", false, "Asset with id %s failed to preload while entering game mode",
+                    asset.GetId().ToString<AZStd::string>().c_str());
+
+                continue;
+            }
+        }
+    }
+
    void PrefabEditorEntityOwnershipService::StartPlayInEditor()
    {
        // This is a workaround until the replacement for GameEntityContext is done
@@ -381,16 +441,21 @@ namespace AzToolsFramework
                                rootSpawnableIndex = m_playInEditorData.m_assets.size();
                            }

+                            LoadReferencedAssets(product.GetReferencedAssets());
+
                            AZ::Data::AssetInfo info;
                            info.m_assetId = product.GetAsset().GetId();
                            info.m_assetType = product.GetAssetType();
                            info.m_relativePath = product.GetId();

                            AZ::Data::AssetCatalogRequestBus::Broadcast(
-                                &AZ::Data::AssetCatalogRequestBus::Events::RegisterAsset, product.GetAsset().GetId(), info);
+                                &AZ::Data::AssetCatalogRequestBus::Events::RegisterAsset, info.m_assetId, info);
                            m_playInEditorData.m_assets.emplace_back(product.ReleaseAsset().release(), AZ::Data::AssetLoadBehavior::Default);
                        }

+                        // make sure that PRE_NOTIFY assets get their notify before we activate, so that we can preserve the order of 
+                        // (load asset) -> (notify) -> (init) -> (activate)
+                        AZ::Data::AssetManager::Instance().DispatchEvents();

                        if (rootSpawnableIndex != NoRootSpawnable)
                        {
@@ -199,6 +199,8 @@ namespace AzToolsFramework

        void OnEntityRemoved(AZ::EntityId entityId);

+        void LoadReferencedAssets(AZStd::vector<AZ::Data::Asset<AZ::Data::AssetData>>& referencedAssets);
+
        OnEntitiesAddedCallback m_entitiesAddedCallback;
        OnEntitiesRemovedCallback m_entitiesRemovedCallback;
        ValidateEntitiesCallback m_validateEntitiesCallback;
@@ -11,8 +11,10 @@
 */

 #include <AzCore/Asset/AssetManager.h>
+#include <AzCore/Asset/AssetJsonSerializer.h>
 #include <AzCore/JSON/prettywriter.h>
 #include <AzCore/Serialization/Json/JsonSerialization.h>
+
 #include <AzToolsFramework/Entity/EditorEntityContextBus.h>
 #include <AzToolsFramework/Prefab/PrefabDomUtils.h>
 #include <AzToolsFramework/Prefab/Instance/Instance.h>
@@ -115,6 +117,48 @@ namespace AzToolsFramework
                return true;
            }

+            bool LoadInstanceFromPrefabDom(
+                Instance& instance, const PrefabDom& prefabDom, AZStd::vector<AZ::Data::Asset<AZ::Data::AssetData>>& referencedAssets, LoadInstanceFlags flags)
+            {
+                // When entities are rebuilt they are first destroyed. As a result any assets they were exclusively holding on to will
+                // be released and reloaded once the entities are built up again. By suspending asset release temporarily the asset reload
+                // is avoided.
+                AZ::Data::AssetManager::Instance().SuspendAssetRelease();
+
+                InstanceEntityIdMapper entityIdMapper;
+                entityIdMapper.SetLoadingInstance(instance);
+                if ((flags & LoadInstanceFlags::AssignRandomEntityId) == LoadInstanceFlags::AssignRandomEntityId)
+                {
+                    entityIdMapper.SetEntityIdGenerationApproach(InstanceEntityIdMapper::EntityIdGenerationApproach::Random);
+                }
+
+                AZ::JsonDeserializerSettings settings;
+                // The InstanceEntityIdMapper is registered twice because it's used in several places during deserialization where one is
+                // specific for the InstanceEntityIdMapper and once for the generic JsonEntityIdMapper. Because the Json Serializer's meta
+                // data has strict typing and doesn't look for inheritance both have to be explicitly added so they're found both locations.
+                settings.m_metadata.Add(static_cast<AZ::JsonEntityIdSerializer::JsonEntityIdMapper*>(&entityIdMapper));
+                settings.m_metadata.Add(&entityIdMapper);
+                settings.m_metadata.Create<AZ::Data::SerializedAssetTracker>();
+
+                AZ::JsonSerializationResult::ResultCode result =
+                    AZ::JsonSerialization::Load(instance, prefabDom, settings);
+
+                AZ::Data::AssetManager::Instance().ResumeAssetRelease();
+
+                if (result.GetProcessing() == AZ::JsonSerializationResult::Processing::Halted)
+                {
+                    AZ_Error("Prefab", false,
+                        "Failed to de-serialize Prefab Instance from Prefab DOM. "
+                        "Unable to proceed.");
+
+                    return false;
+                }
+                AZ::Data::SerializedAssetTracker* assetTracker = settings.m_metadata.Find<AZ::Data::SerializedAssetTracker>();
+
+                referencedAssets = AZStd::move(assetTracker->GetTrackedAssets());
+                return true;
+            }
+
            bool LoadInstanceFromPrefabDom(
                Instance& instance, Instance::EntityList& newlyAddedEntities, const PrefabDom& prefabDom, LoadInstanceFlags flags)
            {
@@ -13,6 +13,7 @@
 #pragma once

 #include <AzCore/std/optional.h>
+#include <AzCore/Asset/AssetCommon.h>
 #include <AzToolsFramework/Prefab/Instance/Instance.h>
 #include <AzToolsFramework/Prefab/PrefabDomTypes.h>

@@ -42,7 +43,7 @@ namespace AzToolsFramework
            /**
            * Stores a valid Prefab Instance within a Prefab Dom. Useful for generating Templates
            * @param instance The instance to store
-            * @param prefabDom the prefabDom that will be used to store the Instance data
+            * @param prefabDom The prefabDom that will be used to store the Instance data
            * @return bool on whether the operation succeeded
            */
            bool StoreInstanceInPrefabDom(const Instance& instance, PrefabDom& prefabDom);
@@ -60,20 +61,32 @@ namespace AzToolsFramework
            /**
            * Loads a valid Prefab Instance from a Prefab Dom. Useful for generating Instances.
            * @param instance The Instance to load.
-            * @param prefabDom the prefabDom that will be used to load the Instance data.
-            * @param shouldClearContainers whether to clear containers in Instance while loading.
+            * @param prefabDom The prefabDom that will be used to load the Instance data.
+            * @param shouldClearContainers Whether to clear containers in Instance while loading.
            * @return bool on whether the operation succeeded.
            */
            bool LoadInstanceFromPrefabDom(
                Instance& instance, const PrefabDom& prefabDom, LoadInstanceFlags flags = LoadInstanceFlags::None);

+            /**
+            * Loads a valid Prefab Instance from a Prefab Dom. Useful for generating Instances.
+            * @param instance The Instance to load.
+            * @param referencedAssets AZ::Assets discovered during json load are added to this list
+            * @param prefabDom The prefabDom that will be used to load the Instance data.
+            * @param shouldClearContainers Whether to clear containers in Instance while loading.
+            * @return bool on whether the operation succeeded.
+            */
+            bool LoadInstanceFromPrefabDom(
+                Instance& instance, const PrefabDom& prefabDom, AZStd::vector<AZ::Data::Asset<AZ::Data::AssetData>>& referencedAssets,
+                LoadInstanceFlags flags = LoadInstanceFlags::None);
+
            /**
            * Loads a valid Prefab Instance from a Prefab Dom. Useful for generating Instances.
            * @param instance The Instance to load.
            * @param newlyAddedEntities The new instances added during deserializing the instance. These are the entities found
            *       in the prefabDom.
-            * @param prefabDom the prefabDom that will be used to load the Instance data.
-            * @param shouldClearContainers whether to clear containers in Instance while loading.
+            * @param prefabDom The prefabDom that will be used to load the Instance data.
+            * @param shouldClearContainers Whether to clear containers in Instance while loading.
            * @return bool on whether the operation succeeded.
            */
            bool LoadInstanceFromPrefabDom(
@@ -63,7 +63,7 @@ namespace AzToolsFramework::Prefab::PrefabConversionUtils
            AZStd::move(uniqueName), context.GetSourceUuid(), AZStd::move(serializer));
        AZ_Assert(spawnable, "Failed to create a new spawnable.");

-        bool result = SpawnableUtils::CreateSpawnable(*spawnable, prefab);
+        bool result = SpawnableUtils::CreateSpawnable(*spawnable, prefab, object.GetReferencedAssets());
        if (result)
        {
            AzFramework::Spawnable::EntityList& entities = spawnable->GetEntities();
@@ -56,6 +56,16 @@ namespace AzToolsFramework::Prefab::PrefabConversionUtils
        return *m_asset;
    }

+    AZStd::vector<AZ::Data::Asset<AZ::Data::AssetData>>& ProcessedObjectStore::GetReferencedAssets()
+    {
+        return m_referencedAssets;
+    }
+
+    const AZStd::vector<AZ::Data::Asset<AZ::Data::AssetData>>& ProcessedObjectStore::GetReferencedAssets() const
+    {
+        return m_referencedAssets;
+    }
+
    AZStd::unique_ptr<AZ::Data::AssetData> ProcessedObjectStore::ReleaseAsset()
    {
        return AZStd::move(m_asset);
@@ -48,6 +48,10 @@ namespace AzToolsFramework::Prefab::PrefabConversionUtils
        AZ::Data::AssetData& GetAsset();
        AZStd::unique_ptr<AZ::Data::AssetData> ReleaseAsset();

+        AZStd::vector<AZ::Data::Asset<AZ::Data::AssetData>>& GetReferencedAssets();
+        const AZStd::vector<AZ::Data::Asset<AZ::Data::AssetData>>& GetReferencedAssets() const;
+
+
        const AZStd::string& GetId() const;

    private:
@@ -55,6 +59,7 @@ namespace AzToolsFramework::Prefab::PrefabConversionUtils

        SerializerFunction m_assetSerializer;
        AZStd::unique_ptr<AZ::Data::AssetData> m_asset;
+        AZStd::vector<AZ::Data::Asset<AZ::Data::AssetData>> m_referencedAssets;
        AZStd::string m_uniqueId;
    };

@@ -28,16 +28,23 @@ namespace AzToolsFramework::Prefab::SpawnableUtils
    AzFramework::Spawnable CreateSpawnable(const PrefabDom& prefabDom)
    {
        AzFramework::Spawnable spawnable;
-        [[maybe_unused]] bool result = CreateSpawnable(spawnable, prefabDom);
+        AZStd::vector<AZ::Data::Asset<AZ::Data::AssetData>> referencedAssets;
+        [[maybe_unused]] bool result = CreateSpawnable(spawnable, prefabDom, referencedAssets);
        AZ_Assert(result,
            "Failed to Load Prefab Instance from given Prefab DOM while Spawnable creation.");
        return spawnable;
    }

    bool CreateSpawnable(AzFramework::Spawnable& spawnable, const PrefabDom& prefabDom)
+    {
+        AZStd::vector<AZ::Data::Asset<AZ::Data::AssetData>> referencedAssets;
+        return CreateSpawnable(spawnable, prefabDom, referencedAssets);
+    }
+
+    bool CreateSpawnable(AzFramework::Spawnable& spawnable, const PrefabDom& prefabDom, AZStd::vector<AZ::Data::Asset<AZ::Data::AssetData>>& referencedAssets)
    {
        Instance instance;
-        if (Prefab::PrefabDomUtils::LoadInstanceFromPrefabDom(instance, prefabDom,
+        if (Prefab::PrefabDomUtils::LoadInstanceFromPrefabDom(instance, prefabDom, referencedAssets,
            Prefab::PrefabDomUtils::LoadInstanceFlags::AssignRandomEntityId)) // Always assign random entity ids because the spawnable is
                                                                              // going to be used to create clones of the entities.
        {
@@ -19,6 +19,7 @@ namespace AzToolsFramework::Prefab::SpawnableUtils
 {
    AzFramework::Spawnable CreateSpawnable(const PrefabDom& prefabDom);
    bool CreateSpawnable(AzFramework::Spawnable& spawnable, const PrefabDom& prefabDom);
+    bool CreateSpawnable(AzFramework::Spawnable& spawnable, const PrefabDom& prefabDom, AZStd::vector<AZ::Data::Asset<AZ::Data::AssetData>>& referencedAssets);

    void SortEntitiesByTransformHierarchy(AzFramework::Spawnable& spawnable);
 } // namespace AzToolsFramework::Prefab::SpawnableUtils