SceneManager.hpp

Go to the documentation of this file.

 
 
#ifndef GALAXY_STATE_SCENEMANAGER_HPP_
#define GALAXY_STATE_SCENEMANAGER_HPP_
 
#include <ankerl/unordered_dense.h>
 
#include "galaxy/math/FNV1a.hpp"
#include "galaxy/scene/Scene.hpp"
 
namespace galaxy
{
    namespace scene
    {
        class SceneManager final : public fs::Serializable
        {
            using Map             = ankerl::unordered_dense::map<std::uint64_t, std::unique_ptr<Scene>>;
            using SystemContainer = meta::vector<std::unique_ptr<systems::System>>;
 
          public:
            SceneManager();
 
            virtual ~SceneManager();
 
            [[maybe_unused]] Scene* add(const std::string& name);
 
            template<std::derived_from<Scene> Custom>
            [[maybe_unused]] Custom* add_custom(const std::string& name);
 
            [[nodiscard]] Scene* get(const std::string& name);
 
            void remove(const std::string& name);
 
            [[nodiscard]] bool has(const std::string& name);
 
            void set_scene(const std::string& name);
 
            template<meta::is_system System, typename... Args>
            void create_system(Args&&... args);
 
            void load_app(const std::string& appdata_file);
 
            void save_app(const std::string& file);
 
            void update();
 
            void only_update_rendering();
 
            void render();
 
            void clear();
 
            [[nodiscard]] scene::Scene* current() const;
 
            [[nodiscard]] const Map& map() const;
 
            [[nodiscard]] bool empty() const;
 
            [[nodiscard]] nlohmann::json serialize() override;
 
            void deserialize(const nlohmann::json& json) override;
 
          private:
            Map m_scenes;
 
            scene::Scene* m_current;
 
            SystemContainer m_systems;
 
            std::size_t m_rendersystem_index;
        };
 
        template<std::derived_from<Scene> Custom>
        inline Custom* SceneManager::add_custom(const std::string& name)
        {
            const auto hash = math::fnv1a_64(name.c_str());
 
            if (!m_scenes.contains(hash))
            {
                m_scenes[hash] = std::make_unique<Custom>(name);
            }
            else
            {
                GALAXY_LOG(GALAXY_WARNING, "Tried to add a duplicate scene '{0}'.", name);
            }
 
            return static_cast<Custom*>(m_scenes[hash].get());
        }
 
        template<meta::is_system System, typename... Args>
        inline void SceneManager::create_system(Args&&... args)
        {
            auto ptr = std::make_unique<System>(std::forward<Args>(args)...);
            m_systems.emplace_back(std::move(ptr));
 
            if constexpr (std::is_same<System, systems::RenderSystem>::value)
            {
                m_rendersystem_index = m_systems.size() - 1;
            }
        }
    } // namespace scene
} // namespace galaxy
 
#endif