TextureManager.cpp

Go to the documentation of this file.

#include "TextureManager.h"
 
#include <filesystem>
#include <thread>
 
#include <stb/stb_image.h>
#include <ElevateEngine/Renderer/GraphicsAPI.h>
 
#include <ElevateEngine/Core/Log.h>
#include <ElevateEngine/Core/PathResolver.h>
 
namespace Elevate {
    TextureManager::TextureManager()
    {
        //TODO : UNCOMMENT AND IMPL 
        m_defaultTexture = Texture::CreateFromColor({ 1.0,1.0,1.0,1.0 }, "default");
        EE_CORE_INFO("Texture Manager Initialized.");
    }
 
    TexturePtr Elevate::TextureManager::RegisterTexture(TexturePtr texture)
    {
        std::string key;
 
        // TODO FIN A WAY TO GET THE ABOSLUTE PATH AND TO NORMALIZE IT
        if (texture->GetMetadata().Source == TextureSource::File)
        {
            if (instance().m_Textures.count(texture->GetPath()) > 0)
            {
                return instance().m_Textures[texture->GetPath()];
            }
            else
            {
                instance().m_Textures[texture->GetPath()] = texture;
                return texture;
            }
        }
        else return texture;
    }
 
    // TODO REMOVE OR IMPL. BUT WE NEED TO DO SOMETHING WITH IT
    //TexturePtr TextureManager::RegisterTexture(std::string& path)
    //{
    //  int width, height, channels;
    //  unsigned char* data = stbi_load(path.c_str(), &width, &height, &channels, STBI_rgb_alpha);
 
    //  if (!data)
    //  {
    //      EE_CORE_ERROR("Failed to load texture {}", path);
    //      return nullptr;
    //  }
 
    //  auto texture = AddOrGetTexture(Texture::CreateFromData(data, width, height, (TextureFormat) channels, path));
    //  stbi_image_free(data);
    //  return texture;
    //}
 
    TexturePtr TextureManager::GetTexture(const std::string& path)
    {
        std::filesystem::path fsPath = std::filesystem::absolute(path);
        return (instance().m_Textures.count(fsPath.string()) > 0) ? instance().m_Textures[fsPath.string()] : nullptr;
    }
 
    TexturePtr TextureManager::LoadTextureAsync(const std::string& path, TextureType usage)
    {
        std::string resolvedPath = PathResolver::Resolve(path);
        std::filesystem::path fsPath = std::filesystem::absolute(resolvedPath);
        std::string absPath = fsPath.string();
 
        EE_CORE_TRACE("{}", absPath);
 
        // If the texture is already loading, or already loaded, return and cancel
        TexturePtr tex = GetTexture(absPath);
        if (!tex)
        {
            for (TextureLoadResult& res : instance().m_loadingTextures) {
                if (res.meta.Path == absPath)
                {
                    // todo: change, should return an empty texture placeholder
                    return nullptr;
                }
            }
        }
        else
        {
            return tex;
        }
 
        // Creation of a blank texture
        TextureMetadata meta = TextureMetadataBuilder()
            .Name(fsPath.filename().string())
            .Path(absPath)
            .size(0, 0)
            .Format(TextureFormat::EMPTY)
            .Usage(usage)
            .Source(TextureSource::File)
            .State(TextureState::Unloaded)
            .Build();
 
        tex = Texture::CreateFromData(nullptr, meta);
 
        // Add the texture to the list of textures
        instance().m_Textures[absPath] = tex;
 
        TextureLoadResult res;
        res.meta = meta;
 
        // Get the texture data async with stbi_load
        std::thread([res]() mutable {
                int width = 0;
                int height = 0;
                int channels = 0;
                res.data = stbi_load(res.meta.Path.c_str(), &width, &height, &channels, 0);
                res.meta = TextureMetadataBuilder(res.meta)
                    .size(static_cast<uint32_t>(width), static_cast<uint32_t>(height))
                    .Format((TextureFormat) channels)
                    .State((res.data) ? TextureState::Loaded : TextureState::Failed)
                    .Build();
 
                std::lock_guard<std::mutex> lock(instance().m_textureMutex);
                instance().m_loadingTextures.push_back(res);
            }
        ).detach();
 
        return tex;
    }
 
    void TextureManager::UpdateLoadingTextures()
    {
        TextureManager& manager = instance();
        std::lock_guard<std::mutex> lock(manager.m_textureMutex);
 
        auto it = manager.m_loadingTextures.begin();
        while (it != manager.m_loadingTextures.end())
        {
            switch (it->meta.State)
            {
            case TextureState::Loaded:
                if (manager.m_Textures.count(it->meta.Path))
                {
                    EE_CORE_INFO("Loaded texture : {}, {}x{}", it->meta.Path, it->meta.Width, it->meta.Height);
                    manager.m_Textures[it->meta.Path]->SetData(it->data, it->meta);
                    stbi_image_free(it->data);  
                    it->data = nullptr;
                }
                it = manager.m_loadingTextures.erase(it);
                break;
            case TextureState::Failed:
                if (manager.m_Textures.count(it->meta.Path))
                {
                    EE_CORE_ERROR("Failed to load texture : {}", it->meta.Path);
                    manager.m_Textures[it->meta.Path]->SetData(it->data, it->meta);
                    if (it->data)
                    {
                        stbi_image_free(it->data);
                    }
                    it->data = nullptr;
                }
                it = manager.m_loadingTextures.erase(it);
                break;
            default:
                ++it;
                break;
            }
        }
    }
}