SceneManager.h

Go to the documentation of this file.

//
// SceneManager.h
//
 
#ifndef SCENEMANAGER_H
#define SCENEMANAGER_H
 
#pragma once
 
#include <Malena/Core/Core.h>
#include <Malena/Utilities/EnumClassHash.h>
#include <unordered_map>
#include <functional>
#include <vector>
#include <memory>
#include <type_traits>
 
namespace ml
{
    template<typename StateEnum>
    class SceneManager
    {
        // ── Internal scene entry ────────────────────────────────────────────

        struct SceneEntry
        {
            Core*                    scene;    
            std::function<Core*()>   factory;  
            std::unique_ptr<Core>    owned;    
 
            bool isLazy()   const { return static_cast<bool>(factory); }
            bool isActive() const { return scene != nullptr; }

            Core* get() const { return scene; }
        };
 
        // ── Static storage ──────────────────────────────────────────────────
 
        inline static std::unordered_map<StateEnum, SceneEntry, EnumClassHash> _bindings;
        inline static std::vector<StateEnum>        _history;
        inline static StateEnum                     _current{};
        inline static bool                          _started  = false;
        inline static bool                          _attached = false;

        inline static std::function<void(Core&)>       _add;

        inline static std::function<void(Core&)>       _remove;

        inline static std::function<void(StateEnum)>   _setter;
 
    public:
 
        // ── Bind ────────────────────────────────────────────────────────────

        static void bind(StateEnum state, Core& scene)
        {
            _bindings[state] = SceneEntry{ &scene, nullptr, nullptr };
        }

        template<typename SceneType, typename... Args>
        static void bindLazy(StateEnum state, Args&&... args)
        {
            static_assert(std::is_base_of_v<Core, SceneType>,
                "[SceneManager] bindLazy: SceneType must derive from ml::Core.");
 
            // Capture args by value so the factory is self-contained
            _bindings[state] = SceneEntry
            {
                nullptr,
                [capturedArgs = std::make_tuple(std::forward<Args>(args)...)]() mutable -> Core*
                {
                    return std::apply([](auto&&... a) -> Core*
                    {
                        return new SceneType(std::forward<decltype(a)>(a)...);
                    }, capturedArgs);
                },
                nullptr
            };
        }
 
        // ── Attach ──────────────────────────────────────────────────────────

        template<typename App>
        static void attach(App& app)
        {
            _attached = true;
 
            // Store navigation primitives
            _setter = [&app](StateEnum s) { app.setState(s); };
            _add    = [&app](Core& s)     { app.addComponent(s); };
 
            // removeComponent lives on CoreManager — call through app if available,
            // otherwise fall back to CoreManager<Core> directly
            _remove = [&app](Core& s)
            {
                if constexpr (requires { app.removeComponent(s); })
                    app.removeComponent(s);
                else
                    CoreManager<Core>::removeComponent(s);
            };
 
            // Hook into the app's state machine — SceneManager reacts to transitions
            app.onStateExit([](StateEnum leaving)
            {
                SceneManager::deactivate(leaving);
            });
 
            app.onStateEnter([](StateEnum entering)
            {
                SceneManager::activate(entering);
            });
        }
 
        // ── Start ───────────────────────────────────────────────────────────

        static void start(StateEnum state)
        {
            _current = state;
            _started = true;
            activate(state);  // show first scene — no history push
        }
 
        // ── Navigation ──────────────────────────────────────────────────────

        static void back()
        {
            if (_history.empty()) return;
 
            StateEnum previous = _history.back();
            _history.pop_back();
 
            // Call setState without re-pushing to history
            // We set _current ahead of time so activate() knows not to push
            _current = previous;
 
            if (_setter)
                _setter(previous);
        }
 
        // ── Query ───────────────────────────────────────────────────────────

        static StateEnum current() { return _current; }

        static bool isActive(StateEnum state) { return _started && _current == state; }

        static bool has(StateEnum state) { return _bindings.count(state) > 0; }

        static void clear()
        {
            _bindings.clear();
            _history.clear();
            _started  = false;
            _attached = false;
            _add    = nullptr;
            _remove = nullptr;
            _setter = nullptr;
        }
 
    private:
 
        // ── Internal transition helpers ─────────────────────────────────────

        static void activate(StateEnum state)
        {
            auto it = _bindings.find(state);
            if (it == _bindings.end()) return;
 
            SceneEntry& entry = it->second;
 
            if (entry.isLazy())
            {
                // Construct on demand if not already alive
                if (!entry.owned)
                {
                    entry.owned.reset(entry.factory());
                    entry.scene = entry.owned.get();
                }
            }
 
            if (entry.scene && _add)
                _add(*entry.scene);
        }

        static void deactivate(StateEnum state)
        {
            auto it = _bindings.find(state);
            if (it == _bindings.end()) return;
 
            SceneEntry& entry = it->second;
 
            if (entry.scene && _remove)
                _remove(*entry.scene);
 
            // Push to history so back() can return
            _history.push_back(state);
            _current = state; // will be overwritten by activate() shortly
 
            if (entry.isLazy())
            {
                // Free the lazy instance — next visit will reconstruct
                entry.scene = nullptr;
                entry.owned.reset();
            }
        }
    };
 
} // namespace ml
 
#endif // SCENEMANAGER_H