types.h

#pragma once
 
#include <cstdint>
#include <typeinfo>
 
namespace Vkm::Engine {

struct StorageIndex {
    uint32_t index      = 0; 
    uint32_t generation = 0; 
 
    constexpr explicit operator bool() const noexcept { return index != 0; }

    constexpr bool operator==(const StorageIndex& other) const noexcept {
        return index == other.index && generation == other.generation;
    }
    constexpr bool operator!=(const StorageIndex& other) const noexcept {
        return !(*this == other);
    }
};
 
static_assert(sizeof(StorageIndex) == 8, "StorageIndex must be 8 bytes");

struct GenerationIndex {
    uint32_t value = 0;
 
    static constexpr uint32_t ALIVE_BIT = uint32_t(1) << 31;
    static constexpr uint32_t GEN_MASK  = ~ALIVE_BIT;

    void setAlive(bool alive) { value = (value & GEN_MASK) | (alive ? ALIVE_BIT : 0); }

    void bumpGeneration() { value = (value & ALIVE_BIT) | (((value & GEN_MASK) + 1) & GEN_MASK); }
 
    bool     alive() const      { return value & ALIVE_BIT; }
    uint32_t generation() const { return value & GEN_MASK; }
};
 
static_assert(sizeof(GenerationIndex) == 4, "GenerationIndex must be 4 bytes");

using TypeId = uint32_t;
 
namespace detail {
    TypeId typeIdFromInfo(const std::type_info& info);
}
 
template<typename T>
TypeId typeId() {
    // Cached per (module, T); the shared registry keeps the modules agreeing.
    static const TypeId s_id = detail::typeIdFromInfo(typeid(T));
    return s_id;
}
 
} // namespace Vkm::Engine