TextureIdentity.h

#pragma once
 
#include "Engine/Texture/TextureType.h"
 
#include <cstddef>
#include <filesystem>
#include <functional>
#include <string>
 
namespace Engine::Assets::Textures
{
    inline std::string normalizeTexturePath( const std::filesystem::path & path )
    {
        std::string pathStr = path.generic_string();
        if ( pathStr.size() >= 2 && pathStr[0] == '.' && pathStr[1] == '/' )
        {
            pathStr = pathStr.substr( 2 );
        }
        return pathStr;
    }

    struct TextureIdentityKey
    {
        std::string normalizedPath;  
        TextureType type = TextureType::Unknown;  

        [[nodiscard]] bool empty() const
        {
            return normalizedPath.empty();
        }

        bool operator==( const TextureIdentityKey & other ) const
        {
            return normalizedPath == other.normalizedPath && type == other.type;
        }
    };

    struct TextureIdentityKeyHash
    {
        std::size_t operator()( const TextureIdentityKey & key ) const noexcept
        {
            const std::size_t pathHash = std::hash<std::string>{}( key.normalizedPath );
            const std::size_t typeHash = std::hash<int>{}( static_cast<int>( key.type ) );
            return pathHash ^ ( typeHash + 0x9e3779b9u + ( pathHash << 6u ) + ( pathHash >> 2u ) );
        }
    };

    inline TextureIdentityKey makeTextureIdentityKey( const std::filesystem::path & path, TextureType type )
    {
        return TextureIdentityKey{ .normalizedPath = normalizeTexturePath( path ), .type = type };
    }
}  // namespace Engine::Assets::Textures