AssetManager.cpp

Go to the documentation of this file.

#include "Engine/Mesh/AssetManager.h"
 
#include "Engine/Core/Optional.h"
#include "Engine/Core/VulkanHelper.h"
#include "Engine/Ecs/EcsData.h"
#include "Engine/Logging/FunctionNotImplemented.h"
#include "Engine/Logging/TracyMacros.hpp"
#include "Engine/Material/MaterialData.h"
#include "Engine/Mesh/GltfLoader.h"
#include "Engine/Mesh/GltfMeshLoader.h"
#include "Engine/Mesh/MeshAsset.h"
#include "Engine/Mesh/ModelAssetManager.h"
#include "Engine/Renderer/RenderingDataManager.h"
#include "Engine/Texture/ExrLoader.h"
 
#include <Engine/Core/Settings.h>
#include <Engine/Renderer/RenderData.h>
#include <Engine/Renderer/RenderProcess.h>
#include <plog/Log.h>
#include <ranges>
#include <type_traits>
 
namespace EngineCore {
    AssetManager::AssetManager() : textureAssetManager(new TextureAssetManager()), texturePipeline(textureAssetManager, threadPool),
                                   meshAssetManager(new MeshAssetManager()),
                                   materialAssetManager(new MaterialAssetManager()),
                                   modelAssetManager(new ModelAssetManager()),
                                   modelAssetPipeline(meshAssetManager, materialAssetManager, modelAssetManager, textureAssetManager, threadPool, this),
                                   textureIndexMap(),
                                   meshIndexMap(), textureAllocator(MAX_TEXTURE_COUNT), meshAllocator(MAX_MESH_COUNT) {
    }
 
    AssetManager::AssetManager(ApplicationContext *context) : textureAssetManager(new TextureAssetManager()),
                                                              texturePipeline(textureAssetManager, threadPool),
                                                              meshAssetManager(new MeshAssetManager()),
                                                              materialAssetManager(new MaterialAssetManager()),
                                                              modelAssetManager(new ModelAssetManager()),
                                                              modelAssetPipeline(meshAssetManager, materialAssetManager, modelAssetManager, textureAssetManager, threadPool, this),
                                                              context(context), textureAllocator(MAX_TEXTURE_COUNT),
                                                              meshAllocator(MAX_MESH_COUNT) {
    }
 
    AssetManager::~AssetManager() {
        delete textureAssetManager;
        delete meshAssetManager;
        delete materialAssetManager;
        delete modelAssetManager;
        delete threadPool;
        delete threadedCalculation;
    }
 
    void AssetManager::attachToRenderer(Renderer *renderer) {
        this->renderer = renderer;
    }
 
    void AssetManager::setRenderingDataManager(RenderingDataManager *renderingDataManager) {
        texturePipeline.setRenderingDataManager(renderingDataManager);
        modelAssetPipeline.setRenderingDataManager(renderingDataManager);
    }
 
    void AssetManager::loadEcsModel(const std::filesystem::path &path) {
        TRACY_ZONE_SCOPED_NAMED("Loading Ecs mesh");
 
        if (!modelAssetManager->exists(path))
        {
            modelAssetManager->add(path, new ModelAsset(path));
            modelAssetPipeline.submitAsset(path);
        }
    }
 
    MeshAsset * AssetManager::getMeshAsset( const Asset::Path & asset )
    {
        auto data = meshAssetManager->getAsset( asset );
        if (!data.has_value())
        {
            loadEcsModel(asset.getFilePath());
            return nullptr;
        }
        return data.value();
    }
 
    void AssetManager::loadEcsTexture(const std::filesystem::path &path) {
        TRACY_ZONE_SCOPED_NAMED("Loading texture data");
        texturePipeline.submitAsset(path);
        textureAssetManager->declare(path);
    }
 
    std::vector<const Mesh *> AssetManager::getAllMeshes() const {
        std::vector<const Mesh *> allMeshes(meshAllocator.getUsedIndices().size());
        uint32_t i = 0;
        for (const std::optional<Mesh> &mesh: meshData) {
            if (!mesh.has_value()) continue;
            allMeshes[i] = &mesh.value();
            i++;
        }
        return allMeshes;
    }
 
    uint32_t AssetManager::getTotalPrimitiveCount() const {
        uint32_t primCount = 0u;
        for (const Mesh *mesh: getAllMeshes()) {
            primCount += mesh->getPrimitives().size();
        }
        return primCount;
    }
 
    bool AssetManager::doesMeshAlreadyExist(const std::filesystem::path &meshPath) const {
        return meshes.find(meshPath) != meshes.end();
    }
 
    void AssetManager::logAllLoadedAssets() const {
        PLOGI << "Loaded Mesh count: " << meshes.size();
        PLOGI << "Loaded Texture count: " << textures.size();
    }
 
    void AssetManager::reloadMeshOffsets() {
        meshOffsets.clear();
 
        uint32_t sum = 0u;
        for (std::optional<Mesh> &mesh: meshData) {
            if (!mesh.has_value()) continue;
            meshOffsets[&mesh.value()] = sum;
            sum += mesh.value().getMeshletCount();
        }
    }
 
    void AssetManager::cleanup() {
        textures.clear();
        meshes.clear();
 
        meshAllocator.reset(0);
        for (auto &mesh: meshData) {
            if (mesh.has_value()) {
                mesh->cleanup();
            }
            mesh.reset();
        }
        for (auto &texture: textureData) {
            if (texture.has_value()) {
                texture->cleanup();
            }
            texture.reset();
        }
 
        for (auto &val: materialStorageBuffers | std::views::values) {
            val.destroy();
        }
        materialStorageBuffers.clear();
    }
 
    std::vector<VkDescriptorImageInfo> AssetManager::getTextureDescriptorInfos() const {
        std::vector<VkDescriptorImageInfo> descriptorTextures;
        for (auto &texture: textureData) {
            if (!texture.has_value()) continue;
            VkDescriptorImageInfo descriptorImageInfo;
            descriptorImageInfo.sampler = texture.value().getVkImageSampler();
            descriptorImageInfo.imageView = texture.value().getVkImageView();
            descriptorImageInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
            descriptorTextures.push_back(descriptorImageInfo);
        }
        return descriptorTextures;
    }
 
    uint32_t AssetManager::getShaderCount() const {
        return shaders.size();
    }
 
    std::vector<MaterialShader *> AssetManager::getShaders() const {
        return shaders;
    }
 
    PipelineNames AssetManager::materialNameFromString(const std::string &string) {
        return DIFFUSE_FLAT_COLOR;
    }
 
    MaterialShader *AssetManager::getShaderByName(const std::string &shaderName) {
        PipelineNames name = materialNameFromString(shaderName);
        return getShaderByName(name);
    }
 
    MaterialShader *AssetManager::getShaderByName(const PipelineNames &shaderName) {
        const auto it = shadersByName.find(shaderName);
        if (it == shadersByName.end()) {
            return nullptr;
        }
        return it->second;
    }
 
    std::vector<Texture *> AssetManager::getTexturesToUpload() {
        return texturesToCopyImageData;
    }
 
    uint32_t AssetManager::getMeshOffset(Mesh *mesh) const {
        return meshOffsets.at(mesh);
    }
 
    MaterialShader *AssetManager::registerShader(MaterialShader shader, const PipelineNames &materialName) {
        uint32_t index = shaderAllocator.allocate();
 
        shaderData[index] = std::move(shader);
        MaterialShader *shaderPtr = &shaderData[index].value();
        shaders.push_back(shaderPtr);
        shaderOffsets[shaderPtr] = index;
 
        shadersByName[materialName] = shaderPtr;
        return shaderPtr;
    }
 
    void AssetManager::unregisterShader(MaterialShader *shader) {
        uint32_t shaderIndex = shaderOffsets[shader];
        shaderOffsets.erase(shader);
 
        if (const auto it = std::ranges::find(shaders, shader); it != shaders.end()) {
            shaders.erase(it);
        }
 
        shaderData[shaderIndex].reset();
    }
 
    VulkanBuffer &AssetManager::getMaterialStorageBufferByName(const PipelineNames name) {
        return materialStorageBuffers[name];
    }
 
    std::vector<const MeshPrimitive *> AssetManager::getMeshPrimitivesFromMeshes(
        const std::vector<const Mesh *> &meshes) const {
        std::vector<const MeshPrimitive *> allPrimitives;
 
        for (const Mesh *mesh: meshes) {
            // Use your new "ByRef" getter to get a reference to the original vector
            for (const MeshPrimitive &primitive: mesh->getPrimitivesByReference()) {
                // Store the ADDRESS of the original primitive. No copy is made.
                allPrimitives.push_back(&primitive);
            }
        }
        return allPrimitives;
    }
 
    std::vector<MeshPrimitive *> AssetManager::getMeshPrimitivesFromMeshes(const std::vector<Mesh *> &meshes) {
        std::vector<MeshPrimitive *> allPrimitives;
 
        for (Mesh *mesh: meshes) {
            // Use your new "ByRef" getter to get a reference to the original vector
            for (MeshPrimitive &primitive: mesh->getPrimitivesByReference()) {
                // Store the ADDRESS of the original primitive. No copy is made.
                allPrimitives.push_back(&primitive);
            }
        }
        return allPrimitives;
    }
 
    uint32_t AssetManager::getMeshletCount(const std::vector<const Mesh *> &meshes) const {
        uint32_t meshletCount = 0;
        uint32_t primitiveCount = 0;
        for (const Mesh *mesh: meshes) {
            for (const MeshPrimitive &primitive: mesh->getPrimitivesByReference()) {
                uint32_t primMeshletCount = primitive.getMeshletsCount();
                meshletCount += primMeshletCount;
                primitiveCount++;
                if (primMeshletCount == 0) {
                    PLOGW << "Primitive " << primitiveCount << " has 0 meshlets!";
                }
            }
        }
        PLOGI << "Total meshlet count: " << meshletCount << " from " << primitiveCount << " primitives";
        return meshletCount;
    }
 
    Ecs::TextureAssetPipeline& AssetManager::getTextureAssetPipeline() {
        return texturePipeline;
    }
 
    Ecs::ModelAssetPipeline & AssetManager::getMeshAssetPipeline() {
        return modelAssetPipeline;
    }
 
    void AssetManager::unloadAllData() const
    {
        TRACY_ZONE_SCOPED_NAMED("Unloading manager data");
        materialAssetManager->clear();
        meshAssetManager->clear();
        modelAssetManager->clear();
        textureAssetManager->clear();
    }
 
    MeshAsset * AssetManager::getMeshAsset( const Asset::Path & asset ) const
    {
        return UnpackOptional(meshAssetManager->getAsset( asset ));
    }
 
    bool AssetManager::doesTextureAlreadyExist(const std::filesystem::path &path) {
        TRACY_LOCK_GUARD(std::mutex, lock, textureMutex);
        return textures.contains(path);
    }
 
    uint32_t AssetManager::getTextureDescriptorIndex(const std::filesystem::path &path) {
        TRACY_LOCK_GUARD(std::mutex, lock, textureMutex);
        const auto it = textures.find(path.generic_string());
        if (it != textures.end() && it->second && it->second->isDescriptorIndexInitialized()) {
            return it->second->getDescriptorIndex();
        }
        return 0xFFFFFFFF;
    }
 
    Texture *AssetManager::registerTexture(const std::filesystem::path &path, Texture texture) {
        TRACY_LOCK_GUARD(std::mutex, lock, textureMutex);
        if (textures.contains(path.generic_string())) {
            return textures.find(path.generic_string())->second;
        }
 
        texture.createResources();
 
        uint32_t freeTextureIndex = textureAllocator.allocate();
        texture.descriptorIndex = freeTextureIndex;
        textureData[freeTextureIndex] = std::move(texture);
 
        Texture *texturePtr = &textureData[freeTextureIndex].value();
        textures[path.generic_string()] = texturePtr;
        textureIndexMap.insert(freeTextureIndex, texturePtr);
 
        // Queue texture for GPU upload via RenderingDataManager
        if (renderer) {
            renderer->getRenderingDataManager()->queueTextureForUpload(texturePtr);
        }
 
        PLOGI << "Texture " << path.generic_string() << " created.";
        return textures[path.generic_string()];
    }
 
    void AssetManager::unregisterTexture(Texture *texture) {
        uint32_t textureIndex = std::numeric_limits<uint32_t>::max();
        TRACY_LOCK_GUARD(std::mutex, lock, textureMutex);
        for (const auto &[path, texturePtr]: textures) {
            if (texturePtr == texture) {
                textureIndex = texturePtr->descriptorIndex;
                break;
            }
        }
 
        textureData[textureIndex]->reset();
        textureData[textureIndex].reset();
        textureIndexMap.remove_left(textureIndex);
    }
 
    Mesh *AssetManager::registerMesh(const std::filesystem::path &path, GltfLoader::GltfMeshData &gltfMeshData) {
        TRACY_ZONE_SCOPED_NAMED("Registering mesh");
        uint32_t meshIndex = std::numeric_limits<uint32_t>::max();
        const std::string meshName = Mesh::createMeshName(path, gltfMeshData.getName()); {
            TRACY_LOCK_GUARD(std::mutex, lock, meshesMutex);
 
            const auto it = meshes.find(meshName);
            if (it != meshes.end()) {
                return it->second;
            }
 
            const uint32_t freeMeshIndex = meshAllocator.allocate();
 
            meshData[freeMeshIndex].emplace(gltfMeshData, context, renderer);
            meshData[freeMeshIndex].value().descriptorIndex = freeMeshIndex;
            Mesh *meshPtr = &meshData[freeMeshIndex].value();
            meshes[meshName] = meshPtr;
            meshIndexMap.insert(freeMeshIndex, meshPtr);
            meshIndex = freeMeshIndex;
        }
 
        meshData[meshIndex]->createResources();
 
        return meshes[meshName];
    }
 
    void AssetManager::unregisterMesh(Mesh *mesh) {
        TRACY_ZONE_SCOPED_NAMED("Unregistering mesh");
        uint32_t meshIndex = std::numeric_limits<uint32_t>::max();
 
        TRACY_LOCK_GUARD(std::mutex, lock, meshesMutex);
        for (const auto &entry: meshes) {
            if (entry.second == mesh) {
                meshIndex = entry.second->descriptorIndex;
                break;
            }
        }
 
        meshData[meshIndex]->reset();
        meshData[meshIndex].reset();
        meshIndexMap.remove_left(meshIndex);
 
        if (meshOffsets.find(mesh) != meshOffsets.end()) {
            meshOffsets.erase(meshOffsets.find(mesh));
        }
    }
 
    uint32_t AssetManager::getImageCount() const {
        return textures.size();
    }
} // namespace EngineCore