SceneHandle.hpp

Go to the documentation of this file.

#pragma once
#include "Scene.hpp"
 
namespace Cori {
    namespace Core {
        class Layer;
    }
 
    namespace World {
        class SceneHandle {
        public:
            SceneHandle(const std::shared_ptr<Scene>& scene) : m_SceneRaw(scene) {} //NOLINT

            [[nodiscard]] Entity CreateBlankEntity() {
                CORI_CORE_ASSERT(!m_SceneRaw.expired(), "No scene is currently bound.");
                return m_SceneRaw.lock()->CreateBlankEntity();
            }

            template<typename... T>
            [[nodiscard]] Entity CreateEntity(const std::string& name) {
                CORI_CORE_ASSERT(!m_SceneRaw.expired(), "No scene is currently bound.");
                return m_SceneRaw.lock()->CreateEntity<T...>(name);
            }

            void DestroyEntity(Entity entity) {
                CORI_CORE_ASSERT(!m_SceneRaw.expired(), "No scene is currently bound.");
                m_SceneRaw.lock()->DestroyEntity(entity);
            }

            std::expected<void, Core::CoriError<>> AddEntityToCache(Entity entity, const Utility::StringHash32 key) {
                CORI_CORE_ASSERT(!m_SceneRaw.expired(), "No scene is currently bound.");
                return m_SceneRaw.lock()->AddEntityToCache(entity, key);
            }

            [[nodiscard]] std::expected<Entity, Core::CoriError<>> GetEntityFromCache(const Utility::StringHash32 key) {
                CORI_CORE_ASSERT(!m_SceneRaw.expired(), "No scene is currently bound.");
                return m_SceneRaw.lock()->GetEntityFromCache(key);
            }

            void RemoveEntityFromCache(const Utility::StringHash32 key) {
                CORI_CORE_ASSERT(!m_SceneRaw.expired(), "No scene is currently bound.");
                m_SceneRaw.lock()->RemoveEntityFromCache(key);
            }

            template<typename... T>
            [[nodiscard]] std::expected<Entity, Core::CoriError<>> FindEntity(const std::string& name) {
                CORI_CORE_ASSERT(!m_SceneRaw.expired(), "No scene is currently bound.");
                return m_SceneRaw.lock()->FindEntity<T...>(name);
            }

            template<typename... T>
            [[nodiscard]] auto StaticView() {
                CORI_CORE_ASSERT(!m_SceneRaw.expired(), "No scene is currently bound.");
                return m_SceneRaw.lock()->StaticView<T...>();
            }

            template<typename... T, typename... ExcludeT>
            [[nodiscard]] auto StaticView(Exclude<ExcludeT...> excludeList) {
                CORI_CORE_ASSERT(!m_SceneRaw.expired(), "No scene is currently bound.");
                return m_SceneRaw.lock()->StaticView<T...>(excludeList);
            }

            [[nodiscard]] DynamicEntityView DynamicView() {
                CORI_CORE_ASSERT(!m_SceneRaw.expired(), "No scene is currently bound.");
                return m_SceneRaw.lock()->DynamicView();
            }
 
            //template<typename... T, typename Func>
            //void ForEach(Func func) {
            //  CORI_CORE_ASSERT(!m_SceneRaw.expired(), "No scene is currently bound.");
            //  m_SceneRaw.lock()->ForEach<T...>(func);
            //}

            template<typename T, typename... Args>
            T& AddContextComponent(Args&&... args) {
                CORI_CORE_ASSERT(!m_SceneRaw.expired(), "No scene is currently bound.");
                return m_SceneRaw.lock()->AddContextComponent<T>(std::forward<Args>(args)...);
            }

            template<typename T>
            [[nodiscard]] T& GetContextComponent() {
                CORI_CORE_ASSERT(!m_SceneRaw.expired(), "No scene is currently bound.");
                return m_SceneRaw.lock()->GetContextComponent<T>();
            }

            template<typename T>
            [[nodiscard]] const T& GetContextComponent() const {
                CORI_CORE_ASSERT(!m_SceneRaw.expired(), "No scene is currently bound.");
                return m_SceneRaw.lock()->GetContextComponent<T>();
            }

            template<typename T>
            [[nodiscard]] bool HasContextComponent() const {
                CORI_CORE_ASSERT(!m_SceneRaw.expired(), "No scene is currently bound.");
                return m_SceneRaw.lock()->HasContextComponent<T>();
            }

            template<typename T>
            void RemoveContextComponent() {
                CORI_CORE_ASSERT(!m_SceneRaw.expired(), "No scene is currently bound.");
                m_SceneRaw.lock()->RemoveContextComponent<T>();
            }

            template <typename T, typename... Args> requires IsSystem<T>
            void RegisterSystem(Args&&... args) {
                CORI_CORE_ASSERT(!m_SceneRaw.expired(), "No scene is currently bound.");
                m_SceneRaw.lock()->RegisterSystem<T>(std::forward<Args>(args)...);
            }

            template <typename T> requires IsSystem<T>
            void UnregisterSystem() {
                CORI_CORE_ASSERT(!m_SceneRaw.expired(), "No scene is currently bound.");
                m_SceneRaw.lock()->UnregisterSystem<T>();
            }

            template <typename T> requires IsSystem<T>
            [[nodiscard]] std::expected<std::weak_ptr<T>, Core::CoriError<>> GetSystem() {
                CORI_CORE_ASSERT(!m_SceneRaw.expired(), "No scene is currently bound.");
                return m_SceneRaw.lock()->GetSystem<T>();
            }

            [[nodiscard]] Graphics::CameraController& GetActiveCamera() {
                CORI_CORE_ASSERT(!m_SceneRaw.expired(), "No scene is currently bound.");
                return m_SceneRaw.lock()->GetCameraController();
            }

            [[nodiscard]] const Graphics::CameraController& GetActiveCamera() const {
                CORI_CORE_ASSERT(!m_SceneRaw.expired(), "No scene is currently bound.");
                return m_SceneRaw.lock()->GetCameraController();
            }

            [[nodiscard]] std::string_view GetName() const {
                CORI_CORE_ASSERT(!m_SceneRaw.expired(), "No scene is currently bound.");
                return m_SceneRaw.lock()->GetName();
            }

            [[nodiscard]] entt::registry& GetRegistry() {
                CORI_CORE_ASSERT(!m_SceneRaw.expired(), "No scene is currently bound.");
                return m_SceneRaw.lock()->m_Registry;
            }

            [[nodiscard]] bool IsValid() const {
                return !m_SceneRaw.expired();
            }
 
        protected:
            friend Core::Layer;
            friend Core::Application;
 
            void BeginRender() {
                if (!m_SceneRaw.expired()) {
                    m_SceneRaw.lock()->BeginRender();
                }
            }
 
            void EndRender() {
                if (!m_SceneRaw.expired()) {
                    m_SceneRaw.lock()->EndRender();
                }
            }
 
            void OnUpdate(Core::GameTimer& gameTimer) {
                if (!m_SceneRaw.expired()) {
                    m_SceneRaw.lock()->OnUpdate(gameTimer);
                }
            }
 
            void OnTickUpdate(Core::GameTimer& gameTimer) {
                if (!m_SceneRaw.expired()) {
                    m_SceneRaw.lock()->OnTickUpdate(gameTimer);
                }
            }
 
            void OnImGuiRender(Core::GameTimer& gameTimer) {
                if (!m_SceneRaw.expired()) {
                    m_SceneRaw.lock()->OnImGuiRender(gameTimer);
                }
            }
 
            [[nodiscard]] bool OnUnbind() {
                if (!m_SceneRaw.expired()) {
                    return m_SceneRaw.lock()->OnUnbind();
                }
                return false;
            }
 
            [[nodiscard]] bool OnBind() {
                if (!m_SceneRaw.expired()) {
                    return m_SceneRaw.lock()->OnBind();
                }
                return false;
            }
 
        private:
            std::weak_ptr<Scene> m_SceneRaw;
        };
    }
}