fix: Allow to convert .slice to .prefabs (o3de#17478)

* new: Allow to convert slice to prefab without asset processor
* clean: keep same code path when using asset processor
* clean: Add comments to new methods
* clean: handle review comments

---------

Signed-off-by: guillaume-haerinck <[email protected]>

Author: guillaume-haerinck

Code/Framework/AzCore/AzCore/Serialization/SerializationUtils.cpp

@@ -527,6 +527,32 @@ namespace AZ::Utils
         return ptr;
     }
 
+    bool InspectSerializedFile(
+        const char* filePath,
+        SerializeContext* sc,
+        const ObjectStream::ClassReadyCB& classCallback,
+        Data::AssetFilterCB assetFilterCallback)
+    {
+        AZ::IO::FileIOStream stream(filePath, AZ::IO::OpenMode::ModeRead);
+        if (!stream.IsOpen())
+        {
+            AZ_Error("Verify", false, "File '%s' could not be opened.", filePath);
+            return false;
+        }
+
+        ObjectStream::FilterDescriptor filter;
+        // By default, never load dependencies. That's another file that would need to be processed
+        // separately from this one.
+        filter.m_assetCB = assetFilterCallback;
+        if (!ObjectStream::LoadBlocking(&stream, *sc, classCallback, filter))
+        {
+            AZ_Printf("Verify", "Failed to deserialize '%s'\n", filePath);
+            return false;
+        }
+
+        return true;
+    }
+
     AZ::Attribute* FindEditOrSerializeContextAttribute(AZ::AttributeId attributeId, const AZ::SerializeContext::ClassData* classData,
         const AZ::SerializeContext::ClassElement* classElement, const AZ::Edit::ClassData* editClassData, const AZ::Edit::ElementData* elementEditData)
     {
@@ -598,4 +624,5 @@ namespace AZ::Utils
         const AZ::Edit::ElementData* elementEditData = classElement != nullptr ? classElement->m_editData : nullptr;
         return FindEditOrSerializeContextAttribute(attributeId, classData, classElement, editClassData, elementEditData);
     }
+
 } // namespace AZ::Utils

Code/Framework/AzCore/AzCore/Serialization/Utils.h

@@ -139,6 +139,15 @@ namespace AZ
         /// Resolve the instance pointer for a given ClassElement by casting it to the actual type
         /// expected by the ClassData for this element
         void* ResolvePointer(void* ptr, const SerializeContext::ClassElement& classElement, const SerializeContext& context);
+
+        //! Open the given file and load it into an ObjectStream that you can inspect
+        //! @param classCallback Called for each root object loaded via the ObjectStream. Use it to read values from the file.
+        //! @param assetFilterCallback Limit the processing/loading to specific asset type(s)
+        bool InspectSerializedFile(
+            const char* filePath,
+            SerializeContext* sc,
+            const ObjectStream::ClassReadyCB& classCallback,
+            Data::AssetFilterCB assetFilterCallback = AZ::Data::AssetFilterNoAssetLoading);
     } // namespace Utils
 } // namespace Az
 

Code/Framework/AzCore/AzCore/Slice/SliceComponent.cpp

@@ -1052,7 +1052,10 @@ namespace AZ
     //=========================================================================
     // SliceComponent::SliceReference::Instantiate
     //=========================================================================
-    bool SliceComponent::SliceReference::Instantiate(const AZ::ObjectStream::FilterDescriptor& filterDesc)
+    bool SliceComponent::SliceReference::Instantiate(
+        const AZ::ObjectStream::FilterDescriptor& filterDesc,
+        AZ::SerializeContext* serializeContext,
+        AZStd::unordered_map<AZStd::string, AZStd::string>* relativeToAbsoluteSlicePaths)
     {
         AZ_PROFILE_FUNCTION(AzCore);
 
@@ -1061,41 +1064,64 @@ namespace AZ
             return true;
         }
 
-        AZ::Data::AssetInfo assetInfo;
-        AZ::Data::AssetCatalogRequestBus::BroadcastResult(assetInfo, &AZ::Data::AssetCatalogRequestBus::Events::GetAssetInfoById, m_asset.GetId());
-        bool isAssetStillOnDisk = assetInfo.m_assetId.IsValid();
-
-        bool isCachedAssetReady = m_asset.IsReady();
-
-        if (!(isCachedAssetReady && isAssetStillOnDisk))
+        SliceComponent* dependentSlice = nullptr;
+        const bool useAssetCatalog = !serializeContext || !relativeToAbsoluteSlicePaths;
+        if (useAssetCatalog)
         {
-            // If the asset has been queued for async loading but hasn't completed, we've reached the point where it is required
-            // to be complete, so block until it finishes loading.
-            if (m_asset.IsLoading())
-            {
-                m_asset.BlockUntilLoadComplete();
-            }
+            AZ::Data::AssetInfo assetInfo;
+            AZ::Data::AssetCatalogRequestBus::BroadcastResult(assetInfo, &AZ::Data::AssetCatalogRequestBus::Events::GetAssetInfoById, m_asset.GetId());
 
-            // If the asset still isn't ready, an unexpected error has occurred.
-            if (!m_asset.IsReady())
+            const bool isAssetStillOnDisk = assetInfo.m_assetId.IsValid();
+            const bool isCachedAssetReady = m_asset.IsReady();
+            if (!(isCachedAssetReady && isAssetStillOnDisk))
             {
+                // If the asset has been queued for async loading but hasn't completed, we've reached the point where it is required
+                // to be complete, so block until it finishes loading.
+                if (m_asset.IsLoading())
+                {
+                    m_asset.BlockUntilLoadComplete();
+                }
+
+                // If the asset still isn't ready, an unexpected error has occurred.
+                if (!m_asset.IsReady())
+                {
 #if defined(AZ_ENABLE_TRACING)
-                const Data::Asset<SliceAsset> owningAsset = m_component->m_myAsset ?
-                    Data::Asset<SliceAsset>(Data::AssetManager::Instance().FindAsset(m_component->m_myAsset->GetId(), AZ::Data::AssetLoadBehavior::Default)) :
-                    Data::Asset<SliceAsset>();
-                AZ_Error("Slice", false,
-                    "Instantiation of %d slice instance(s) of asset %s failed - asset not ready or not found during instantiation of owning slice %s!"
-                    "Saving owning slice will lose data for these instances.",
-                    m_instances.size(),
-                    m_asset.ToString<AZStd::string>().c_str(),
-                    m_component->m_myAsset ? owningAsset.ToString<AZStd::string>().c_str() : "[Could not find owning slice]");
+                    const Data::Asset<SliceAsset> owningAsset = m_component->m_myAsset ?
+                        Data::Asset<SliceAsset>(Data::AssetManager::Instance().FindAsset(m_component->m_myAsset->GetId(), AZ::Data::AssetLoadBehavior::Default)) :
+                        Data::Asset<SliceAsset>();
+                    AZ_Error("Slice", false,
+                        "Instantiation of %d slice instance(s) of asset %s failed - asset not ready or not found during instantiation of owning slice %s!"
+                        "Saving owning slice will lose data for these instances.",
+                        m_instances.size(),
+                        m_asset.ToString<AZStd::string>().c_str(),
+                        m_component->m_myAsset ? owningAsset.ToString<AZStd::string>().c_str() : "[Could not find owning slice]");
 #endif // AZ_ENABLE_TRACING
+                    return false;
+                }
+            }
+            dependentSlice = m_asset.Get()->GetComponent();
+        }
+        else
+        {
+            const AZStd::string& path = (*relativeToAbsoluteSlicePaths)[m_asset.GetHint()];
+            if (path.empty())
+            {
+                AZ_Error("SliceReference::Instantiate", false, "Failed to find Slice relative path from %s", m_asset.GetHint().c_str());
                 return false;
             }
+
+            AZ::Entity* sliceRootEntity = AZ::EntityUtils::LoadRootEntityFromSlicePath(path.c_str(), serializeContext);
+            dependentSlice = AZ::EntityUtils::FindFirstDerivedComponent<SliceComponent>(sliceRootEntity);
+            m_asset.Get()->SetData(sliceRootEntity, dependentSlice, false);
         }
 
-        SliceComponent* dependentSlice = m_asset.Get()->GetComponent();
-        InstantiateResult instantiationResult = dependentSlice->Instantiate();
+        if (!dependentSlice)
+        {
+            AZ_Error("SliceReference::Instantiate", false, "Failed to get SliceComponent from %s", m_asset.GetHint().c_str());
+            return false;
+        }
+        
+        InstantiateResult instantiationResult = dependentSlice->Instantiate(serializeContext, relativeToAbsoluteSlicePaths);
         if (instantiationResult != InstantiateResult::Success)
         {
             #if defined(AZ_ENABLE_TRACING)
@@ -1653,7 +1679,9 @@ namespace AZ
     //=========================================================================
     // SliceComponent::Instantiate
     //=========================================================================
-    SliceComponent::InstantiateResult SliceComponent::Instantiate()
+    SliceComponent::InstantiateResult SliceComponent::Instantiate(
+        AZ::SerializeContext* serializeContext,
+        AZStd::unordered_map<AZStd::string, AZStd::string>* relativeToAbsoluteSlicePaths)
     {
         AZ_PROFILE_FUNCTION(AzCore);
         AZStd::unique_lock<AZStd::recursive_mutex> lock(m_instantiateMutex);
@@ -1684,7 +1712,8 @@ namespace AZ
             }
             else
             {
-                bool instantiateSuccess = slice.Instantiate(AZ::ObjectStream::FilterDescriptor(m_assetLoadFilterCB, m_filterFlags));
+                bool instantiateSuccess = slice.Instantiate(
+                    AZ::ObjectStream::FilterDescriptor(m_assetLoadFilterCB, m_filterFlags), serializeContext, relativeToAbsoluteSlicePaths);
                 if (instantiateSuccess)
                 {
                     // Prune empty slice instances.
@@ -3956,4 +3985,40 @@ namespace AZ
                 ;
         }
     }
+
+    namespace EntityUtils
+    {
+        AZ::Entity* LoadRootEntityFromSlicePath(const char* filePath, SerializeContext* context)
+        {
+            AZ::Entity* sliceRootEntity = nullptr;
+            auto callback = [&sliceRootEntity](void* classPtr, const Uuid& classId, SerializeContext* serializeContext)
+            {
+                sliceRootEntity = serializeContext->Cast<AZ::Entity*>(classPtr, classId);
+                if (!sliceRootEntity)
+                {
+                    AZ_Warning("LoadRootEntityFromSlicePath", false, "  File not opened: Slice root is not an entity.\n");
+                    return false;
+                }
+                return true;
+            };
+
+            if (!AZ::Utils::InspectSerializedFile(
+                    filePath,
+                    context,
+                    callback,
+                    [](const AZ::Data::AssetFilterInfo& filterInfo)
+                    {
+                        return (filterInfo.m_assetType == azrtti_typeid<AZ::SliceAsset>());
+                    }))
+            {
+                AZ_Warning("LoadRootEntityFromSlicePath", false, "Failed to load '%s'. File may not contain an object stream.", filePath);
+                return nullptr;
+            }
+
+            return sliceRootEntity;
+        }
+    }
+
 } // namespace AZ
+
+

Code/Framework/AzCore/AzCore/Slice/SliceComponent.h

@@ -524,7 +524,11 @@ namespace AZ
                 const AZ::IdUtils::Remapper<AZ::EntityId>::IdMapper& customMapper = nullptr);
 
             /// Instantiate all instances (by default we just hold the deltas - data patch), the Slice component controls the instantiate state
-            bool Instantiate(const AZ::ObjectStream::FilterDescriptor& filterDesc);
+            /// serializeContext and relativeToAbsoluteSlicePaths arguments are used for a specific case when asset processor is not available
+            bool Instantiate(
+                const AZ::ObjectStream::FilterDescriptor& filterDesc,
+                AZ::SerializeContext* serializeContext = nullptr,
+                AZStd::unordered_map<AZStd::string, AZStd::string>* relativeToAbsoluteSlicePaths = nullptr);
 
             void UnInstantiate();
 
@@ -936,8 +940,11 @@ namespace AZ
 
         /**
         * Instantiate entities for this slice, otherwise only the data are stored.
+        * \param serializeContext and relativeToAbsoluteSlicePaths are used for a specific case when asset processor is not available
         */
-        InstantiateResult Instantiate();
+        InstantiateResult Instantiate(
+            AZ::SerializeContext* serializeContext = nullptr,
+            AZStd::unordered_map<AZStd::string, AZStd::string>* relativeToAbsoluteSlicePaths = nullptr);
         bool IsInstantiated() const;
         /**
          * Generate new entity Ids and remap references
@@ -1122,6 +1129,9 @@ namespace AZ
 
             return replaced;
         }
+
+        // Deserialize a slice without using asset processor and read root entity from it
+        AZ::Entity* LoadRootEntityFromSlicePath(const char* filePath, SerializeContext* context);
     } // namespace EntityUtils
 
     namespace IdUtils

Code/Tools/SerializeContextTools/Converter.cpp

@@ -114,7 +114,7 @@ namespace AZ
                     }
                     return true;
                 };
-                if (!Utilities::InspectSerializedFile(filePath.c_str(), convertSettings.m_serializeContext, callback))
+                if (!AZ::Utils::InspectSerializedFile(filePath.c_str(), convertSettings.m_serializeContext, callback))
                 {
                     AZ_Warning("Convert", false, "Failed to load '%s'. File may not contain an object stream.", filePath.c_str());
                     result = false;

Code/Tools/SerializeContextTools/Dumper.cpp

@@ -20,6 +20,7 @@
 #include <AzCore/Serialization/EditContext.h>
 #include <AzCore/Serialization/Json/JsonSerialization.h>
 #include <AzCore/Serialization/Json/JsonSerializationSettings.h>
+#include <AzCore/Serialization/Utils.h>
 #include <AzCore/Settings/TextParser.h>
 #include <AzCore/Settings/SettingsRegistryMergeUtils.h>
 #include <AzCore/std/algorithm.h>
@@ -207,7 +208,7 @@ namespace AZ::SerializeContextTools
                     result = false;
                 }
             };
-            if (!Utilities::InspectSerializedFile(filePath.c_str(), sc, callback))
+            if (!AZ::Utils::InspectSerializedFile(filePath.c_str(), sc, callback))
             {
                 result = false;
                 continue;

Code/Tools/SerializeContextTools/Runner.cpp

@@ -72,11 +72,12 @@ namespace SerializeContextTools
         AZ_Printf("Help", R"(    example: 'convert-ini --files=AssetProcessorPlatformConfig.ini;bootstrap.cfg --ext=setreg)" "\n");
         AZ_Printf("Help", "  'convert-slice': Converts ObjectStream-based slice files or legacy levels to a JSON-based prefab.\n");
         AZ_Printf("Help", "    [arg] -files=<path>: <comma or semicolon>-separated list of files to convert. Supports wildcards.\n");
+        AZ_Printf("Help", "    [opt] -slices=<path>: <comma or semicolon>-separated list of .slice files that you converted files depends on. Supports wildcards. Use this if you cannot use the asset processor on the target project (like o3de converting lumberyard)\n");
         AZ_Printf("Help", "    [opt] -dryrun: Processes as normal, but doesn't write files.\n");
         AZ_Printf("Help", "    [opt] -keepdefaults: Fields are written if a default value was found.\n");
         AZ_Printf("Help", "    [opt] -verbose: Report additional details during the conversion process.\n");
         AZ_Printf("Help", "    example: 'convert-slice -files=*.slice -specializations=editor\n");
-        AZ_Printf("Help", "    example: 'convert-slice -files=Levels/TestLevel/TestLevel.ly -specializations=editor\n");
+        AZ_Printf("Help", "    example: 'convert-slice -files=Levels/TestLevel/TestLevel.ly -project-path=F:/lmbr-fork/dev/StarterGame -slices=Gems/*.slice -specializations=editor\n");
         AZ_Printf("Help", "\n");
         AZ_Printf("Help", "  'createtype': Create a default constructed object using Json Serialization and output the contents.\n");
         AZ_Printf("Help", "    [arg] --type-name=<string>: Name of type to construct and output.\n");