TextureLoadData.h

#pragma once
 
#include <vector>
 
namespace EngineCore {
    struct TextureLoadData {
        TextureLoadData(std::vector<unsigned char> imageData, int width, int height, int channels) :
        width(width),
        height(height),
        channels(channels),
        imageData(std::move(imageData))
        {
 
        }
 
        int width;  
        int height;  
        int channels;  
        std::vector<unsigned char> imageData;  

        bool operator==(const TextureLoadData& other) const {
            return width == other.width &&
                   height == other.height &&
                   channels == other.channels &&
                   imageData == other.imageData;
        }
    };
}
 
namespace std {
 
    template <>
    struct hash<EngineCore::TextureLoadData> {
        std::size_t operator()(const EngineCore::TextureLoadData& tex) const {
            std::size_t seed = 0;
 
            // Hash the integral members
            seed ^= std::hash<int>()(tex.width) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
            seed ^= std::hash<int>()(tex.height) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
            seed ^= std::hash<int>()(tex.channels) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
 
            // Hash the imageData vector
            for (const auto& byte : tex.imageData) {
                seed ^= std::hash<unsigned char>()(byte) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
            }
 
            return seed;
        }
    };
 
} // namespace std