TextureHandleRegistry.cpp

Go to the documentation of this file.

#include "Engine/Texture/TextureHandleRegistry.h"
 
#include <mutex>
#include <plog/Log.h>
 
namespace EngineCore {
 
namespace {
    // Normalize path for consistent lookup - handles relative vs absolute, different separators, etc.
    std::string normalizePath(const std::filesystem::path& path) {
        // Use generic_string for consistent forward slashes
        std::string pathStr = path.generic_string();
 
        // Remove any leading "./" if present
        if (pathStr.size() >= 2 && pathStr[0] == '.' && pathStr[1] == '/') {
            pathStr = pathStr.substr(2);
        }
 
        return pathStr;
    }
}
 
TextureHandle TextureHandleRegistry::getOrCreateHandleImpl(const std::filesystem::path& path, TextureType type) {
    std::string pathKey = normalizePath(path);
    PLOGI << "TextureHandleRegistry::getOrCreateHandleImpl - normalized path: '" << pathKey << "' from '" << path.generic_string() << "'";
 
    // First try with shared (read) lock for the common case
    {
        std::shared_lock<std::shared_mutex> readLock(mutex_);
        auto it = pathToHandleId_.find(pathKey);
        if (it != pathToHandleId_.end()) {
            // Handle already exists - verify type matches
            const Entry& entry = entries_[it->second];
            if (entry.type != type) {
                PLOGW << "TextureHandleRegistry: Type mismatch for path '" << pathKey
                      << "' - existing type=" << static_cast<int>(entry.type)
                      << " requested type=" << static_cast<int>(type)
                      << ". Using existing type.";
            }
            return TextureHandle(it->second, entry.type);
        }
    }
 
    // Need to create a new entry - acquire exclusive (write) lock
    std::unique_lock<std::shared_mutex> writeLock(mutex_);
 
    // Double-check after acquiring write lock (another thread may have added it)
    auto it = pathToHandleId_.find(pathKey);
    if (it != pathToHandleId_.end()) {
        const Entry& entry = entries_[it->second];
        return TextureHandle(it->second, entry.type);
    }
 
    // Create new entry
    uint32_t newId = static_cast<uint32_t>(entries_.size());
    Entry newEntry;
    newEntry.path = path;
    newEntry.type = type;
    newEntry.texture = nullptr;
    newEntry.descriptorIndex = TextureHandle::INVALID_ID;
 
    entries_.push_back(std::move(newEntry));
    pathToHandleId_[pathKey] = newId;
 
    PLOGD << "TextureHandleRegistry: Created handle " << newId
          << " for path '" << pathKey << "' with type " << static_cast<int>(type);
 
    return TextureHandle(newId, type);
}
 
uint32_t TextureHandleRegistry::resolveDescriptorIndex(TextureHandle handle) const {
    if (!handle.isValid()) {
        return TextureHandle::INVALID_ID;
    }
 
    std::shared_lock<std::shared_mutex> lock(mutex_);
 
    uint32_t id = handle.getId();
    if (id >= entries_.size()) {
        PLOGW << "TextureHandleRegistry: Invalid handle ID " << id
              << " (entries size=" << entries_.size() << ")";
        return TextureHandle::INVALID_ID;
    }
 
    return entries_[id].descriptorIndex;
}
 
TextureType TextureHandleRegistry::getTextureType(TextureHandle handle) const {
    if (!handle.isValid()) {
        return TextureType::Unknown;
    }
 
    std::shared_lock<std::shared_mutex> lock(mutex_);
 
    uint32_t id = handle.getId();
    if (id >= entries_.size()) {
        return TextureType::Unknown;
    }
 
    return entries_[id].type;
}
 
TextureType TextureHandleRegistry::getTextureTypeForPath(const std::filesystem::path& path) const {
    std::string pathKey = normalizePath(path);
    PLOGI << "TextureHandleRegistry::getTextureTypeForPath - normalized path: '" << pathKey << "'";
 
    std::shared_lock<std::shared_mutex> lock(mutex_);
 
    auto it = pathToHandleId_.find(pathKey);
    if (it == pathToHandleId_.end()) {
        return TextureType::Unknown;
    }
 
    return entries_[it->second].type;
}
 
void TextureHandleRegistry::onTextureLoaded(const std::filesystem::path& path, Texture* texture, uint32_t descriptorIndex) {
    std::string pathKey = normalizePath(path);
    PLOGI << "TextureHandleRegistry::onTextureLoaded - normalized path: '" << pathKey << "' from '" << path.generic_string() << "'";
 
    std::unique_lock<std::shared_mutex> lock(mutex_);
 
    auto it = pathToHandleId_.find(pathKey);
    if (it == pathToHandleId_.end()) {
        PLOGW << "TextureHandleRegistry: onTextureLoaded called for unregistered path '" << pathKey << "'";
        return;
    }
 
    Entry& entry = entries_[it->second];
    entry.texture = texture;
    entry.descriptorIndex = descriptorIndex;
 
    PLOGD << "TextureHandleRegistry: Texture loaded for handle " << it->second
          << " path='" << pathKey << "' descriptorIndex=" << descriptorIndex;
}
 
void TextureHandleRegistry::onTextureUnloaded(const std::filesystem::path& path) {
    std::string pathKey = normalizePath(path);
 
    std::unique_lock<std::shared_mutex> lock(mutex_);
 
    auto it = pathToHandleId_.find(pathKey);
    if (it == pathToHandleId_.end()) {
        return;  // Not registered, nothing to do
    }
 
    Entry& entry = entries_[it->second];
    entry.texture = nullptr;
    entry.descriptorIndex = TextureHandle::INVALID_ID;
 
    PLOGD << "TextureHandleRegistry: Texture unloaded for handle " << it->second
          << " path='" << pathKey << "'";
}
 
size_t TextureHandleRegistry::getHandleCount() const {
    std::shared_lock<std::shared_mutex> lock(mutex_);
    return entries_.size();
}
 
std::filesystem::path TextureHandleRegistry::getPathForHandle(TextureHandle handle) const {
    if (!handle.isValid()) {
        return {};
    }
 
    std::shared_lock<std::shared_mutex> lock(mutex_);
 
    uint32_t id = handle.getId();
    if (id >= entries_.size()) {
        return {};
    }
 
    return entries_[id].path;
}
 
void TextureHandleRegistry::clear() {
    std::unique_lock<std::shared_mutex> lock(mutex_);
    entries_.clear();
    pathToHandleId_.clear();
    PLOGD << "TextureHandleRegistry: Cleared all entries";
}
 
} // namespace EngineCore