Elevate::TextureManager Class Reference

#include <TextureManager.h>

Static Public Member Functions
static TexturePtr	RegisterTexture (TexturePtr texture)
static TexturePtr	GetTexture (const std::string &path)
	FUNCTION TO LOAD AND GET A TEXTURE SYNCED WITH THE CURRENT THREAD.
static TexturePtr	LoadTextureAsync (const std::string &path, TextureType usage=TextureType::Diffuse)
static TexturePtr	GetDefaultTexture ()
static bool	IsAllLoaded ()

Static Protected Member Functions
static void	UpdateLoadingTextures ()

Friends
class	Application

Detailed Description

Definition at line 17 of file TextureManager.h.

Member Function Documentation

GetDefaultTexture()

static TexturePtr Elevate::TextureManager::GetDefaultTexture ( )

inlinestatic

Definition at line 25 of file TextureManager.h.

{ return  instance().m_defaultTexture; }

GetTexture()

TexturePtr Elevate::TextureManager::GetTexture ( const std::string &  path )

static

FUNCTION TO LOAD AND GET A TEXTURE SYNCED WITH THE CURRENT THREAD.

Definition at line 58 of file TextureManager.cpp.

    {
        std::filesystem::path fsPath = std::filesystem::absolute(path);
        return (instance().m_Textures.count(fsPath.string()) > 0) ? instance().m_Textures[fsPath.string()] : nullptr;
    }

IsAllLoaded()

static bool Elevate::TextureManager::IsAllLoaded ( )

inlinestatic

Definition at line 27 of file TextureManager.h.

{ return instance().m_loadingTextures.empty(); }

LoadTextureAsync()

TexturePtr Elevate::TextureManager::LoadTextureAsync ( const std::string &  path, TextureType  usage = TextureType::Diffuse  )

static

Definition at line 64 of file TextureManager.cpp.

    {
        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;
    }

RegisterTexture()

TexturePtr Elevate::TextureManager::RegisterTexture ( TexturePtr  texture )

static

Definition at line 20 of file TextureManager.cpp.

    {
        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;
    }

UpdateLoadingTextures()

void Elevate::TextureManager::UpdateLoadingTextures ( )

staticprotected

Definition at line 128 of file TextureManager.cpp.

    {
        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;
            }
        }
    }

Friends And Related Symbol Documentation

Application

friend class Application

friend

Definition at line 29 of file TextureManager.h.

---

The documentation for this class was generated from the following files:

• ElevateEngine/src/ElevateEngine/Renderer/Texture/TextureManager.h
• ElevateEngine/src/ElevateEngine/Renderer/Texture/TextureManager.cpp