SceneManager.h

#pragma once
#include "../Component/MeshComponent.h"
#include "Engine/Core/Settings.h"
#include "Engine/Entity/Scene.h"
 
#include <functional>
#include <memory>
#include <utility>
#include <vector>
using scene_object_id = uint32_t;
 
namespace Vulkan
{
    class Buffer;
}
 
namespace Engine::Core
{
    class AssetManager;
    class ApplicationContext;

    class SceneManager
    {
    public:
        explicit SceneManager( ApplicationContext * context );

        ~SceneManager();

        std::vector<Entities::Actor *> getAllActors();
        std::vector<Entities::Entity *> getAllEntities();

        template<typename Func>
        void forEachActor(Func&& func) const;

        template <typename T>
        std::vector<T *> getAllComponentsOfClassFromActors();

        Components::Mesh * registerGameObject( Components::Mesh * gameObject );
        void unregisterGameObject( const Components::Mesh * gameObject );

        [[nodiscard]] uint32_t getGameObjectCount() const
        {
            return gameObjects.size();
        }

        [[nodiscard]] const std::vector<Components::Mesh *> & getGameObjects() const;

        [[nodiscard]] const Components::Mesh *                getGameObject( const scene_object_id id ) const;

        void cleanup();

        void uploadGameObjectToMeshletMap();

        void destroyMeshletToObjectMapBuffer();

        template <typename T>
        void loadScene();

        void loadScene( std::function<Entities::Scene *()> createScene );

        [[nodiscard]] bool isSceneChangePending() const;

        void executePendingSceneLoading();

        void unloadScene();

        void clear();

        [[nodiscard]] Entities::Scene * getActiveScene() const { return activeScene; }

        [[nodiscard]] Entities::SceneLightingSettings getEffectiveLightingSettings() const;

        void setActiveScene( Entities::Scene * scene);

        void setAssetManager(AssetManager* manager);
 
    private:
        AssetManager* assetManager_ = nullptr;
        std::vector<Components::Mesh *> gameObjects = {};
 
        std::vector<uint32_t> gameObjectToMeshletMap{};
 
        std::unique_ptr<Vulkan::Buffer> meshletToObjectMapBuffer;
 
        void createMeshletToObjectMapBuffer( ApplicationContext * context );
 
        ApplicationContext * context = nullptr;
 
        Entities::Scene * activeScene = nullptr;
        std::function<void()> pendingSceneLoad;
 
        void loadSceneContent() const;
    };
 
    template <typename T>
    std::vector<T *> SceneManager::getAllComponentsOfClassFromActors()
    {
        if (!activeScene) return {};
        std::vector<T*> outComponents;
        for ( const auto entity : activeScene->getEntities()) {
            if ( const auto actor = dynamic_cast<Entities::Actor*>(entity)) {
                if (actor->hasComponent<T>())
                {
                    std::vector<T*> components = actor->getComponents<T>();
                    outComponents.insert(outComponents.end(), components.begin(), components.end());
                }
            }
        }
        return outComponents;
 
    }
 
    template<typename Func>
    void SceneManager::forEachActor(Func&& func) const
    {
        if (!activeScene) return;
        activeScene->forEachEntity([&func](Entities::Entity* entity) {
            if (auto* actor = dynamic_cast<Entities::Actor*>(entity)) {
                func(actor);
            }
        });
    }
 
    template <typename T>
    void SceneManager::loadScene() {
        pendingSceneLoad = [this]() {
            activeScene = new T();
            // Inject AssetManager into the scene if available
            if (assetManager_ != nullptr) {
                activeScene->setAssetManager(assetManager_);
            }
            loadSceneContent();
        };
    }
 
    inline void SceneManager::loadScene( std::function<Entities::Scene *()> createScene )
    {
        pendingSceneLoad = [this, createScene = std::move( createScene )]() {
            activeScene = createScene ? createScene() : nullptr;
            if ( activeScene != nullptr && assetManager_ != nullptr )
            {
                activeScene->setAssetManager( assetManager_ );
            }
            loadSceneContent();
        };
    }
}  // namespace EngineCore