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/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 {
      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);
 
      struct SchemaField {
        char name[MaxNameLength]{};
        ser::serialization_type_id type = ser::serialization_type_id::u8;
        uint32_t offset = 0;
        uint32_t size = 0;
      };
 
      struct ComponentCacheItemCtx {
        uint32_t compDescId = 0;
        const char* nameStr = nullptr;
        uint32_t nameLen = 0;
        uint32_t size = 0;
        uint32_t alig = 0;
        DataStorageType storageType = DataStorageType::Table;
        uint32_t soa = 0;
        const uint8_t* pSoaSizes = nullptr;
        ComponentLookupHash hashLookup = {};
        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{};
 
#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<SchemaField> schema;
 
    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);
        }
      }
 
      GAIA_NODISCARD bool set_field(
          const char* fieldName, uint32_t len, ser::serialization_type_id type, uint32_t fieldOffset,
          uint32_t fieldSize) {
        if (fieldName == nullptr || fieldName[0] == 0)
          return false;
 
        const auto fieldLen = len == 0 ? (uint32_t)GAIA_STRLEN(fieldName, MaxNameLength) : len;
        if (fieldLen == 0 || fieldLen >= MaxNameLength)
          return false;
 
        for (auto& f: schema) {
          if (strncmp(f.name, fieldName, fieldLen) == 0 && f.name[fieldLen] == 0) {
            f.type = type;
            f.offset = fieldOffset;
            f.size = fieldSize;
            return true;
          }
        }
 
        SchemaField f{};
        memcpy((void*)f.name, (const void*)fieldName, fieldLen);
        f.name[fieldLen] = 0;
        f.type = type;
        f.offset = fieldOffset;
        f.size = fieldSize;
        schema.push_back(f);
        return true;
      }
 
      void clear_fields() {
        schema.clear();
      }
 
      GAIA_NODISCARD bool has_fields() const {
        return !schema.empty();
      }
 
#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, const char* nameStr, uint32_t nameLen) {
        char* name = mem::AllocHelper::alloc<char>(nameLen + 1);
        memcpy((void*)name, (const void*)nameStr, nameLen);
        name[nameLen] = 0;
        nameOut = SymbolLookupKey(name, nameLen, 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);
 
        ComponentCacheItemCtx ctx{};
        ctx.compDescId = detail::ComponentDesc<T>::id();
        ctx.nameStr = nameTmp;
        ctx.nameLen = nameTmpLen;
        ctx.size = componentSize;
        ctx.alig = detail::ComponentDesc<T>::alig();
        ctx.storageType = DataStorageType::Table;
        uint8_t soaSizes[meta::StructToTupleMaxTypes]{};
        ctx.soa = detail::ComponentDesc<T>::soa(soaSizes);
        ctx.pSoaSizes = soaSizes;
        ctx.hashLookup = detail::ComponentDesc<T>::hash_lookup();
        ctx.funcCtor = detail::ComponentDesc<T>::func_ctor();
        ctx.funcMoveCtor = detail::ComponentDesc<T>::func_move_ctor();
        ctx.funcCopyCtor = detail::ComponentDesc<T>::func_copy_ctor();
        ctx.funcDtor = detail::ComponentDesc<T>::func_dtor();
        ctx.funcCopy = detail::ComponentDesc<T>::func_copy();
        ctx.funcMove = detail::ComponentDesc<T>::func_move();
        ctx.funcSwap = detail::ComponentDesc<T>::func_swap();
        ctx.funcCmp = detail::ComponentDesc<T>::func_cmp();
        ctx.funcSave = detail::ComponentDesc<T>::func_save();
        ctx.funcLoad = detail::ComponentDesc<T>::func_load();
        return create(entity, ctx);
      }
 
      GAIA_NODISCARD static ComponentCacheItem* create(Entity entity, const ComponentCacheItemCtx& ctx) {
        GAIA_ASSERT(ctx.nameStr != nullptr && ctx.nameLen > 0 && ctx.nameLen < MaxNameLength);
        GAIA_ASSERT(ctx.size < Component::MaxComponentSizeInBytes);
        GAIA_ASSERT((ctx.size == 0 && ctx.alig == 0) || (ctx.alig > 0 && ctx.alig < Component::MaxAlignment));
        GAIA_ASSERT(ctx.soa <= meta::StructToTupleMaxTypes);
 
        auto* cci = mem::AllocHelper::alloc<ComponentCacheItem>("ComponentCacheItem");
        (void)new (cci) ComponentCacheItem();
        cci->entity = entity;
        cci->comp = Component(ctx.compDescId, ctx.soa, ctx.size, ctx.alig, ctx.storageType);
        cci->hashLookup = ctx.hashLookup.hash != 0
                              ? ctx.hashLookup
                              : ComponentLookupHash{core::calculate_hash64(ctx.nameStr, ctx.nameLen)};
 
        if (ctx.soa > 0 && ctx.pSoaSizes != nullptr) {
          GAIA_FOR(ctx.soa) cci->soaSizes[i] = ctx.pSoaSizes[i];
        }
 
        init_name(cci->name, ctx.nameStr, ctx.nameLen);
 
        cci->func_ctor = ctx.funcCtor;
        cci->func_move_ctor = ctx.funcMoveCtor;
        cci->func_copy_ctor = ctx.funcCopyCtor;
        cci->func_dtor = ctx.funcDtor;
        cci->func_copy = ctx.funcCopy;
        cci->func_move = ctx.funcMove;
        cci->func_swap = ctx.funcSwap;
        cci->func_cmp = ctx.funcCmp;
        cci->func_save = ctx.funcSave;
        cci->func_load = ctx.funcLoad;
 
        return cci;
      }
 
      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 = {};
        }
 
        pItem->~ComponentCacheItem();
        mem::AllocHelper::free("ComponentCacheItem", pItem);
      }
    };
  } // namespace ecs
} // namespace gaia