chunk_iterator.h

#pragma once
#include "gaia/config/config.h"
 
#include <cinttypes>
#include <cstdint>
#include <type_traits>
 
#include "gaia/ecs/api.h"
#include "gaia/ecs/archetype.h"
#include "gaia/ecs/chunk.h"
#include "gaia/ecs/command_buffer_fwd.h"
#include "gaia/ecs/component.h"
#include "gaia/ecs/component_cache_item.h"
#include "gaia/ecs/id.h"
#include "gaia/ecs/query_common.h"
#include "gaia/mem/data_layout_policy.h"
 
namespace gaia {
  namespace ecs {
    class World;
 
    enum class Constraints : uint8_t { EnabledOnly, DisabledOnly, AcceptAll };
 
    namespace detail {
      template <Constraints IterConstraint>
      class ChunkIterImpl {
      protected:
        using CompIndicesBitView = core::bit_view<ChunkHeader::MAX_COMPONENTS_BITS>;
 
        const World* m_pWorld = nullptr;
        const Archetype* m_pArchetype = nullptr;
        Chunk* m_pChunk = nullptr;
        const uint8_t* m_pCompIdxMapping = nullptr;
        uint16_t m_from;
        uint16_t m_to;
        GroupId m_groupId = 0;
 
      public:
        ChunkIterImpl() = default;
        ~ChunkIterImpl() = default;
        ChunkIterImpl(ChunkIterImpl&&) noexcept = default;
        ChunkIterImpl& operator=(ChunkIterImpl&&) noexcept = default;
        ChunkIterImpl(const ChunkIterImpl&) = delete;
        ChunkIterImpl& operator=(const ChunkIterImpl&) = delete;
 
        void set_world(const World* pWorld) {
          GAIA_ASSERT(pWorld != nullptr);
          m_pWorld = pWorld;
        }
 
        GAIA_NODISCARD World* world() {
          GAIA_ASSERT(m_pWorld != nullptr);
          return const_cast<World*>(m_pWorld);
        }
 
        GAIA_NODISCARD const World* world() const {
          GAIA_ASSERT(m_pWorld != nullptr);
          return m_pWorld;
        }
 
        void set_archetype(const Archetype* pArchetype) {
          GAIA_ASSERT(pArchetype != nullptr);
          m_pArchetype = pArchetype;
        }
 
        // GAIA_NODISCARD Archetype* archetype() {
        //  GAIA_ASSERT(m_pArchetype != nullptr);
        //  return m_pArchetype;
        // }
 
        GAIA_NODISCARD const Archetype* archetype() const {
          GAIA_ASSERT(m_pArchetype != nullptr);
          return m_pArchetype;
        }
 
        void set_chunk(Chunk* pChunk) {
          GAIA_ASSERT(pChunk != nullptr);
          m_pChunk = pChunk;
 
          if constexpr (IterConstraint == Constraints::EnabledOnly)
            m_from = m_pChunk->size_disabled();
          else
            m_from = 0;
 
          if constexpr (IterConstraint == Constraints::DisabledOnly)
            m_to = m_pChunk->size_disabled();
          else
            m_to = m_pChunk->size();
        }
 
        void set_chunk(Chunk* pChunk, uint16_t from, uint16_t to) {
          if (from == 0 && to == 0) {
            set_chunk(pChunk);
            return;
          }
 
          GAIA_ASSERT(pChunk != nullptr);
          m_pChunk = pChunk;
          m_from = from;
          m_to = to;
        }
 
        GAIA_NODISCARD const Chunk* chunk() const {
          GAIA_ASSERT(m_pChunk != nullptr);
          return m_pChunk;
        }
 
        void set_remapping_indices(const uint8_t* pCompIndicesMapping) {
          m_pCompIdxMapping = pCompIndicesMapping;
        }
 
        void set_group_id(GroupId groupId) {
          m_groupId = groupId;
        }
 
        GAIA_NODISCARD GroupId group_id() const {
          return m_groupId;
        }
 
        GAIA_NODISCARD CommandBufferST& cmd_buffer_st() const {
          auto* pWorld = const_cast<World*>(m_pWorld);
          return cmd_buffer_st_get(*pWorld);
        }
 
        GAIA_NODISCARD CommandBufferMT& cmd_buffer_mt() const {
          auto* pWorld = const_cast<World*>(m_pWorld);
          return cmd_buffer_mt_get(*pWorld);
        }
 
        template <typename T>
        GAIA_NODISCARD auto view() const {
          return m_pChunk->view<T>(from(), to());
        }
 
        template <typename T>
        GAIA_NODISCARD auto view(uint32_t termIdx) {
          using U = typename actual_type_t<T>::Type;
 
          const auto compIdx = m_pCompIdxMapping[termIdx];
          GAIA_ASSERT(compIdx < m_pChunk->ids_view().size());
 
          if constexpr (mem::is_soa_layout_v<U>) {
            auto* pData = m_pChunk->comp_ptr_mut(compIdx);
            return m_pChunk->view_raw<T>(pData, m_pChunk->capacity());
          } else {
            auto* pData = m_pChunk->comp_ptr_mut(compIdx, from());
            return m_pChunk->view_raw<T>(pData, to() - from());
          }
        }
 
        template <typename T>
        GAIA_NODISCARD auto view_mut() {
          return m_pChunk->view_mut<T>(from(), to());
        }
 
        template <typename T>
        GAIA_NODISCARD auto view_mut(uint32_t termIdx) {
          using U = typename actual_type_t<T>::Type;
 
          const auto compIdx = m_pCompIdxMapping[termIdx];
          GAIA_ASSERT(compIdx < m_pChunk->comp_rec_view().size());
 
          m_pChunk->update_world_version(compIdx);
 
          if constexpr (mem::is_soa_layout_v<U>) {
            auto* pData = m_pChunk->comp_ptr_mut(compIdx);
            return m_pChunk->view_mut_raw<T>(pData, m_pChunk->capacity());
          } else {
            auto* pData = m_pChunk->comp_ptr_mut(compIdx, from());
            return m_pChunk->view_mut_raw<T>(pData, to() - from());
          }
        }
 
        template <typename T>
        GAIA_NODISCARD auto sview_mut() {
          return m_pChunk->sview_mut<T>(from(), to());
        }
 
        template <typename T>
        GAIA_NODISCARD auto sview_mut(uint32_t termIdx) {
          using U = typename actual_type_t<T>::Type;
 
          const auto compIdx = m_pCompIdxMapping[termIdx];
          GAIA_ASSERT(compIdx < m_pChunk->ids_view().size());
 
          if constexpr (mem::is_soa_layout_v<U>) {
            auto* pData = m_pChunk->comp_ptr_mut(compIdx);
            return m_pChunk->view_mut_raw<T>(pData, m_pChunk->capacity());
          } else {
            auto* pData = m_pChunk->comp_ptr_mut(compIdx, from());
            return m_pChunk->view_mut_raw<T>(pData, to() - from());
          }
        }
 
        template <typename T, bool TriggerHooks>
        void modify() {
          m_pChunk->modify<T, TriggerHooks>();
        }
 
        template <typename T>
        GAIA_NODISCARD auto view_auto() {
          return m_pChunk->view_auto<T>(from(), to());
        }
 
        template <typename T>
        GAIA_NODISCARD auto sview_auto() {
          return m_pChunk->sview_auto<T>(from(), to());
        }
 
        GAIA_NODISCARD bool enabled(uint32_t index) const {
          const auto row = (uint16_t)(from() + index);
          return m_pChunk->enabled(row);
        }
 
        GAIA_NODISCARD bool has(Entity entity) const {
          return m_pChunk->has(entity);
        }
 
        GAIA_NODISCARD bool has(Pair pair) const {
          return m_pChunk->has((Entity)pair);
        }
 
        template <typename T>
        GAIA_NODISCARD bool has() const {
          return m_pChunk->has<T>();
        }
 
        GAIA_NODISCARD static uint16_t start_index(Chunk* pChunk) noexcept {
          if constexpr (IterConstraint == Constraints::EnabledOnly)
            return pChunk->size_disabled();
          else
            return 0;
        }
 
        GAIA_NODISCARD static uint16_t end_index(Chunk* pChunk) noexcept {
          if constexpr (IterConstraint == Constraints::DisabledOnly)
            return pChunk->size_enabled();
          else
            return pChunk->size();
        }
 
        GAIA_NODISCARD static uint16_t size(Chunk* pChunk) noexcept {
          if constexpr (IterConstraint == Constraints::EnabledOnly)
            return pChunk->size_enabled();
          else if constexpr (IterConstraint == Constraints::DisabledOnly)
            return pChunk->size_disabled();
          else
            return pChunk->size();
        }
 
        GAIA_NODISCARD uint16_t size() const noexcept {
          return size(m_pChunk);
        }
 
        template <typename T>
        uint32_t acc_index(uint32_t idx) const noexcept {
          using U = typename actual_type_t<T>::Type;
 
          if constexpr (mem::is_soa_layout_v<U>)
            return idx + from();
          else
            return idx;
        }
 
      protected:
        GAIA_NODISCARD uint16_t from() const noexcept {
          return m_from;
        }
 
        GAIA_NODISCARD uint16_t to() const noexcept {
          return m_to;
        }
      };
    } // namespace detail
 
    class GAIA_API Iter final: public detail::ChunkIterImpl<Constraints::EnabledOnly> {};
    class GAIA_API IterDisabled final: public detail::ChunkIterImpl<Constraints::DisabledOnly> {};
 
    class GAIA_API IterAll final: public detail::ChunkIterImpl<Constraints::AcceptAll> {
    public:
      GAIA_NODISCARD uint16_t size_enabled() const noexcept {
        return m_pChunk->size_enabled();
      }
 
      GAIA_NODISCARD uint16_t size_disabled() const noexcept {
        return m_pChunk->size_disabled();
      }
    };
 
    class GAIA_API CopyIter final {
    protected:
      using CompIndicesBitView = core::bit_view<ChunkHeader::MAX_COMPONENTS_BITS>;
 
      const World* m_pWorld = nullptr;
      const Archetype* m_pArchetype = nullptr;
      Chunk* m_pChunk = nullptr;
      uint16_t m_from;
      uint16_t m_cnt;
 
    public:
      CopyIter() = default;
      ~CopyIter() = default;
      CopyIter(CopyIter&&) noexcept = default;
      CopyIter& operator=(CopyIter&&) noexcept = default;
      CopyIter(const CopyIter&) = delete;
      CopyIter& operator=(const CopyIter&) = delete;
 
      void set_range(uint16_t from, uint16_t cnt) {
        GAIA_ASSERT(from < m_pChunk->size());
        GAIA_ASSERT(from + cnt <= m_pChunk->size());
        m_from = from;
        m_cnt = cnt;
      }
 
      void set_world(const World* pWorld) {
        GAIA_ASSERT(pWorld != nullptr);
        m_pWorld = pWorld;
      }
 
      GAIA_NODISCARD World* world() {
        GAIA_ASSERT(m_pWorld != nullptr);
        return const_cast<World*>(m_pWorld);
      }
 
      GAIA_NODISCARD const World* world() const {
        GAIA_ASSERT(m_pWorld != nullptr);
        return m_pWorld;
      }
 
      void set_archetype(const Archetype* pArchetype) {
        GAIA_ASSERT(pArchetype != nullptr);
        m_pArchetype = pArchetype;
      }
 
      // GAIA_NODISCARD Archetype* archetype() {
      //  GAIA_ASSERT(m_pArchetype != nullptr);
      //  return m_pArchetype;
      // }
 
      GAIA_NODISCARD const Archetype* archetype() const {
        GAIA_ASSERT(m_pArchetype != nullptr);
        return m_pArchetype;
      }
 
      void set_chunk(Chunk* pChunk) {
        GAIA_ASSERT(pChunk != nullptr);
        m_pChunk = pChunk;
      }
 
      GAIA_NODISCARD const Chunk* chunk() const {
        GAIA_ASSERT(m_pChunk != nullptr);
        return m_pChunk;
      }
 
      GAIA_NODISCARD CommandBufferST& cmd_buffer_st() const {
        auto* pWorld = const_cast<World*>(m_pWorld);
        return cmd_buffer_st_get(*pWorld);
      }
 
      GAIA_NODISCARD CommandBufferMT& cmd_buffer_mt() const {
        auto* pWorld = const_cast<World*>(m_pWorld);
        return cmd_buffer_mt_get(*pWorld);
      }
 
      template <typename T>
      GAIA_NODISCARD auto view() const {
        return m_pChunk->view<T>(from(), to());
      }
 
      template <typename T>
      GAIA_NODISCARD auto view_mut() {
        return m_pChunk->view_mut<T>(from(), to());
      }
 
      template <typename T>
      GAIA_NODISCARD auto sview_mut() {
        return m_pChunk->sview_mut<T>(from(), to());
      }
 
      template <typename T, bool TriggerHooks>
      void modify() {
        m_pChunk->modify<T, TriggerHooks>();
      }
 
      template <typename T>
      GAIA_NODISCARD auto view_auto() {
        return m_pChunk->view_auto<T>(from(), to());
      }
 
      template <typename T>
      GAIA_NODISCARD auto sview_auto() {
        return m_pChunk->sview_auto<T>(from(), to());
      }
 
      GAIA_NODISCARD bool enabled(uint32_t index) const {
        const auto row = (uint16_t)(from() + index);
        return m_pChunk->enabled(row);
      }
 
      GAIA_NODISCARD bool has(Entity entity) const {
        return m_pChunk->has(entity);
      }
 
      GAIA_NODISCARD bool has(Pair pair) const {
        return m_pChunk->has((Entity)pair);
      }
 
      template <typename T>
      GAIA_NODISCARD bool has() const {
        return m_pChunk->has<T>();
      }
 
      GAIA_NODISCARD uint16_t size() const noexcept {
        return m_cnt;
      }
 
    private:
      GAIA_NODISCARD uint16_t from() const noexcept {
        return m_from;
      }
 
      GAIA_NODISCARD uint16_t to() const noexcept {
        return m_from + m_cnt;
      }
    };
  } // namespace ecs
} // namespace gaia