Initial commit

Code/Framework/AzFramework/AzFramework/Scene/Scene.cpp

@@ -0,0 +1,26 @@
+/*
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
+
+#include <AzFramework/Scene/Scene.h>
+
+namespace AzFramework
+{
+    Scene::Scene(AZStd::string_view name)
+        : m_name(name)
+    {
+    }
+
+    const AZStd::string& Scene::GetName()
+    {
+        return m_name;
+    }
+}

Code/Framework/AzFramework/AzFramework/Scene/Scene.h

@@ -0,0 +1,94 @@
+/*
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
+#pragma once
+
+#include <AzCore/RTTI/RTTI.h>
+#include <AzCore/std/string/string.h>
+#include <AzCore/Memory/SystemAllocator.h>
+#include <AzCore/std/containers/vector.h>
+
+namespace AzFramework
+{
+    class Scene final
+    {
+    public:
+        AZ_TYPE_INFO(Scene, "{DB449BB3-7A95-434D-BC61-47ACBB1F3436}");
+        AZ_CLASS_ALLOCATOR(Scene, AZ::SystemAllocator, 0);
+
+        explicit Scene(AZStd::string_view name);
+
+        const AZStd::string& GetName();
+        
+        // Set the instance of a subsystem associated with this scene.
+        template <typename T>
+        bool SetSubsystem(T* system);
+
+        // Unset the instance of a subsystem associated with this scene.
+        template <typename T>
+        bool UnsetSubsystem();
+
+        // Get the instance of a subsystem associated with this scene.
+        template <typename T>
+        T* GetSubsystem();
+
+    private:
+
+        AZStd::string m_name;
+
+        // Storing keys separate from data to optimize for fast key search.
+        AZStd::vector<AZ::TypeId> m_systemKeys;
+        AZStd::vector<void*> m_systemPointers;
+    };
+    
+    template <typename T>
+    bool Scene::SetSubsystem(T* system)
+    {
+        if (GetSubsystem<T>() != nullptr)
+        {
+            return false;
+        }
+        m_systemKeys.push_back(T::RTTI_Type());
+        m_systemPointers.push_back(system);
+        return true;
+    }
+
+    template <typename T>
+    bool Scene::UnsetSubsystem()
+    {
+        for (size_t i = 0; i < m_systemKeys.size(); ++i)
+        {
+            if (m_systemKeys.at(i) == T::RTTI_Type())
+            {
+                m_systemKeys.at(i) = m_systemKeys.back();
+                m_systemKeys.pop_back();
+                m_systemPointers.at(i) = m_systemPointers.back();
+                m_systemPointers.pop_back();
+                return true;
+            }
+        }
+        return false;
+    }
+
+    template <typename T>
+    T* Scene::GetSubsystem()
+    {
+        for (size_t i = 0; i < m_systemKeys.size(); ++i)
+        {
+            if (m_systemKeys.at(i) == T::RTTI_Type())
+            {
+                return reinterpret_cast<T*>(m_systemPointers.at(i));
+            }
+        }
+        return nullptr;
+    }
+
+} // AzFramework

Code/Framework/AzFramework/AzFramework/Scene/SceneSystemBus.h

@@ -0,0 +1,114 @@
+/*
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
+#pragma once
+
+#include <AzCore/EBus/EBus.h>
+#include <AzFramework/Entity/EntityContext.h>
+
+namespace AzFramework
+{
+    // Forward declarations
+    class Scene;
+
+    //! Interface used to create, get, or destroy scenes.
+    class SceneSystemRequests
+        : public AZ::EBusTraits
+    {
+    public:
+
+        virtual ~SceneSystemRequests() = default;
+
+        //! Single handler policy since there should only be one instance of this system component.
+        static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
+
+        //! Creates a scene with a given name.
+        //!  - If there is already a scene with the provided name this will return AZ::Failure(). 
+        //!  - If isDefault is set to true and there is already a default scene, the default scene will be switched to this one. 
+        virtual AZ::Outcome<Scene*, AZStd::string> CreateScene(AZStd::string_view name) = 0;
+
+        //! Gets a scene with a given name
+        //!  - If a scene does not exist with the given name, nullptr is returned.
+        virtual Scene* GetScene(AZStd::string_view name) = 0;
+
+        //! Gets all the scenes that currently exist.
+        virtual AZStd::vector<Scene*> GetAllScenes() = 0;
+
+        //! Remove a scene with a given name and return if the operation was successful.
+        //!  - If the removed scene is the default scene, there will no longer be a default scene.
+        virtual bool RemoveScene(AZStd::string_view name) = 0;
+
+        //! Add a mapping from the provided EntityContextId to a Scene
+        //! - If a scene is already associated with this EntityContextId, nothing is changed and false is returned.
+        virtual bool SetSceneForEntityContextId(EntityContextId entityContextId, Scene* scene) = 0;
+
+        //! Remove a mapping from the provided EntityContextId to a Scene
+        //!  - If no scene is found from the provided EntityContextId, false is returned.
+        virtual bool RemoveSceneForEntityContextId(EntityContextId entityContextId, Scene* scene) = 0;
+
+        //! Get the scene associated with an EntityContextId
+        //!  - If no scene is found for the provided EntityContextId, nullptr is returned.
+        virtual Scene* GetSceneFromEntityContextId(EntityContextId entityContextId) = 0;
+    };
+
+    using SceneSystemRequestBus = AZ::EBus<SceneSystemRequests>;
+
+    //! Interface used for notifications from the scene system
+    class SceneSystemNotifications
+        : public AZ::EBusTraits
+    {
+    public:
+
+        virtual ~SceneSystemNotifications() = default;
+
+        //! There can be multiple listeners to changes in the scene system.
+        static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Multiple;
+
+        //! Called when a scene has been created.
+        virtual void SceneCreated(Scene& /*scene*/) {};
+
+        //! Called just before a scene is removed.
+        virtual void SceneAboutToBeRemoved(Scene& /*scene*/) {};
+
+    };
+
+    using SceneSystemNotificationBus = AZ::EBus<SceneSystemNotifications>;
+
+    //! Interface used for notifications about individual scenes
+    class SceneNotifications
+        : public AZ::EBusTraits
+    {
+    public:
+
+        virtual ~SceneNotifications() = default;
+
+        //! There can be multiple listeners to changes in the scene system.
+        static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Multiple;
+
+        //! Bus is listened to using the pointer of the scene
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+
+        //! Specifies that events are addressed by the pointer to the scene
+        using BusIdType = Scene*;
+
+        //! Called just before a scene is removed.
+        virtual void SceneAboutToBeRemoved() {};
+
+        //! Called when an entity context is mapped to this scene.
+        virtual void EntityContextMapped(EntityContextId /*entityContextId*/) {};
+
+        //! Called when an entity context is unmapped from this scene.
+        virtual void EntityContextUnmapped(EntityContextId /*entityContextId*/) {};
+    };
+
+    using SceneNotificationBus = AZ::EBus<SceneNotifications>;
+
+} // AzFramework

Code/Framework/AzFramework/AzFramework/Scene/SceneSystemComponent.cpp

@@ -0,0 +1,200 @@
+/*
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
+
+#include <AzFramework/Scene/SceneSystemComponent.h>
+
+#include <AzCore/Serialization/SerializeContext.h>
+#include <AzCore/Serialization/EditContext.h>
+#include <AzFramework/Scene/Scene.h>
+
+namespace AzFramework
+{
+    void SceneSystemComponent::Reflect(AZ::ReflectContext* context)
+    {
+        if (AZ::SerializeContext* serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
+        {
+            serializeContext->Class<SceneSystemComponent, AZ::Component>();
+
+            if (AZ::EditContext* editContext = serializeContext->GetEditContext())
+            {
+                editContext->Class<SceneSystemComponent>(
+                    "Scene System Component", "System component responsible for owning scenes")
+                    ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
+                    ->Attribute(AZ::Edit::Attributes::Category, "Editor")
+                    ->Attribute(AZ::Edit::Attributes::AppearsInAddComponentMenu, AZ_CRC("System", 0xc94d118b))
+                    ;
+            }
+        }
+    }
+
+    SceneSystemComponent::SceneSystemComponent() = default;
+    SceneSystemComponent::~SceneSystemComponent() = default;
+
+    void SceneSystemComponent::Activate()
+    {
+        // Connect busses
+        SceneSystemRequestBus::Handler::BusConnect();
+    }
+
+    void SceneSystemComponent::Deactivate()
+    {
+        // Disconnect Busses
+        SceneSystemRequestBus::Handler::BusDisconnect();
+    }
+
+    void SceneSystemComponent::GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided)
+    {
+        provided.push_back(AZ_CRC("SceneSystemComponentService", 0xd8975435));
+    }
+
+    void SceneSystemComponent::GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& incompatible)
+    {
+        incompatible.push_back(AZ_CRC("SceneSystemComponentService", 0xd8975435));
+    }
+
+    AZ::Outcome<Scene*, AZStd::string> SceneSystemComponent::CreateScene(AZStd::string_view name)
+    {
+        Scene* existingScene = GetScene(name);
+
+        if (existingScene)
+        {
+            return AZ::Failure<AZStd::string>("A scene already exists with this name.");
+        }
+
+        auto newScene = AZStd::make_unique<Scene>(name);
+        Scene* scenePointer = newScene.get();
+        m_scenes.push_back(AZStd::move(newScene));
+        SceneSystemNotificationBus::Broadcast(&SceneSystemNotificationBus::Events::SceneCreated, *scenePointer);
+        return AZ::Success(scenePointer);
+    }
+
+    Scene* SceneSystemComponent::GetScene(AZStd::string_view name)
+    {
+        auto sceneIterator = AZStd::find_if(m_scenes.begin(), m_scenes.end(),
+            [name](auto& scene) -> bool
+            {
+                return scene->GetName() == name;
+            }
+        );
+
+        return sceneIterator == m_scenes.end() ? nullptr : sceneIterator->get();
+    }
+
+    AZStd::vector<Scene*> SceneSystemComponent::GetAllScenes()
+    {
+        AZStd::vector<Scene*> scenes;
+        scenes.resize_no_construct(m_scenes.size());
+
+        for (size_t i = 0; i < m_scenes.size(); ++i)
+        {
+            scenes.at(i) = m_scenes.at(i).get();
+        }
+        return scenes;
+    }
+
+    bool SceneSystemComponent::RemoveScene(AZStd::string_view name)
+    {
+        for (size_t i = 0; i < m_scenes.size(); ++i)
+        {
+            auto& scenePtr = m_scenes.at(i);
+            if (scenePtr->GetName() == name)
+            {
+                // Remove any entityContext mappings.
+                Scene* scene = scenePtr.get();
+                for (auto entityContextScenePairIt = m_entityContextToScenes.begin(); entityContextScenePairIt != m_entityContextToScenes.end();)
+                {
+                    AZStd::pair<EntityContextId, Scene*>& pair = *entityContextScenePairIt;
+                    if (pair.second == scene)
+                    {
+                        // swap and pop back.
+                        *entityContextScenePairIt = m_entityContextToScenes.back();
+                        m_entityContextToScenes.pop_back();
+                    }
+                    else
+                    {
+                        ++entityContextScenePairIt;
+                    }
+                }
+
+                SceneSystemNotificationBus::Broadcast(&SceneSystemNotificationBus::Events::SceneAboutToBeRemoved, *scene);
+                SceneNotificationBus::Event(scene, &SceneNotificationBus::Events::SceneAboutToBeRemoved);
+
+                m_scenes.erase(&scenePtr);
+                return true;
+            }
+        }
+
+        AZ_Warning("SceneSystemComponent", false, "Attempting to remove scene name \"%.*s\", but that scene was not found.", static_cast<int>(name.size()), name.data());
+        return false;
+    }
+
+    bool SceneSystemComponent::SetSceneForEntityContextId(EntityContextId entityContextId, Scene* scene)
+    {
+        Scene* existingSceneForEntityContext = GetSceneFromEntityContextId(entityContextId);
+        if (existingSceneForEntityContext)
+        {
+            // This entity context is already mapped and must be unmapped explictely before it can be changed.
+            char entityContextIdString[EntityContextId::MaxStringBuffer];
+            entityContextId.ToString(entityContextIdString, sizeof(entityContextIdString));
+            AZ_Warning("SceneSystemComponent", false, "Failed to set a scene for entity context %s, scene is already set for that entity context.", entityContextIdString);
+
+            return false;
+        }
+        m_entityContextToScenes.emplace_back(entityContextId, scene);
+        SceneNotificationBus::Event(scene, &SceneNotificationBus::Events::EntityContextMapped, entityContextId);
+        return true;
+    }
+
+    bool SceneSystemComponent::RemoveSceneForEntityContextId(EntityContextId entityContextId, Scene* scene)
+    {
+        if (!scene || entityContextId.IsNull())
+        {
+            return false;
+        }
+
+        for (auto entityContextScenePairIt = m_entityContextToScenes.begin(); entityContextScenePairIt != m_entityContextToScenes.end();)
+        {
+            AZStd::pair<EntityContextId, Scene*>& pair = *entityContextScenePairIt;
+            if (!(pair.first == entityContextId && pair.second == scene))
+            {
+                ++entityContextScenePairIt;
+            }
+            else
+            {
+                // swap and pop back.
+                *entityContextScenePairIt = m_entityContextToScenes.back();
+                m_entityContextToScenes.pop_back();
+
+                SceneNotificationBus::Event(scene, &SceneNotificationBus::Events::EntityContextUnmapped, entityContextId);
+                return true;
+            }
+        }
+
+        char entityContextIdString[EntityContextId::MaxStringBuffer];
+        entityContextId.ToString(entityContextIdString, sizeof(entityContextIdString));
+        AZ_Warning("SceneSystemComponent", false, "Failed to remove scene \"%.*s\" for entity context %s, entity context is not currently mapped to that scene.", static_cast<int>(scene->GetName().size()), scene->GetName().data(), entityContextIdString);
+        return false;
+    }
+
+    Scene* SceneSystemComponent::GetSceneFromEntityContextId(EntityContextId entityContextId)
+    {
+        for (AZStd::pair<EntityContextId, Scene*>& pair : m_entityContextToScenes)
+        {
+            if (pair.first == entityContextId)
+            {
+                return pair.second;
+            }
+        }
+        return nullptr;
+    }
+
+} // AzFramework

Code/Framework/AzFramework/AzFramework/Scene/SceneSystemComponent.h

@@ -0,0 +1,64 @@
+/*
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
+#pragma once
+
+#include <AzCore/Component/Component.h>
+#include <AzCore/std/containers/map.h>
+#include <AzFramework/Scene/SceneSystemBus.h>
+#include <AzFramework/Entity/EntityContext.h>
+
+namespace AzFramework
+{
+    class SceneSystemComponent
+        : public AZ::Component
+        , public SceneSystemRequestBus::Handler
+    {
+    public:
+
+        AZ_COMPONENT(SceneSystemComponent, "{7AC53AF0-BE1A-437C-BE3E-4D6A998DA945}", AZ::Component);
+
+        SceneSystemComponent();
+        ~SceneSystemComponent() override;
+
+        //////////////////////////////////////////////////////////////////////////
+        // Component overrides
+        void Activate() override;
+        void Deactivate() override;
+        //////////////////////////////////////////////////////////////////////////
+
+        static void Reflect(AZ::ReflectContext* context);
+
+        static void GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided);
+        static void GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& incompatible);
+
+        //////////////////////////////////////////////////////////////////////////
+        // SceneSystemRequestsBus::Handler
+        //////////////////////////////////////////////////////////////////////////
+        AZ::Outcome<Scene*, AZStd::string> CreateScene(AZStd::string_view name) override;
+        Scene* GetScene(AZStd::string_view name) override;
+        AZStd::vector<Scene*> GetAllScenes() override;
+        bool RemoveScene(AZStd::string_view name) override;
+        bool SetSceneForEntityContextId(EntityContextId entityContextId, Scene* scene) override;
+        bool RemoveSceneForEntityContextId(EntityContextId entityContextId, Scene* scene) override;
+        Scene* GetSceneFromEntityContextId(EntityContextId entityContextId) override;
+
+    private:
+
+        AZ_DISABLE_COPY(SceneSystemComponent);
+
+        // Container of scene in order of creation
+        AZStd::vector<AZStd::unique_ptr<Scene>> m_scenes;
+
+        // Map of entity context Ids to scenes. Using a vector because lookups will be common, but the size will be small.
+        AZStd::vector<AZStd::pair<EntityContextId, Scene*>> m_entityContextToScenes;
+    };
+}