component_cache_item.h

#pragma once
#include "gaia/config/config.h"
 
#include <cstdint>
#include <cstring>
#include <type_traits>
 
#include "gaia/cnt/darray.h"
#include "gaia/core/hashing_string.h"
#include "gaia/ecs/component.h"
#include "gaia/ecs/component_desc.h"
#include "gaia/ecs/id.h"
#include "gaia/mem/mem_alloc.h"
#include "gaia/mem/mem_utils.h"
#include "gaia/mem/smallblock_allocator.h"
#include "gaia/ser/ser_common.h"
#include "gaia/ser/ser_rt.h"
#include "gaia/util/str.h"
 
namespace gaia {
  namespace ecs {
    class World;
    class Chunk;
    struct ComponentRecord;
 
    struct GAIA_API ComponentCacheItem final {
      GAIA_USE_SMALLBLOCK(ComponentCacheItem);
 
      static constexpr uint32_t MaxNameLength = 256;
 
      using SymbolLookupKey = core::StringLookupKey<512>;
 
      using FuncCtor = void(void*, uint32_t);
      using FuncDtor = void(void*, uint32_t);
      using FuncFrom = void(void*, void*, uint32_t, uint32_t, uint32_t, uint32_t);
      using FuncCopy = void(void*, const void*, uint32_t, uint32_t, uint32_t, uint32_t);
      using FuncMove = void(void*, void*, uint32_t, uint32_t, uint32_t, uint32_t);
      using FuncSwap = void(void*, void*, uint32_t, uint32_t, uint32_t, uint32_t);
      using FuncCmp = bool(const void*, const void*);
 
      using FuncSave = void(ser::serializer&, const void*, uint32_t, uint32_t, uint32_t);
      using FuncLoad = void(ser::serializer&, void*, uint32_t, uint32_t, uint32_t);
 
      using FuncOnAdd = void(const World& world, const ComponentCacheItem&, Entity);
      using FuncOnDel = void(const World& world, const ComponentCacheItem&, Entity);
      using FuncOnSet = void(const World& world, const ComponentRecord&, Chunk& chunk);
 
      using RuntimeField = ecs::RuntimeField;
 
      struct ComponentCacheItemCtx {
        util::str_view name{};
        uint32_t size = 0;
        uint32_t alig = 0;
        DataStorageType storageType = DataStorageType::Table;
        uint32_t soa = 0;
        const uint8_t* pSoaSizes = nullptr;
        ComponentLookupHash hashLookup{};
        RuntimeTypeKind typeKind = RuntimeTypeKind::Struct;
        RuntimePrimitiveKind primitiveKind = RuntimePrimitiveKind::None;
        FuncCtor* funcCtor = nullptr;
        FuncMove* funcMoveCtor = nullptr;
        FuncCopy* funcCopyCtor = nullptr;
        FuncDtor* funcDtor = nullptr;
        FuncCopy* funcCopy = nullptr;
        FuncMove* funcMove = nullptr;
        FuncSwap* funcSwap = nullptr;
        FuncCmp* funcCmp = nullptr;
        FuncSave* funcSave = nullptr;
        FuncLoad* funcLoad = nullptr;
      };
 
      Entity entity;
      Component comp;
      ComponentLookupHash hashLookup;
      uint8_t soaSizes[meta::StructToTupleMaxTypes];
 
      SymbolLookupKey name;
      util::str path;
      FuncCtor* func_ctor{};
      FuncMove* func_move_ctor{};
      FuncCopy* func_copy_ctor{};
      FuncDtor* func_dtor{};
      FuncCopy* func_copy{};
      FuncMove* func_move{};
      FuncSwap* func_swap{};
      FuncCmp* func_cmp{};
      FuncSave* func_save{};
      // !Function to call when loading component from a buffer
      FuncLoad* func_load{};
      RuntimeTypeKind typeKind = RuntimeTypeKind::Struct;
      RuntimePrimitiveKind primitiveKind = RuntimePrimitiveKind::None;
 
#if GAIA_ENABLE_HOOKS
      struct Hooks {
  #if GAIA_ENABLE_ADD_DEL_HOOKS
        FuncOnAdd* func_add{};
        FuncOnDel* func_del{};
  #endif
  #if GAIA_ENABLE_SET_HOOKS
        FuncOnSet* func_set{};
  #endif
      };
      Hooks comp_hooks;
#endif
      cnt::darray<RuntimeField> fields;
 
    private:
      ComponentCacheItem() = default;
      ~ComponentCacheItem() = default;
 
    public:
      ComponentCacheItem(const ComponentCacheItem&) = delete;
      ComponentCacheItem(ComponentCacheItem&&) = delete;
      ComponentCacheItem& operator=(const ComponentCacheItem&) = delete;
      ComponentCacheItem& operator=(ComponentCacheItem&&) = delete;
 
      void
      ctor_move(void* pDst, void* pSrc, uint32_t idxDst, uint32_t idxSrc, uint32_t sizeDst, uint32_t sizeSrc) const {
        GAIA_ASSERT(pSrc != nullptr && pDst != nullptr);
        GAIA_ASSERT(pSrc != pDst || idxSrc != idxDst);
        if (func_move_ctor != nullptr) {
          func_move_ctor(pDst, pSrc, idxDst, idxSrc, sizeDst, sizeSrc);
          return;
        }
 
        if (comp.soa() != 0 || comp.size() == 0)
          return;
 
        auto* pD = (uint8_t*)pDst + ((uintptr_t)comp.size() * idxDst);
        auto* pS = (uint8_t*)pSrc + ((uintptr_t)comp.size() * idxSrc);
        memmove((void*)pD, (const void*)pS, comp.size());
      }
 
      void ctor_copy(
          void* pDst, const void* pSrc, uint32_t idxDst, uint32_t idxSrc, uint32_t sizeDst, uint32_t sizeSrc) const {
        GAIA_ASSERT(pSrc != nullptr && pDst != nullptr);
        GAIA_ASSERT(pSrc != pDst || idxSrc != idxDst);
        if (func_copy_ctor != nullptr) {
          func_copy_ctor(pDst, pSrc, idxDst, idxSrc, sizeDst, sizeSrc);
          return;
        }
 
        if (comp.soa() != 0 || comp.size() == 0)
          return;
 
        auto* pD = (uint8_t*)pDst + ((uintptr_t)comp.size() * idxDst);
        auto* pS = (const uint8_t*)pSrc + ((uintptr_t)comp.size() * idxSrc);
        memcpy((void*)pD, (const void*)pS, comp.size());
      }
 
      void dtor(void* pSrc) const {
        if (func_dtor != nullptr)
          func_dtor(pSrc, 1);
      }
 
      void
      copy(void* pDst, const void* pSrc, uint32_t idxDst, uint32_t idxSrc, uint32_t sizeDst, uint32_t sizeSrc) const {
        GAIA_ASSERT(pSrc != nullptr && pDst != nullptr);
        GAIA_ASSERT(pSrc != pDst || idxSrc != idxDst);
        if (func_copy != nullptr) {
          func_copy(pDst, pSrc, idxDst, idxSrc, sizeDst, sizeSrc);
          return;
        }
 
        if (comp.soa() != 0 || comp.size() == 0)
          return;
 
        auto* pD = (uint8_t*)pDst + ((uintptr_t)comp.size() * idxDst);
        auto* pS = (const uint8_t*)pSrc + ((uintptr_t)comp.size() * idxSrc);
        memcpy((void*)pD, (const void*)pS, comp.size());
      }
 
      void move(void* pDst, void* pSrc, uint32_t idxDst, uint32_t idxSrc, uint32_t sizeDst, uint32_t sizeSrc) const {
        GAIA_ASSERT(pSrc != nullptr && pDst != nullptr);
        GAIA_ASSERT(pSrc != pDst || idxSrc != idxDst);
        if (func_move != nullptr) {
          func_move(pDst, pSrc, idxDst, idxSrc, sizeDst, sizeSrc);
          return;
        }
 
        if (comp.soa() != 0 || comp.size() == 0)
          return;
 
        auto* pD = (uint8_t*)pDst + ((uintptr_t)comp.size() * idxDst);
        auto* pS = (uint8_t*)pSrc + ((uintptr_t)comp.size() * idxSrc);
        memmove((void*)pD, (const void*)pS, comp.size());
      }
 
      void
      swap(void* pLeft, void* pRight, uint32_t idxLeft, uint32_t idxRight, uint32_t sizeDst, uint32_t sizeSrc) const {
        GAIA_ASSERT(pLeft != nullptr && pRight != nullptr);
        if (func_swap != nullptr) {
          func_swap(pLeft, pRight, idxLeft, idxRight, sizeDst, sizeSrc);
          return;
        }
 
        if (comp.soa() != 0 || comp.size() == 0)
          return;
 
        auto* l = (uint8_t*)pLeft + ((uintptr_t)comp.size() * idxLeft);
        auto* r = (uint8_t*)pRight + ((uintptr_t)comp.size() * idxRight);
        GAIA_FOR(comp.size()) {
          const auto tmp = l[i];
          l[i] = r[i];
          r[i] = tmp;
        }
      }
 
      bool cmp(const void* pLeft, const void* pRight) const {
        GAIA_ASSERT(pLeft != pRight);
        if (func_cmp != nullptr)
          return func_cmp(pLeft, pRight);
 
        if (comp.soa() != 0 || comp.size() == 0)
          return true;
 
        return memcmp(pLeft, pRight, comp.size()) == 0;
      }
 
      void save(ser::serializer& serializer, const void* pSrc, uint32_t from, uint32_t to, uint32_t cap) const {
        GAIA_ASSERT(serializer.valid() && pSrc != nullptr && from < to && to <= cap);
        if (func_save != nullptr) {
          func_save(serializer, pSrc, from, to, cap);
          return;
        }
 
        if (comp.soa() != 0 || comp.size() == 0)
          return;
 
        const auto* pBase = (const uint8_t*)pSrc;
        GAIA_FOR2(from, to) {
          const auto* p = pBase + ((uintptr_t)comp.size() * i);
          serializer.save_raw((const void*)p, comp.size(), ser::serialization_type_id::trivial_wrapper);
        }
      }
 
      void load(ser::serializer& serializer, void* pDst, uint32_t from, uint32_t to, uint32_t cap) const {
        GAIA_ASSERT(serializer.valid() && pDst != nullptr && from < to && to <= cap);
        if (func_load != nullptr) {
          func_load(serializer, pDst, from, to, cap);
          return;
        }
 
        if (comp.soa() != 0 || comp.size() == 0)
          return;
 
        auto* pBase = (uint8_t*)pDst;
        GAIA_FOR2(from, to) {
          auto* p = pBase + ((uintptr_t)comp.size() * i);
          serializer.load_raw((void*)p, comp.size(), ser::serialization_type_id::trivial_wrapper);
        }
      }
 
      void clear_fields() {
        fields.clear();
      }
 
      GAIA_NODISCARD bool has_fields() const {
        return !fields.empty();
      }
 
      GAIA_NODISCARD static uint32_t field_element_count(const RuntimeFieldDesc& field) noexcept {
        return field.count == 0 ? 1U : field.count;
      }
 
      GAIA_NODISCARD static uint32_t field_element_count(const RuntimeField& field) noexcept {
        return field.count == 0 ? 1U : field.count;
      }
 
      GAIA_NODISCARD static uint32_t primitive_type_size(Entity type) noexcept {
        ser::serialization_type_id id = ser::serialization_type_id::ignore;
        if (!runtime_primitive_serialization_type(type, id))
          return 0;
        return ser::serialization_type_size(id, 0);
      }
 
      GAIA_NODISCARD bool add_field(const RuntimeFieldDesc& desc, uint32_t typeSize = 0) {
        if (desc.name.empty() || desc.name.size() >= MaxNameLength)
          return false;
        if (desc.type == EntityBad)
          return false;
 
        const auto elemSize = typeSize != 0 ? typeSize : primitive_type_size(desc.type);
        if (elemSize == 0)
          return false;
 
        const auto elemCount = field_element_count(desc);
        const auto end = (uint64_t)desc.offset + (uint64_t)elemSize * (uint64_t)elemCount;
        if (end > comp.size())
          return false;
 
        for (auto& field: fields) {
          if (strncmp(field.name, desc.name.data(), desc.name.size()) == 0 && field.name[desc.name.size()] == 0) {
            field.type = desc.type;
            field.offset = desc.offset;
            field.count = desc.count;
            return true;
          }
        }
 
        RuntimeField field{};
        memcpy((void*)field.name, (const void*)desc.name.data(), desc.name.size());
        field.name[desc.name.size()] = 0;
        field.type = desc.type;
        field.offset = desc.offset;
        field.count = desc.count;
        fields.push_back(field);
        return true;
      }
 
      GAIA_NODISCARD bool field(util::str_view fieldName, const RuntimeField** ppField) const {
        GAIA_ASSERT(ppField != nullptr);
        *ppField = nullptr;
        if (fieldName.empty() || fieldName.size() >= MaxNameLength)
          return false;
 
        for (const auto& field: fields) {
          if (strncmp(field.name, fieldName.data(), fieldName.size()) == 0 && field.name[fieldName.size()] == 0) {
            *ppField = &field;
            return true;
          }
        }
        return false;
      }
 
      GAIA_NODISCARD uint32_t field_count() const noexcept {
        return (uint32_t)fields.size();
      }
 
      void clear_runtime_fields() {
        fields.clear();
      }
 
#if GAIA_ENABLE_HOOKS
      Hooks& hooks() {
        return comp_hooks;
      }
 
      const Hooks& hooks() const {
        return comp_hooks;
      }
 
#endif
 
      GAIA_NODISCARD uint32_t calc_new_mem_offset(uint32_t addr, size_t cnt) const noexcept {
        if (comp.soa() == 0) {
          addr = (uint32_t)mem::detail::get_aligned_byte_offset(addr, comp.alig(), comp.size(), cnt);
        } else {
          GAIA_FOR(comp.soa()) {
            addr = (uint32_t)mem::detail::get_aligned_byte_offset(addr, comp.alig(), soaSizes[i], cnt);
          }
          // TODO: Magic offset. Otherwise, SoA data might leak past the chunk boundary when accessing
          //       the last element. By faking the memory offset we can bypass this is issue for now.
          //       Obviously, this needs fixing at some point.
          addr += comp.soa() * 12;
        }
        return addr;
      }
 
    private:
      template <typename T>
      GAIA_NODISCARD static uint32_t init_type_name(char (&nameTmp)[MaxNameLength]) {
        auto ct_name = detail::ComponentDesc<T>::name();
 
        // Allocate enough memory for the name string + the null-terminating character (
        // the compile time string returned by ComponentDesc<T>::name is not null-terminated).
        // Different compilers will give a bit different strings, e.g.:
        //   Clang/GCC: gaia::ecs::uni<Position>
        //   MSVC     : gaia::ecs::uni<struct Position>
        // Therefore, we first copy the compile-time string and then tweak it so it is
        // the same on all supported compilers.
        auto nameTmpLen = (uint32_t)ct_name.size();
        GAIA_ASSERT(nameTmpLen < MaxNameLength);
        memcpy((void*)nameTmp, (const void*)ct_name.data(), nameTmpLen);
        nameTmp[ct_name.size()] = 0;
 
        auto strip_prefix = [&](const char* prefix, uint32_t prefixLen) {
          if (nameTmpLen <= prefixLen || strncmp(nameTmp, prefix, prefixLen) != 0)
            return;
 
          memmove(nameTmp, nameTmp + prefixLen, nameTmpLen - prefixLen + 1);
          nameTmpLen -= prefixLen;
        };
 
        strip_prefix("const ", 6);
 
        const uint32_t NSubstrings = 3;
        const char* to_remove[NSubstrings] = {"class ", "struct ", "enum "};
        const uint32_t to_remove_len[NSubstrings] = {6, 7, 5};
        GAIA_FOR(NSubstrings) {
          strip_prefix(to_remove[i], to_remove_len[i]);
        }
 
        while (nameTmpLen > 0) {
          const auto ch = nameTmp[nameTmpLen - 1];
          if (ch != ' ' && ch != '&' && ch != '*')
            break;
 
          nameTmp[--nameTmpLen] = 0;
        }
 
        if (nameTmpLen > 6 && strncmp(nameTmp + nameTmpLen - 6, " const", 6) == 0) {
          nameTmpLen -= 6;
          nameTmp[nameTmpLen] = 0;
        }
 
        // Normalization template names by removing keywords when they appear as template argument
        // prefixes instead of as part of a longer identifier.
        GAIA_FOR(NSubstrings) {
          const auto* str = to_remove[i];
          const auto len = to_remove_len[i];
 
          auto* pos = nameTmp;
          while ((pos = strstr(pos, str)) != nullptr) {
            const bool isBoundary = pos == nameTmp || pos[-1] == '<' || pos[-1] == ',' || pos[-1] == ' ';
            if (!isBoundary) {
              ++pos;
              continue;
            }
 
            const auto tailMaxLen = (size_t)(MaxNameLength - (uint32_t)(pos + len - nameTmp));
            memmove(pos, pos + len, GAIA_STRLEN(pos + len, tailMaxLen) + 1);
            nameTmpLen -= len;
          }
        }
 
        return nameTmpLen;
      }
 
      static void init_name(SymbolLookupKey& nameOut, util::str_view nameView) {
        char* name = mem::AllocHelper::alloc<char>(nameView.size() + 1);
        memcpy((void*)name, (const void*)nameView.data(), nameView.size());
        name[nameView.size()] = 0;
        nameOut = SymbolLookupKey(name, nameView.size(), 1);
      }
 
    public:
      template <typename T>
      GAIA_NODISCARD static ComponentCacheItem* create(Entity entity) {
        static_assert(core::is_raw_v<T>);
 
        constexpr auto componentSize = detail::ComponentDesc<T>::size();
        static_assert(
            componentSize < Component::MaxComponentSizeInBytes,
            "Trying to register a component larger than the maximum allowed component size! In the future this "
            "restriction won't apply to components not stored inside archetype chunks.");
 
        char nameTmp[MaxNameLength];
        const auto nameTmpLen = init_type_name<T>(nameTmp);
 
        uint8_t soaSizes[meta::StructToTupleMaxTypes]{};
        const auto desc = detail::ComponentDesc<T>::make(
            util::str_view(nameTmp, nameTmpLen), std::span<uint8_t, meta::StructToTupleMaxTypes>{soaSizes});
        return create(entity, desc);
      }
 
      GAIA_NODISCARD static ComponentCacheItem* create(Entity entity, const ecs::ComponentDesc& desc) {
        GAIA_ASSERT(!desc.name.empty());
        GAIA_ASSERT(desc.name.size() < MaxNameLength);
        GAIA_ASSERT(desc.size < Component::MaxComponentSizeInBytes);
        GAIA_ASSERT((desc.size == 0 && desc.alig == 0) || (desc.alig > 0 && desc.alig < Component::MaxAlignment));
        GAIA_ASSERT(desc.soa <= meta::StructToTupleMaxTypes);
 
        auto* cci = new ComponentCacheItem();
        cci->entity = entity;
        cci->comp = Component(entity.id(), desc.soa, desc.size, desc.alig, desc.storageType);
        cci->hashLookup = desc.hashLookup.hash != 0
                              ? desc.hashLookup
                              : ComponentLookupHash{core::calculate_hash64(desc.name.data(), desc.name.size())};
 
        if (desc.soa > 0 && desc.pSoaSizes != nullptr) {
          GAIA_FOR(desc.soa) cci->soaSizes[i] = desc.pSoaSizes[i];
        }
 
        init_name(cci->name, desc.name);
 
        cci->func_ctor = desc.funcCtor;
        cci->func_move_ctor = desc.funcMoveCtor;
        cci->func_copy_ctor = desc.funcCopyCtor;
        cci->func_dtor = desc.funcDtor;
        cci->func_copy = desc.funcCopy;
        cci->func_move = desc.funcMove;
        cci->func_swap = desc.funcSwap;
        cci->func_cmp = desc.funcCmp;
        cci->func_save = desc.funcSave;
        cci->func_load = desc.funcLoad;
        cci->typeKind = desc.typeKind;
        cci->primitiveKind = desc.primitiveKind;
 
        return cci;
      }
 
      GAIA_NODISCARD static ComponentCacheItem* create(Entity entity, const ComponentCacheItemCtx& ctx) {
        ecs::ComponentDesc desc{};
        desc.name = ctx.name;
        desc.size = ctx.size;
        desc.alig = ctx.alig;
        desc.storageType = ctx.storageType;
        desc.soa = ctx.soa;
        desc.pSoaSizes = ctx.pSoaSizes;
        desc.hashLookup = ctx.hashLookup;
        desc.typeKind = ctx.typeKind;
        desc.primitiveKind = ctx.primitiveKind;
        desc.funcCtor = ctx.funcCtor;
        desc.funcMoveCtor = ctx.funcMoveCtor;
        desc.funcCopyCtor = ctx.funcCopyCtor;
        desc.funcDtor = ctx.funcDtor;
        desc.funcCopy = ctx.funcCopy;
        desc.funcMove = ctx.funcMove;
        desc.funcSwap = ctx.funcSwap;
        desc.funcCmp = ctx.funcCmp;
        desc.funcSave = ctx.funcSave;
        desc.funcLoad = ctx.funcLoad;
        return create(entity, desc);
      }
 
      static void destroy(ComponentCacheItem* pItem) {
        if (pItem == nullptr)
          return;
 
        if (pItem->name.str() != nullptr && pItem->name.owned()) {
          mem::AllocHelper::free((void*)pItem->name.str());
          pItem->name = {};
        }
 
        delete pItem;
      }
    };
  } // namespace ecs
} // namespace gaia