component_desc.h

#pragma once
#include "gaia/config/config.h"
 
#include <cstdint>
#include <cstring>
#include <tuple>
#include <type_traits>
 
#include "gaia/core/span.h"
#include "gaia/core/utility.h"
#include "gaia/ecs/component.h"
#include "gaia/mem/data_layout_policy.h"
#include "gaia/mem/mem_utils.h"
#include "gaia/meta/reflection.h"
#include "gaia/meta/type_info.h"
#include "gaia/ser/ser_rt.h"
#include "gaia/util/str.h"
 
namespace gaia {
  namespace ecs {
    enum class RuntimeTypeKind : uint8_t {
      None,
      Primitive,
      Struct,
    };
 
    enum class RuntimePrimitiveKind : uint8_t {
      None,
      Bool,
      S8,
      U8,
      S16,
      U16,
      S32,
      U32,
      S64,
      U64,
      Char8,
      Char16,
      Char32,
      WChar,
      F8,
      F16,
      F32,
      F64,
      F128,
    };
 
    struct RuntimeFieldDesc final {
      util::str_view name{};
      Entity type = EntityBad;
      uint32_t offset = 0;
      uint32_t count = 0;
    };
 
    struct RuntimeField final {
      char name[256]{};
      Entity type = EntityBad;
      uint32_t offset = 0;
      uint32_t count = 0;
    };
 
    struct ComponentDesc final {
      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);
 
      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;
    };
 
    namespace detail {
      template <typename T>
      struct ComponentDesc final {
        using CT = component_type_t<T>;
        using U = typename component_type_t<T>::Type;
        using DescU = typename CT::TypeFull;
 
        static constexpr ComponentLookupHash hash_lookup() {
          return {meta::type_info::hash<DescU>()};
        }
 
        static constexpr auto name() {
          return meta::type_info::name<DescU>();
        }
 
        static constexpr uint32_t size() {
          if constexpr (std::is_empty_v<U>)
            return 0;
          else
            return (uint32_t)sizeof(U);
        }
 
        static constexpr uint32_t alig() {
          constexpr auto alig = mem::auto_view_policy<U>::Alignment;
          static_assert(alig < Component::MaxAlignment, "Maximum supported alignment for a component is MaxAlignment");
          return alig;
        }
 
        static uint32_t soa(std::span<uint8_t, meta::StructToTupleMaxTypes> soaSizes) {
          if constexpr (mem::is_soa_layout_v<U>) {
            uint32_t i = 0;
            using TTuple = decltype(meta::struct_to_tuple(std::declval<U>()));
            // is_soa_layout_v is always false for empty types so we know there is at least one element in the tuple
            constexpr auto TTupleSize = std::tuple_size_v<TTuple>;
            static_assert(TTupleSize > 0);
            static_assert(TTupleSize <= meta::StructToTupleMaxTypes);
            core::each_tuple<TTuple>([&](auto&& item) {
              static_assert(sizeof(item) <= 255, "Each member of a SoA component can be at most 255 B long!");
              soaSizes[i] = (uint8_t)sizeof(item);
              ++i;
            });
            GAIA_ASSERT(i <= meta::StructToTupleMaxTypes);
            return i;
          } else {
            return 0U;
          }
        }
 
        static constexpr auto func_ctor() {
          if constexpr (!mem::is_soa_layout_v<U> && !std::is_trivially_constructible_v<U>) {
            return [](void* ptr, uint32_t cnt) {
              core::call_ctor_n((U*)ptr, cnt);
            };
          } else {
            return nullptr;
          }
        }
 
        static constexpr auto func_dtor() {
          if constexpr (!mem::is_soa_layout_v<U> && !std::is_trivially_destructible_v<U>) {
            return [](void* ptr, uint32_t cnt) {
              core::call_dtor_n((U*)ptr, cnt);
            };
          } else {
            return nullptr;
          }
        }
 
        static constexpr auto func_copy_ctor() {
          return [](void* GAIA_RESTRICT dst, const void* GAIA_RESTRICT src, uint32_t idxDst, uint32_t idxSrc,
                    uint32_t sizeDst, uint32_t sizeSrc) {
            mem::copy_ctor_element<U>((uint8_t*)dst, (const uint8_t*)src, idxDst, idxSrc, sizeDst, sizeSrc);
          };
        }
 
        static constexpr auto func_move_ctor() {
          return [](void* GAIA_RESTRICT dst, void* GAIA_RESTRICT src, uint32_t idxDst, uint32_t idxSrc,
                    uint32_t sizeDst, uint32_t sizeSrc) {
            mem::move_ctor_element<U>((uint8_t*)dst, (uint8_t*)src, idxDst, idxSrc, sizeDst, sizeSrc);
          };
        }
 
        static constexpr auto func_copy() {
          return [](void* GAIA_RESTRICT dst, const void* GAIA_RESTRICT src, uint32_t idxDst, uint32_t idxSrc,
                    uint32_t sizeDst, uint32_t sizeSrc) {
            mem::copy_element<U>((uint8_t*)dst, (const uint8_t*)src, idxDst, idxSrc, sizeDst, sizeSrc);
          };
        }
 
        static constexpr auto func_move() {
          return [](void* GAIA_RESTRICT dst, void* GAIA_RESTRICT src, uint32_t idxDst, uint32_t idxSrc,
                    uint32_t sizeDst, uint32_t sizeSrc) {
            mem::move_element<U>((uint8_t*)dst, (uint8_t*)src, idxDst, idxSrc, sizeDst, sizeSrc);
          };
        }
 
        static constexpr auto func_swap() {
          return [](void* GAIA_RESTRICT left, void* GAIA_RESTRICT right, uint32_t idxLeft, uint32_t idxRight,
                    uint32_t sizeLeft, uint32_t sizeRight) {
            mem::swap_elements<U>((uint8_t*)left, (uint8_t*)right, idxLeft, idxRight, sizeLeft, sizeRight);
          };
        }
 
        static constexpr auto func_cmp() {
          if constexpr (mem::is_soa_layout_v<U>) {
            return []([[maybe_unused]] const void* left, [[maybe_unused]] const void* right) {
              GAIA_ASSERT(false && "func_cmp for SoA not implemented yet");
              return false;
            };
          } else {
            constexpr bool hasGlobalCmp = core::has_ffunc_equals<U>::value;
            constexpr bool hasMemberCmp = core::has_func_equals<U>::value;
            if constexpr (hasGlobalCmp || hasMemberCmp) {
              return [](const void* left, const void* right) {
                const auto* l = (const U*)left;
                const auto* r = (const U*)right;
                return *l == *r;
              };
            } else {
              // fallback comparison function
              return [](const void* left, const void* right) {
                const auto* l = (const U*)left;
                const auto* r = (const U*)right;
                return memcmp(l, r, sizeof(U)) == 0;
              };
            }
          }
        }
 
        static constexpr auto func_save() {
          return [](ser::serializer& s, const void* pSrc, uint32_t from, uint32_t to, uint32_t cap) {
            const auto* pComponent = (const U*)pSrc;
 
#if GAIA_ASSERT_ENABLED
            // Check if save and load match. Testing with one item is enough.
            s.check(*pComponent);
#endif
 
            if constexpr (mem::is_soa_layout_v<U>) {
              auto view = mem::auto_view_policy_get<U>{std::span{(const uint8_t*)pSrc, cap}};
              GAIA_FOR2(from, to) {
                auto val = view[i];
                s.save(val);
              }
            } else {
              pComponent += from;
              GAIA_FOR2(from, to) {
                s.save(*pComponent);
                ++pComponent;
              }
            }
          };
        }
 
        static constexpr auto func_load() {
          return [](ser::serializer& s, void* pDst, uint32_t from, uint32_t to, uint32_t cap) {
            if constexpr (mem::is_soa_layout_v<U>) {
              auto view = mem::auto_view_policy_set<U>{std::span{(uint8_t*)pDst, cap}};
              GAIA_FOR2(from, to) {
                U val;
                s.load(val);
                view[i] = val;
              }
            } else {
              auto* pComponent = (U*)pDst + from;
              GAIA_FOR2(from, to) {
                s.load(*pComponent);
                ++pComponent;
              }
            }
          };
        }
 
        static ecs::ComponentDesc
        make(util::str_view descName, std::span<uint8_t, meta::StructToTupleMaxTypes> soaSizes) {
          ecs::ComponentDesc desc{};
          desc.name = descName;
          desc.size = size();
          desc.alig = alig();
          desc.storageType = DataStorageType::Table;
          desc.soa = soa(soaSizes);
          desc.pSoaSizes = soaSizes.data();
          desc.hashLookup = hash_lookup();
          desc.funcCtor = func_ctor();
          desc.funcMoveCtor = func_move_ctor();
          desc.funcCopyCtor = func_copy_ctor();
          desc.funcDtor = func_dtor();
          desc.funcCopy = func_copy();
          desc.funcMove = func_move();
          desc.funcSwap = func_swap();
          desc.funcCmp = func_cmp();
          desc.funcSave = func_save();
          desc.funcLoad = func_load();
          return desc;
        }
      };
    } // namespace detail
  } // namespace ecs
} // namespace gaia