decouple SceneBuilder from AssImp

* use AbstractFactory pattern to deliver family of classes specific for chosen Importer
* use existing AssImp Importer as a default one if no specializations available

Signed-off-by: Mateusz Żak <[email protected]>

Author: zakmat

Code/Tools/SceneAPI/SceneBuilder/DllMain.cpp

@@ -8,26 +8,30 @@
 
 #if !defined(AZ_MONOLITHIC_BUILD)
 
+#include "ImportContexts/AssImpImportContextProvider.h"
+#include "SceneBuilderSystemComponent.h"
+
 #include <AzCore/Component/Component.h>
 #include <AzCore/Component/ComponentApplicationBus.h>
-#include <AzCore/std/containers/vector.h>
 #include <AzCore/Module/Environment.h>
+#include <AzCore/std/containers/vector.h>
+#include <SceneAPI/SceneBuilder/ImportContextRegistry.h>
 #include <SceneAPI/SceneBuilder/SceneImportRequestHandler.h>
 
-#include <SceneAPI/SceneBuilder/SceneImporter.h>
+#include <SceneAPI/SceneBuilder/Importers/AssImpAnimationImporter.h>
 #include <SceneAPI/SceneBuilder/Importers/AssImpBitangentStreamImporter.h>
+#include <SceneAPI/SceneBuilder/Importers/AssImpBlendShapeImporter.h>
+#include <SceneAPI/SceneBuilder/Importers/AssImpBoneImporter.h>
 #include <SceneAPI/SceneBuilder/Importers/AssImpColorStreamImporter.h>
 #include <SceneAPI/SceneBuilder/Importers/AssImpCustomPropertyImporter.h>
 #include <SceneAPI/SceneBuilder/Importers/AssImpMaterialImporter.h>
 #include <SceneAPI/SceneBuilder/Importers/AssImpMeshImporter.h>
+#include <SceneAPI/SceneBuilder/Importers/AssImpSkinImporter.h>
+#include <SceneAPI/SceneBuilder/Importers/AssImpSkinWeightsImporter.h>
 #include <SceneAPI/SceneBuilder/Importers/AssImpTangentStreamImporter.h>
 #include <SceneAPI/SceneBuilder/Importers/AssImpTransformImporter.h>
 #include <SceneAPI/SceneBuilder/Importers/AssImpUvMapImporter.h>
-#include <SceneAPI/SceneBuilder/Importers/AssImpSkinImporter.h>
-#include <SceneAPI/SceneBuilder/Importers/AssImpSkinWeightsImporter.h>
-#include <SceneAPI/SceneBuilder/Importers/AssImpBoneImporter.h>
-#include <SceneAPI/SceneBuilder/Importers/AssImpAnimationImporter.h>
-#include <SceneAPI/SceneBuilder/Importers/AssImpBlendShapeImporter.h>
+#include <SceneAPI/SceneBuilder/SceneImporter.h>
 
 namespace AZ
 {
@@ -50,6 +54,9 @@ namespace AZ
                     g_componentDescriptors.push_back(SceneBuilder::SceneImporter::CreateDescriptor());
                     g_componentDescriptors.push_back(SceneImportRequestHandler::CreateDescriptor());
 
+                    // ImportContextProviderRegistry
+                    g_componentDescriptors.push_back(SceneBuilderSystemComponent::CreateDescriptor());
+
                     // Node and attribute importers
                     g_componentDescriptors.push_back(AssImpBitangentStreamImporter::CreateDescriptor());
                     g_componentDescriptors.push_back(AssImpColorStreamImporter::CreateDescriptor());

Code/Tools/SceneAPI/SceneBuilder/ImportContextRegistry.h

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+#pragma once
+
+#include <AzCore/Interface/Interface.h>
+#include <AzCore/Memory/SystemAllocator.h>
+#include <AzCore/RTTI/RTTI.h>
+#include <AzCore/std/smart_ptr/unique_ptr.h>
+
+namespace AZ
+{
+    namespace SceneAPI
+    {
+        namespace SceneBuilder
+        {
+            struct ImportContextProvider;
+
+            // ImportContextRegistry realizes Abstract Factory Pattern.
+            // It provides a family of objects related to a particular Import Context.
+            // Those include ImportContext specializations for different stages of the Import pipeline
+            // as well as Scene and Node wrappers.
+            // To add a new library for importing scene assets:
+            // - specialize and implement the ImportContextProvider
+            // - register specialization with this interface
+            class ImportContextRegistry
+            {
+            public:
+                AZ_RTTI(ImportContextRegistry, "{5faaaa8a-2497-41d7-8b5c-5af4390af776}");
+                AZ_CLASS_ALLOCATOR(ImportContextRegistry, AZ::SystemAllocator, 0);
+
+                virtual ~ImportContextRegistry() = default;
+
+                virtual void RegisterContextProvider(ImportContextProvider* provider) = 0;
+                virtual void UnregisterContextProvider(ImportContextProvider* provider) = 0;
+                virtual ImportContextProvider* SelectImportProvider(AZStd::string_view fileExtension) const = 0;
+            };
+
+            using ImportContextRegistryInterface = AZ::Interface<ImportContextRegistry>;
+        } // namespace SceneBuilder
+    } // namespace SceneAPI
+} // namespace AZ

Code/Tools/SceneAPI/SceneBuilder/ImportContextRegistryManager.cpp

@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#include "ImportContextRegistryManager.h"
+
+namespace AZ
+{
+    namespace SceneAPI
+    {
+        namespace SceneBuilder
+        {
+            ImportContextRegistryManager::ImportContextRegistryManager()
+            {
+                // register AssImp default provider
+                auto assimpContextProvider = aznew AssImpImportContextProvider();
+                m_importContextProviders.push_back(AZStd::unique_ptr<ImportContextProvider>(assimpContextProvider));
+            };
+
+            void ImportContextRegistryManager::RegisterContextProvider(ImportContextProvider* provider)
+            {
+                if (provider)
+                {
+                    m_importContextProviders.push_back(AZStd::unique_ptr<ImportContextProvider>(provider));
+                }
+            }
+
+            void ImportContextRegistryManager::UnregisterContextProvider(ImportContextProvider* provider)
+            {
+                AZ_TracePrintf("SceneAPI", "Unregistered ImportContextProvider %s", provider->GetImporterName().data());
+                for (auto it = m_importContextProviders.begin(); it != m_importContextProviders.end(); ++it)
+                {
+                    if (it->get() == provider)
+                    {
+                        m_importContextProviders.erase(it);
+                        break; // Assuming only one instance can be registered at a time
+                    }
+                }
+            }
+
+            ImportContextProvider* ImportContextRegistryManager::SelectImportProvider(AZStd::string_view fileExtension) const
+            {
+                AZ_TracePrintf(
+                    "SceneAPI",
+                    "Finding ImportContextProvider (registered %d) suitable for extension: %.*s",
+                    m_importContextProviders.size(),
+                    static_cast<int>(fileExtension.length()),
+                    fileExtension.data());
+                // search in reverse order since the default AssImp Provider can handle all extenstions
+                for (auto it = m_importContextProviders.rbegin(); it != m_importContextProviders.rend(); ++it)
+                {
+                    if (it->get()->CanHandleExtension(fileExtension))
+                    {
+                        return it->get();
+                    }
+                    else
+                    {
+                        AZ_TracePrintf(
+                            "SceneAPI",
+                            "Importer %s cannot handle %.*s",
+                            it->get()->GetImporterName().data(),
+                            static_cast<int>(fileExtension.length()),
+                            fileExtension.data());
+                    }
+                }
+                return nullptr; // No provider found
+            }
+
+        } // namespace SceneBuilder
+    } // namespace SceneAPI
+} // namespace AZ

Code/Tools/SceneAPI/SceneBuilder/ImportContextRegistryManager.h

@@ -0,0 +1,43 @@
+/*
+* Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+#include <SceneAPI/SceneBuilder/ImportContextRegistry.h>
+#include <AzCore/Debug/Trace.h>
+#include <AzCore/std/containers/vector.h>
+#include <SceneAPI/SceneBuilder/ImportContexts/ImportContextProvider.h>
+
+namespace AZ
+{
+    namespace SceneAPI
+    {
+        namespace SceneBuilder
+        {
+            // Implementation of the ImportContextRegistryInterface.
+            class ImportContextRegistryManager : public ImportContextRegistryInterface::Registrar
+            {
+            public:
+                AZ_RTTI(ImportContextRegistryManager, "{d3107473-4f99-4421-b4a8-ece66a922191}", ImportContextRegistry);
+                AZ_CLASS_ALLOCATOR(ImportContextRegistryManager, AZ::SystemAllocator, 0);
+
+                ImportContextRegistryManager();
+                ImportContextRegistryManager(const ImportContextRegistryManager&) = delete;
+                ImportContextRegistryManager& operator=(const ImportContextRegistryManager&) = delete;
+
+                ~ImportContextRegistryManager() override = default;
+
+                void RegisterContextProvider(ImportContextProvider* provider) override;
+                void UnregisterContextProvider(ImportContextProvider* provider) override;
+                ImportContextProvider* SelectImportProvider(AZStd::string_view fileExtension) const override;
+
+            private:
+                AZStd::vector<AZStd::unique_ptr<ImportContextProvider>> m_importContextProviders;
+            };
+        } // namespace SceneBuilder
+    } // namespace SceneAPI
+} // namespace AZ

Code/Tools/SceneAPI/SceneBuilder/ImportContexts/AssImpImportContextProvider.cpp

@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#include "AssImpImportContextProvider.h"
+#include <SceneAPI/SceneBuilder/ImportContexts/AssImpImportContexts.h>
+
+namespace AZ
+{
+    namespace SceneAPI
+    {
+        namespace SceneBuilder
+        {
+            AZStd::shared_ptr<NodeEncounteredContextBase> AssImpImportContextProvider::CreateNodeEncounteredContext(
+                Containers::Scene& scene,
+                Containers::SceneGraph::NodeIndex currentGraphPosition,
+                const SceneSystem& sourceSceneSystem,
+                RenamedNodesMap& nodeNameMap,
+                SDKScene::SceneWrapperBase& sourceScene,
+                SDKNode::NodeWrapper& sourceNode)
+            {
+                // need to cast NodeWrapper
+                auto assImpNode = azrtti_cast<AZ::AssImpSDKWrapper::AssImpNodeWrapper*>(&sourceNode);
+                auto assImpScene = azrtti_cast<AZ::AssImpSDKWrapper::AssImpSceneWrapper*>(&sourceScene);
+
+                if (!assImpNode)
+                {
+                    // Handle error: parent is not of the expected type
+                    AZ_Error("SceneBuilder", false, "Incorrect node type. Cannot create NodeEncounteredContext");
+                    return nullptr;
+                }
+                if (!assImpScene)
+                {
+                    AZ_Error("SceneBuilder", false, "Incorrect scene type. Cannot create NodeEncounteredContext");
+                    return nullptr;
+                }
+                return AZStd::make_shared<AssImpNodeEncounteredContext>(
+                    scene, currentGraphPosition, *assImpScene, sourceSceneSystem, nodeNameMap, *assImpNode);
+            }
+
+            AZStd::shared_ptr<SceneDataPopulatedContextBase> AssImpImportContextProvider::CreateSceneDataPopulatedContext(
+                NodeEncounteredContextBase& parent, AZStd::shared_ptr<DataTypes::IGraphObject> graphData, const AZStd::string& dataName)
+            {
+                // Downcast the parent to the AssImp-specific type to access AssImpImportContext members
+                AssImpNodeEncounteredContext* assImpParent = azrtti_cast<AssImpNodeEncounteredContext*>(&parent);
+                if (!assImpParent)
+                {
+                    AZ_Error("SceneBuilder", false, "Incorrect type of parent. Cannot create SceneDataPopulatedContext");
+                    return nullptr;
+                }
+
+                return AZStd::make_shared<AssImpSceneDataPopulatedContext>(*assImpParent, AZStd::move(graphData), dataName);
+            }
+
+            AZStd::shared_ptr<SceneNodeAppendedContextBase> AssImpImportContextProvider::CreateSceneNodeAppendedContext(
+                SceneDataPopulatedContextBase& parent, Containers::SceneGraph::NodeIndex newIndex)
+            {
+                // Downcast the parent to the AssImp-specific type
+                AssImpSceneDataPopulatedContext* assImpParent = azrtti_cast<AssImpSceneDataPopulatedContext*>(&parent);
+                if (!assImpParent)
+                {
+                    AZ_Error("SceneBuilder", false, "Incorrect type of parent. Cannot create SceneNodeAppendedContext");
+                    return nullptr;
+                }
+
+                return AZStd::make_shared<AssImpSceneNodeAppendedContext>(*assImpParent, newIndex);
+            }
+
+            AZStd::shared_ptr<SceneAttributeDataPopulatedContextBase> AssImpImportContextProvider::CreateSceneAttributeDataPopulatedContext(
+                SceneNodeAppendedContextBase& parent,
+                AZStd::shared_ptr<DataTypes::IGraphObject> nodeData,
+                const Containers::SceneGraph::NodeIndex attributeNodeIndex,
+                const AZStd::string& dataName)
+            {
+                // Downcast the parent to the AssImp-specific type
+                AssImpSceneNodeAppendedContext* assImpParent = azrtti_cast<AssImpSceneNodeAppendedContext*>(&parent);
+                if (!assImpParent)
+                {
+                    AZ_Error("SceneBuilder", false, "Incorrect type of parent. Cannot create SceneAttributeDataPopulatedContext");
+                    return nullptr;
+                }
+                return AZStd::make_shared<AssImpSceneAttributeDataPopulatedContext>(
+                    *assImpParent, AZStd::move(nodeData), attributeNodeIndex, dataName);
+            }
+
+            AZStd::shared_ptr<SceneAttributeNodeAppendedContextBase> AssImpImportContextProvider::CreateSceneAttributeNodeAppendedContext(
+                SceneAttributeDataPopulatedContextBase& parent, Containers::SceneGraph::NodeIndex newIndex)
+            {
+                // Downcast the parent to the AssImp-specific type
+                AssImpSceneAttributeDataPopulatedContext* assImpParent = azrtti_cast<AssImpSceneAttributeDataPopulatedContext*>(&parent);
+                if (!assImpParent)
+                {
+                    AZ_Error("SceneBuilder", false, "Incorrect type of parent. Cannot create SceneAttributeNodeAppendedContext");
+                    return nullptr;
+                }
+                return AZStd::make_shared<AssImpSceneAttributeNodeAppendedContext>(*assImpParent, newIndex);
+            }
+
+            AZStd::shared_ptr<SceneNodeAddedAttributesContextBase> AssImpImportContextProvider::CreateSceneNodeAddedAttributesContext(
+                SceneNodeAppendedContextBase& parent)
+            {
+                // Downcast the parent to the AssImp-specific type
+                AssImpSceneNodeAppendedContext* assImpParent = azrtti_cast<AssImpSceneNodeAppendedContext*>(&parent);
+                if (!assImpParent)
+                {
+                    AZ_Error("SceneBuilder", false, "Incorrect type of parent. Cannot create SceneNodeAddedAttributesContext");
+                    return nullptr;
+                }
+                return AZStd::make_shared<AssImpSceneNodeAddedAttributesContext>(*assImpParent);
+            }
+
+            AZStd::shared_ptr<SceneNodeFinalizeContextBase> AssImpImportContextProvider::CreateSceneNodeFinalizeContext(
+                SceneNodeAddedAttributesContextBase& parent)
+            {
+                // Downcast the parent to the AssImp-specific type
+                AssImpSceneNodeAddedAttributesContext* assImpParent = azrtti_cast<AssImpSceneNodeAddedAttributesContext*>(&parent);
+                if (!assImpParent)
+                {
+                    AZ_Error("SceneBuilder", false, "Incorrect type of parent. Cannot create SceneNodeFinalizeContext");
+                    return nullptr;
+                }
+                return AZStd::make_shared<AssImpSceneNodeFinalizeContext>(*assImpParent);
+            }
+
+            AZStd::shared_ptr<FinalizeSceneContextBase> AssImpImportContextProvider::CreateFinalizeSceneContext(
+                Containers::Scene& scene,
+                const SceneSystem& sourceSceneSystem,
+                SDKScene::SceneWrapperBase& sourceScene,
+                RenamedNodesMap& nodeNameMap)
+            {
+                AssImpSDKWrapper::AssImpSceneWrapper* assImpScene = azrtti_cast<AssImpSDKWrapper::AssImpSceneWrapper*>(&sourceScene);
+                if (!assImpScene)
+                {
+                    AZ_Error("SceneBuilder", false, "Incorrect scene type. Cannot create FinalizeSceneContext");
+                    return nullptr;
+                }
+                return AZStd::make_shared<AssImpFinalizeSceneContext>(scene, *assImpScene, sourceSceneSystem, nodeNameMap);
+            }
+        } // namespace SceneBuilder
+    } // namespace SceneAPI
+} // namespace AZ