SceneManager.cpp

Go to the documentation of this file.

#include "Engine/World/SceneManager.h"
 
#include "../../../include/Engine/Component/MeshComponent.h"
#include "Engine/Core/Engine.h"
#include "Engine/Core/Tick.h"
#include "Engine/Entity/Actor.h"
#include "Engine/Entity/Scene.h"
#include "Engine/Logging/TracyMacros.hpp"
#include "Engine/Mesh/Mesh.h"
#include "plog/Log.h"
 
namespace EngineCore {
    SceneManager::SceneManager(ApplicationContext *context) : context(context) {
        createMeshletToObjectMapBuffer(this->context);
    }
 
    SceneManager::~SceneManager() {
    }
 
    std::vector<Actor *> SceneManager::getAllActors()
    {
        TRACY_ZONE_SCOPED_NAMED("Get all actors");
        if (!activeScene) return {};
        std::vector<Actor*> actors;
        for (auto entity : activeScene->getEntities()) {
            if (auto actor = dynamic_cast<Actor*>(entity)) {
                actors.push_back(actor);
            }
        }
        return actors;
    }
 
    std::vector<Entity *> SceneManager::getAllEntities()
    {
        if (!activeScene) return {};
        return activeScene->getEntities();
    }
 
    MeshComponent * SceneManager::registerGameObject(MeshComponent* gameObject)
    {
        gameObjects.push_back(gameObject);
        return gameObject;
    }
 
    void SceneManager::unregisterGameObject(const MeshComponent* gameObject)
    {
        if (gameObject == nullptr) {
            PLOGW << "Attempted to unregister a null GameObject pointer.";
            return;
        }
 
        if (const auto it = std::ranges::find(gameObjects, gameObject); it != gameObjects.end()) {
            gameObjects.erase(it);
        } else {
            PLOGW << "GameObject pointer not found in gameObjects vector during unregistration.";
        }
    }
 
    const std::vector<MeshComponent *> & SceneManager::getGameObjects() const {
        return gameObjects;
    }
 
    const MeshComponent * SceneManager::getGameObject(const scene_object_id id) const {
        if (id < gameObjects.size()) {
            return gameObjects[id];
        }
        return nullptr;
    }
 
    const VulkanBuffer & SceneManager::getMeshletToObjectBuffer() const {
        return meshletToObjectMapBuffer.value();
    }
 
    void SceneManager::cleanup()
    {
        unloadScene();
        destroyMeshletToObjectMapBuffer();
    }
 
    bool SceneManager::isSceneChangePending() const {
        return pendingSceneLoad != nullptr;
    }
 
    void SceneManager::executePendingSceneLoading() {
        TRACY_ZONE_SCOPED_NAMED("Scene loading");
        if (activeScene != nullptr) {
            unloadScene();
        }
        pendingSceneLoad();
        pendingSceneLoad = nullptr;
    }
 
    void SceneManager::unloadScene() {
        TRACY_ZONE_SCOPED_NAMED("Unload scene");
        if (activeScene) {
            activeScene->unloadContent();
            activeScene->cleanup();
            delete activeScene;
            activeScene = nullptr;
        }
        clear();
    }
 
    void SceneManager::clear() {
        gameObjects.clear();
        gameObjectToMeshletMap.clear();
    }
 
    void SceneManager::setActiveScene(Scene* scene) {
        if (activeScene) {
            unloadScene();
        }
        activeScene = scene;
        if (activeScene) {
            // Inject AssetManager into the scene if available
            if (assetManager_ != nullptr) {
                activeScene->setAssetManager(assetManager_);
            }
            loadSceneContent();
        }
    }
 
    void SceneManager::setAssetManager(AssetManager* manager) {
        assetManager_ = manager;
    }
 
    void SceneManager::loadSceneContent() const {
        if (activeScene) {
            activeScene->loadContent();
        }
        else {
            PLOGE << "Failed to load scene content as the scene was nullptr";
        }
    }
 
    void SceneManager::uploadGameObjectToMeshletMap() {
        meshletToObjectMapBuffer->uploadData(gameObjectToMeshletMap.data(), gameObjectToMeshletMap.size());
    }
 
    void SceneManager::addMeshToMap(const MeshComponent *gameObject) {
        // Legacy - meshlet mapping now handled by RenderingDataManager
    }
 
    void SceneManager::addMeshesToMap(const std::vector<MeshComponent *> &gameObjects) {
        // Legacy - meshlet mapping now handled by RenderingDataManager
    }
 
    void SceneManager::rebuildMeshMap() {
        // Legacy - meshlet mapping now handled by RenderingDataManager
    }
 
    void SceneManager::createMeshletToObjectMapBuffer( ApplicationContext * context )
    {
        constexpr VkDeviceSize bufferSize = sizeof( uint32_t ) * MAX_MESHLETS_PER_BIN;
        meshletToObjectMapBuffer.emplace( context );
        meshletToObjectMapBuffer->create(
            bufferSize,
            VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT
        );
        meshletToObjectMapBuffer->setDebugName( "Meshlet To Object Map Buffer" );
    }
 
    void SceneManager::destroyMeshletToObjectMapBuffer()
    {
        if ( meshletToObjectMapBuffer.has_value() && meshletToObjectMapBuffer->isValid() )
        {
            meshletToObjectMapBuffer->destroy();
        }
        meshletToObjectMapBuffer->invalidate();
    }
}