TextureHandle.h

#pragma once
#include "TextureType.h"
#include <cassert>
#include <cstdint>
 
namespace Engine::Assets {

class TextureHandle {
public:
    static constexpr uint32_t INVALID_ID = 0xFFFFFFFF;  

    TextureHandle() = default;

    TextureHandle(uint32_t id, TextureType type) : id_(id), type_(type) {}

    [[nodiscard]] bool isValid() const { return id_ != INVALID_ID; }

    [[nodiscard]] uint32_t getId() const { return id_; }

    [[nodiscard]] TextureType getType() const { return type_; }

    bool operator==(const TextureHandle& other) const {
        return id_ == other.id_ && type_ == other.type_;
    }

    bool operator!=(const TextureHandle& other) const {
        return !(*this == other);
    }
 
private:
    uint32_t id_ = INVALID_ID;
    TextureType type_ = TextureType::Unknown;
};

template <TextureType Type>
class TypedTextureHandle {
public:
    TypedTextureHandle() = default;

    explicit TypedTextureHandle(TextureHandle base) : base_(base) {
        assert((base.getType() == Type || !base.isValid()) &&
               "TextureHandle type mismatch in TypedTextureHandle construction");
    }

    [[nodiscard]] bool isValid() const { return base_.isValid(); }

    [[nodiscard]] TextureHandle getBase() const { return base_; }

    [[nodiscard]] uint32_t getId() const { return base_.getId(); }

    [[nodiscard]] static constexpr TextureType getType() { return Type; }

    operator TextureHandle() const { return base_; }

    bool operator==(const TypedTextureHandle& other) const {
        return base_ == other.base_;
    }

    bool operator!=(const TypedTextureHandle& other) const {
        return !(*this == other);
    }
 
private:
    TextureHandle base_;
};
 
} // namespace EngineCore