SceneManager.h

Go to the documentation of this file.

#pragma once
#include "../Component/MeshComponent.h"
#include "Engine/Core/Settings.h"
#include "Engine/Entity/Scene.h"
#include "Engine/Renderer/VulkanBuffer.h"
 
#include <functional>
#include <vector>
using scene_object_id = uint32_t;
 
namespace EngineCore
{
    class Actor;
    class Entity;
    class ApplicationContext;
    class AssetManager;

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

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

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

        MeshComponent * registerGameObject( MeshComponent * gameObject );
        void unregisterGameObject( const MeshComponent * gameObject );

        [[nodiscard]] uint32_t getGameObjectCount() const
        {
            return gameObjects.size();
        }
 
        [[nodiscard]] const std::vector<MeshComponent *> & getGameObjects() const;
        [[nodiscard]] const MeshComponent *                getGameObject( const scene_object_id id ) const;
        [[nodiscard]] const VulkanBuffer &                 getMeshletToObjectBuffer() const;
 
        void cleanup();

        void uploadGameObjectToMeshletMap();
        void destroyMeshletToObjectMapBuffer();

        template <typename T>
        void loadScene();

        [[nodiscard]] bool isSceneChangePending() const;

        void executePendingSceneLoading();

        void unloadScene();

        void clear();
 
        [[nodiscard]] Scene* getActiveScene() const { return activeScene; }
        void setActiveScene(Scene* scene);

        void setAssetManager(AssetManager* manager);
 
    private:
        AssetManager* assetManager_ = nullptr;
        std::vector<MeshComponent *> gameObjects = {};
 
        std::vector<uint32_t> gameObjectToMeshletMap{};
 
        void addMeshToMap( const MeshComponent * gameObject );
        void addMeshesToMap( const std::vector<MeshComponent *> & gameObjects );
        void rebuildMeshMap();
 
        std::optional<VulkanBuffer> meshletToObjectMapBuffer{};
 
        void createMeshletToObjectMapBuffer( ApplicationContext * context );
 
        ApplicationContext * context = nullptr;
 
        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<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 T>
    void SceneManager::loadScene() {
        pendingSceneLoad = [this]() {
            activeScene = new T();
            // Inject AssetManager into the scene if available
            if (assetManager_ != nullptr) {
                activeScene->setAssetManager(assetManager_);
            }
            loadSceneContent();
        };
    }
}  // namespace EngineCore