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;
    void world_finish_write(World& world, Entity term, Entity entity);
    template <typename T>
    decltype(auto) world_query_entity_arg_by_id_raw(World& world, Entity entity, Entity id);
    template <typename T>
    decltype(auto) world_query_entity_arg_by_id_cached_const(
        World& world, Entity entity, Entity id, const Archetype*& pLastArchetype, Entity& cachedOwner,
        bool& cachedDirect);
    template <typename T>
    void world_init_query_entity_arg_by_id_chunk_stable_const(
        World& world, const Chunk& chunk, const Entity* pEntities, Entity id, bool& direct, uint32_t& compIdx,
        const std::remove_cv_t<std::remove_reference_t<T>>*& pDataInherited);
    template <typename T>
    const std::remove_cv_t<std::remove_reference_t<T>>*
    world_query_inherited_arg_data_const(World& world, Entity owner, Entity id);
    bool world_term_uses_inherit_policy(const World& world, Entity term);
    template <typename T>
    Entity world_query_arg_id(World& world);
 
    enum class Constraints : uint8_t { EnabledOnly, DisabledOnly, AcceptAll };
 
    namespace detail {
      struct BfsChunkRun {
        const Archetype* pArchetype = nullptr;
        Chunk* pChunk = nullptr;
        uint16_t from = 0;
        uint16_t to = 0;
        uint32_t offset = 0;
      };
 
      template <typename U>
      struct EntityTermViewGetPointer {
        const U* pData = nullptr;
        uint32_t cnt = 0;
 
        GAIA_NODISCARD decltype(auto) operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          return pData[idx];
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
 
        GAIA_NODISCARD const U* data() const noexcept {
          return pData;
        }
      };
 
      template <typename U>
      struct EntityTermViewGetEntity {
        const Entity* pEntities = nullptr;
        World* pWorld = nullptr;
        Entity id = EntityBad;
        uint32_t cnt = 0;
        mutable const Archetype* pLastArchetype = nullptr;
        mutable Entity cachedOwner = EntityBad;
        mutable bool cachedDirect = false;
 
        GAIA_NODISCARD decltype(auto) operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          return world_query_entity_arg_by_id_cached_const<const U&>(
              *pWorld, pEntities[idx], id, pLastArchetype, cachedOwner, cachedDirect);
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
 
        GAIA_NODISCARD const U* data() const noexcept {
          return nullptr;
        }
      };
 
      template <typename U>
      struct EntityTermViewSetPointer {
        U* pData = nullptr;
        uint32_t cnt = 0;
 
        GAIA_NODISCARD decltype(auto) operator[](size_t idx) {
          GAIA_ASSERT(idx < cnt);
          return pData[idx];
        }
 
        GAIA_NODISCARD decltype(auto) operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          return static_cast<const U&>(pData[idx]);
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
 
        GAIA_NODISCARD U* data() noexcept {
          return pData;
        }
 
        GAIA_NODISCARD const U* data() const noexcept {
          return pData;
        }
      };
 
      template <typename U, bool WriteIm>
      struct EntityTermViewSetEntity {
        const Entity* pEntities = nullptr;
        World* pWorld = nullptr;
        Entity id = EntityBad;
        uint32_t cnt = 0;
 
        GAIA_NODISCARD decltype(auto) operator[](size_t idx) {
          GAIA_ASSERT(idx < cnt);
          if constexpr (WriteIm)
            return world_query_entity_arg_by_id<U&>(*pWorld, pEntities[idx], id);
          else
            return world_query_entity_arg_by_id_raw<U&>(*pWorld, pEntities[idx], id);
        }
 
        GAIA_NODISCARD decltype(auto) operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          return world_query_entity_arg_by_id<const U&>(*pWorld, pEntities[idx], id);
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
 
        GAIA_NODISCARD U* data() noexcept {
          return nullptr;
        }
 
        GAIA_NODISCARD const U* data() const noexcept {
          return nullptr;
        }
      };
 
      template <typename U>
      struct EntityTermViewGet {
        const U* pData = nullptr;
        const Entity* pEntities = nullptr;
        World* pWorld = nullptr;
        Entity id = EntityBad;
        uint32_t cnt = 0;
        const U* pDataInherited = nullptr;
        mutable const Archetype* pLastArchetype = nullptr;
        mutable Entity cachedOwner = EntityBad;
        mutable bool cachedDirect = false;
 
        static EntityTermViewGet pointer(const U* pData, uint32_t cnt) {
          return {pData, nullptr, nullptr, EntityBad, cnt, nullptr, nullptr, EntityBad, false};
        }
 
        static EntityTermViewGet entity(const Entity* pEntities, World* pWorld, Entity id, uint32_t cnt) {
          return {nullptr, pEntities, pWorld, id, cnt, nullptr, nullptr, EntityBad, false};
        }
 
        static EntityTermViewGet inherited(const U* pDataInherited, uint32_t cnt) {
          return {nullptr, nullptr, nullptr, EntityBad, cnt, pDataInherited, nullptr, EntityBad, false};
        }
 
        static EntityTermViewGet entity_chunk_stable(
            const Entity* pEntities, const Chunk* pChunk, World* pWorld, Entity id, uint16_t rowBase, uint32_t cnt) {
          uint32_t compIdx = BadIndex;
          const U* pDataInherited = nullptr;
          bool direct = false;
          world_init_query_entity_arg_by_id_chunk_stable_const<U>(
              *pWorld, *pChunk, pEntities, id, direct, compIdx, pDataInherited);
          const U* pData = nullptr;
          if (direct)
            pData = reinterpret_cast<const U*>(pChunk->comp_ptr(compIdx, rowBase));
 
          return {pData, nullptr, pWorld, id, cnt, pDataInherited, nullptr, EntityBad, false};
        }
 
        GAIA_NODISCARD decltype(auto) operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          if (pData != nullptr)
            return pData[idx];
          if (pDataInherited != nullptr) {
            GAIA_ASSERT(pDataInherited != nullptr);
            return *pDataInherited;
          }
 
          return world_query_entity_arg_by_id_cached_const<const U&>(
              *pWorld, pEntities[idx], id, pLastArchetype, cachedOwner, cachedDirect);
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
 
        GAIA_NODISCARD const U* data() const noexcept {
          return pData;
        }
      };
 
      template <typename U>
      struct EntityTermViewSet {
        U* pData = nullptr;
        const Entity* pEntities = nullptr;
        World* pWorld = nullptr;
        Entity id = EntityBad;
        uint32_t cnt = 0;
        bool writeIm = true;
 
        static EntityTermViewSet pointer(U* pData, uint32_t cnt) {
          return {pData, nullptr, nullptr, EntityBad, cnt, true};
        }
 
        static EntityTermViewSet
        entity(const Entity* pEntities, World* pWorld, Entity id, uint32_t cnt, bool writeIm = true) {
          return {nullptr, pEntities, pWorld, id, cnt, writeIm};
        }
 
        GAIA_NODISCARD decltype(auto) operator[](size_t idx) {
          GAIA_ASSERT(idx < cnt);
          if (pData != nullptr)
            return pData[idx];
 
          if (writeIm)
            return EntityTermViewSetEntity<U, true>{pEntities, pWorld, id, cnt}[idx];
          return EntityTermViewSetEntity<U, false>{pEntities, pWorld, id, cnt}[idx];
        }
 
        GAIA_NODISCARD decltype(auto) operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          if (pData != nullptr)
            return static_cast<const U&>(pData[idx]);
 
          return world_query_entity_arg_by_id<const U&>(*pWorld, pEntities[idx], id);
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
 
        GAIA_NODISCARD U* data() noexcept {
          return pData;
        }
 
        GAIA_NODISCARD const U* data() const noexcept {
          return pData;
        }
      };
 
      template <typename U>
      struct SoATermRowWriteProxyPointer {
        using raw_view_policy = mem::data_view_policy_soa<U::gaia_Data_Layout, U>;
 
        uint8_t* pData = nullptr;
        uint32_t dataSize = 0;
        uint32_t idx = 0;
 
        GAIA_NODISCARD operator U() const {
          return raw_view_policy::get(std::span<const uint8_t>{pData, dataSize}, idx);
        }
 
        SoATermRowWriteProxyPointer& operator=(const U& value) {
          raw_view_policy::set(std::span<uint8_t>{pData, dataSize}, idx) = value;
          return *this;
        }
      };
 
      template <typename U, bool WriteIm>
      struct SoATermRowWriteProxyEntity {
        const Entity* pEntities = nullptr;
        World* pWorld = nullptr;
        Entity id = EntityBad;
        uint32_t idx = 0;
 
        GAIA_NODISCARD operator U() const {
          return world_query_entity_arg_by_id<const U&>(*pWorld, pEntities[idx], id);
        }
 
        SoATermRowWriteProxyEntity& operator=(const U& value) {
          if constexpr (WriteIm)
            world_query_entity_arg_by_id<U&>(*pWorld, pEntities[idx], id) = value;
          else
            world_query_entity_arg_by_id_raw<U&>(*pWorld, pEntities[idx], id) = value;
          return *this;
        }
      };
 
      template <typename U, size_t Item>
      struct SoATermFieldReadProxyPointer {
        using view_policy = mem::data_view_policy_soa_get<U::gaia_Data_Layout, U>;
        using value_type = typename view_policy::template data_view_policy_idx_info<Item>::const_value_type;
 
        const value_type* pData = nullptr;
        uint32_t cnt = 0;
 
        GAIA_NODISCARD value_type operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          return pData[idx];
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
      };
 
      template <typename U, size_t Item>
      struct SoATermFieldReadProxyEntity {
        using view_policy = mem::data_view_policy_soa_get<U::gaia_Data_Layout, U>;
        using value_type = typename view_policy::template data_view_policy_idx_info<Item>::const_value_type;
 
        const Entity* pEntities = nullptr;
        World* pWorld = nullptr;
        Entity id = EntityBad;
        uint32_t cnt = 0;
 
        GAIA_NODISCARD value_type operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          const U value = world_query_entity_arg_by_id<const U&>(*pWorld, pEntities[idx], id);
          return std::get<Item>(meta::struct_to_tuple(value));
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
      };
 
      template <typename U, size_t Item>
      struct SoATermFieldWriteProxyPointer {
        using view_policy = mem::data_view_policy_soa_set<U::gaia_Data_Layout, U>;
        using value_type = typename view_policy::template data_view_policy_idx_info<Item>::value_type;
 
        value_type* pData = nullptr;
        uint32_t cnt = 0;
 
        GAIA_NODISCARD value_type& operator[](size_t idx) {
          GAIA_ASSERT(idx < cnt);
          return pData[idx];
        }
 
        GAIA_NODISCARD const value_type& operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          return pData[idx];
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
      };
 
      template <typename U, size_t Item, bool WriteIm>
      struct SoATermFieldWriteProxyEntity {
        using view_policy = mem::data_view_policy_soa_set<U::gaia_Data_Layout, U>;
        using value_type = typename view_policy::template data_view_policy_idx_info<Item>::value_type;
 
        struct ElementProxy {
          const Entity* pEntities = nullptr;
          World* pWorld = nullptr;
          Entity id = EntityBad;
          uint32_t idx = 0;
 
          GAIA_NODISCARD operator value_type() const {
            const U value = world_query_entity_arg_by_id<const U&>(*pWorld, pEntities[idx], id);
            return std::get<Item>(meta::struct_to_tuple(value));
          }
 
          ElementProxy& operator=(const value_type& value) {
            auto data = world_query_entity_arg_by_id<const U&>(*pWorld, pEntities[idx], id);
            auto tuple = meta::struct_to_tuple(data);
            std::get<Item>(tuple) = value;
            if constexpr (WriteIm)
              world_query_entity_arg_by_id<U&>(*pWorld, pEntities[idx], id) = meta::tuple_to_struct<U>(GAIA_MOV(tuple));
            else
              world_query_entity_arg_by_id_raw<U&>(*pWorld, pEntities[idx], id) =
                  meta::tuple_to_struct<U>(GAIA_MOV(tuple));
            return *this;
          }
 
          template <typename V>
          ElementProxy& operator+=(V&& value) {
            const value_type current = operator value_type();
            return operator=(current + GAIA_FWD(value));
          }
 
          template <typename V>
          ElementProxy& operator-=(V&& value) {
            const value_type current = operator value_type();
            return operator=(current - GAIA_FWD(value));
          }
 
          template <typename V>
          ElementProxy& operator*=(V&& value) {
            const value_type current = operator value_type();
            return operator=(current * GAIA_FWD(value));
          }
 
          template <typename V>
          ElementProxy& operator/=(V&& value) {
            const value_type current = operator value_type();
            return operator=(current / GAIA_FWD(value));
          }
        };
 
        const Entity* pEntities = nullptr;
        World* pWorld = nullptr;
        Entity id = EntityBad;
        uint32_t cnt = 0;
 
        GAIA_NODISCARD ElementProxy operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          return ElementProxy{pEntities, pWorld, id, (uint32_t)idx};
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
      };
 
      template <typename U>
      struct SoATermViewGetPointer {
        using raw_view_policy = mem::data_view_policy_soa<U::gaia_Data_Layout, U>;
        using read_view_policy = mem::data_view_policy_soa_get<U::gaia_Data_Layout, U>;
 
        const uint8_t* pData = nullptr;
        uint32_t dataSize = 0;
        uint32_t idxBase = 0;
        uint32_t cnt = 0;
 
        GAIA_NODISCARD U operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          return raw_view_policy::get(std::span<const uint8_t>{pData, dataSize}, idxBase + idx);
        }
 
        template <size_t Item>
        GAIA_NODISCARD auto get() const {
          const auto field = read_view_policy{std::span<const uint8_t>{pData, dataSize}}.template get<Item>();
          return SoATermFieldReadProxyPointer<U, Item>{field.data() + idxBase, cnt};
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
      };
 
      template <typename U>
      struct SoATermViewGetEntity {
        const Entity* pEntities = nullptr;
        World* pWorld = nullptr;
        Entity id = EntityBad;
        uint32_t cnt = 0;
 
        GAIA_NODISCARD U operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          return world_query_entity_arg_by_id<const U&>(*pWorld, pEntities[idx], id);
        }
 
        template <size_t Item>
        GAIA_NODISCARD auto get() const {
          return SoATermFieldReadProxyEntity<U, Item>{pEntities, pWorld, id, cnt};
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
      };
 
      template <typename U>
      struct SoATermViewSetPointer {
        using raw_view_policy = mem::data_view_policy_soa<U::gaia_Data_Layout, U>;
        using read_view_policy = mem::data_view_policy_soa_get<U::gaia_Data_Layout, U>;
        using write_view_policy = mem::data_view_policy_soa_set<U::gaia_Data_Layout, U>;
 
        uint8_t* pData = nullptr;
        uint32_t dataSize = 0;
        uint32_t idxBase = 0;
        uint32_t cnt = 0;
 
        GAIA_NODISCARD auto operator[](size_t idx) {
          GAIA_ASSERT(idx < cnt);
          return SoATermRowWriteProxyPointer<U>{pData, dataSize, idxBase + (uint32_t)idx};
        }
 
        GAIA_NODISCARD U operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          return raw_view_policy::get(std::span<const uint8_t>{pData, dataSize}, idxBase + idx);
        }
 
        template <size_t Item>
        GAIA_NODISCARD auto get() const {
          const auto field = read_view_policy{std::span<const uint8_t>{pData, dataSize}}.template get<Item>();
          return SoATermFieldReadProxyPointer<U, Item>{field.data() + idxBase, cnt};
        }
 
        template <size_t Item>
        GAIA_NODISCARD auto set() {
          auto field = write_view_policy{std::span<uint8_t>{pData, dataSize}}.template set<Item>();
          return SoATermFieldWriteProxyPointer<U, Item>{field.data() + idxBase, cnt};
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
      };
 
      template <typename U, bool WriteIm>
      struct SoATermViewSetEntity {
        const Entity* pEntities = nullptr;
        World* pWorld = nullptr;
        Entity id = EntityBad;
        uint32_t cnt = 0;
 
        GAIA_NODISCARD auto operator[](size_t idx) {
          GAIA_ASSERT(idx < cnt);
          return SoATermRowWriteProxyEntity<U, WriteIm>{pEntities, pWorld, id, (uint32_t)idx};
        }
 
        GAIA_NODISCARD U operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          return world_query_entity_arg_by_id<const U&>(*pWorld, pEntities[idx], id);
        }
 
        template <size_t Item>
        GAIA_NODISCARD auto get() const {
          return SoATermFieldReadProxyEntity<U, Item>{pEntities, pWorld, id, cnt};
        }
 
        template <size_t Item>
        GAIA_NODISCARD auto set() {
          return SoATermFieldWriteProxyEntity<U, Item, WriteIm>{pEntities, pWorld, id, cnt};
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
      };
 
      template <typename U>
      struct SoATermRowWriteProxy {
        uint8_t* pData = nullptr;
        uint32_t dataSize = 0;
        const Entity* pEntities = nullptr;
        World* pWorld = nullptr;
        Entity id = EntityBad;
        uint32_t idx = 0;
        bool writeIm = true;
 
        GAIA_NODISCARD operator U() const {
          if (pData != nullptr)
            return (U)SoATermRowWriteProxyPointer<U>{pData, dataSize, idx};
 
          if (writeIm)
            return (U)SoATermRowWriteProxyEntity<U, true>{pEntities, pWorld, id, idx};
          return (U)SoATermRowWriteProxyEntity<U, false>{pEntities, pWorld, id, idx};
        }
 
        SoATermRowWriteProxy& operator=(const U& value) {
          if (pData != nullptr) {
            SoATermRowWriteProxyPointer<U>{pData, dataSize, idx} = value;
          } else if (writeIm)
            SoATermRowWriteProxyEntity<U, true>{pEntities, pWorld, id, idx} = value;
          else
            SoATermRowWriteProxyEntity<U, false>{pEntities, pWorld, id, idx} = value;
          return *this;
        }
      };
 
      template <typename U, size_t Item>
      struct SoATermFieldReadProxy {
        using value_type = typename SoATermFieldReadProxyPointer<U, Item>::value_type;
 
        const value_type* pData = nullptr;
        const Entity* pEntities = nullptr;
        World* pWorld = nullptr;
        Entity id = EntityBad;
        uint32_t cnt = 0;
 
        GAIA_NODISCARD value_type operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          if (pData != nullptr)
            return SoATermFieldReadProxyPointer<U, Item>{pData, cnt}[idx];
 
          return SoATermFieldReadProxyEntity<U, Item>{pEntities, pWorld, id, cnt}[idx];
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
      };
 
      template <typename U, size_t Item>
      struct SoATermFieldWriteProxy {
        using value_type = typename SoATermFieldWriteProxyPointer<U, Item>::value_type;
 
        value_type* pData = nullptr;
        const Entity* pEntities = nullptr;
        World* pWorld = nullptr;
        Entity id = EntityBad;
        uint32_t cnt = 0;
        bool writeIm = true;
 
        struct ElementProxy {
          value_type* pData = nullptr;
          const Entity* pEntities = nullptr;
          World* pWorld = nullptr;
          Entity id = EntityBad;
          uint32_t idx = 0;
          bool writeIm = true;
 
          GAIA_NODISCARD operator value_type() const {
            if (pData != nullptr)
              return SoATermFieldWriteProxyPointer<U, Item>{pData, idx + 1}[idx];
 
            if (writeIm)
              return SoATermFieldWriteProxyEntity<U, Item, true>{pEntities, pWorld, id, idx + 1}[idx];
            return SoATermFieldWriteProxyEntity<U, Item, false>{pEntities, pWorld, id, idx + 1}[idx];
          }
 
          ElementProxy& operator=(const value_type& value) {
            if (pData != nullptr) {
              SoATermFieldWriteProxyPointer<U, Item>{pData, idx + 1}[idx] = value;
              return *this;
            }
 
            if (writeIm)
              SoATermFieldWriteProxyEntity<U, Item, true>{pEntities, pWorld, id, idx + 1}[idx] = value;
            else
              SoATermFieldWriteProxyEntity<U, Item, false>{pEntities, pWorld, id, idx + 1}[idx] = value;
            return *this;
          }
 
          template <typename V>
          ElementProxy& operator+=(V&& value) {
            const value_type current = operator value_type();
            return operator=(current + GAIA_FWD(value));
          }
 
          template <typename V>
          ElementProxy& operator-=(V&& value) {
            const value_type current = operator value_type();
            return operator=(current - GAIA_FWD(value));
          }
 
          template <typename V>
          ElementProxy& operator*=(V&& value) {
            const value_type current = operator value_type();
            return operator=(current * GAIA_FWD(value));
          }
 
          template <typename V>
          ElementProxy& operator/=(V&& value) {
            const value_type current = operator value_type();
            return operator=(current / GAIA_FWD(value));
          }
        };
 
        GAIA_NODISCARD ElementProxy operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          return ElementProxy{pData, pEntities, pWorld, id, (uint32_t)idx, writeIm};
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
      };
 
      template <typename U>
      struct SoATermViewGet {
        const uint8_t* pData = nullptr;
        uint32_t dataSize = 0;
        const Entity* pEntities = nullptr;
        World* pWorld = nullptr;
        Entity id = EntityBad;
        uint32_t idxBase = 0;
        uint32_t cnt = 0;
 
        GAIA_NODISCARD U operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          if (pData != nullptr)
            return SoATermViewGetPointer<U>{pData, dataSize, idxBase, cnt}[idx];
 
          return SoATermViewGetEntity<U>{pEntities, pWorld, id, cnt}[idx];
        }
 
        template <size_t Item>
        GAIA_NODISCARD auto get() const {
          if (pData != nullptr) {
            const auto field = SoATermViewGetPointer<U>{pData, dataSize, idxBase, cnt}.template get<Item>();
            return SoATermFieldReadProxy<U, Item>{field.pData, nullptr, pWorld, id, cnt};
          }
 
          const auto field = SoATermViewGetEntity<U>{pEntities, pWorld, id, cnt}.template get<Item>();
          return SoATermFieldReadProxy<U, Item>{nullptr, field.pEntities, field.pWorld, field.id, field.cnt};
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
      };
 
      template <typename U>
      struct SoATermViewSet {
        uint8_t* pData = nullptr;
        uint32_t dataSize = 0;
        const Entity* pEntities = nullptr;
        World* pWorld = nullptr;
        Entity id = EntityBad;
        uint32_t idxBase = 0;
        uint32_t cnt = 0;
        bool writeIm = true;
 
        GAIA_NODISCARD auto operator[](size_t idx) {
          GAIA_ASSERT(idx < cnt);
          return SoATermRowWriteProxy<U>{pData, dataSize, pEntities, pWorld, id, idxBase + (uint32_t)idx, writeIm};
        }
 
        GAIA_NODISCARD U operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          if (pData != nullptr)
            return SoATermViewSetPointer<U>{pData, dataSize, idxBase, cnt}[idx];
 
          return SoATermViewSetEntity<U, true>{pEntities, pWorld, id, cnt}[idx];
        }
 
        template <size_t Item>
        GAIA_NODISCARD auto get() const {
          if (pData != nullptr) {
            const auto field = SoATermViewSetPointer<U>{pData, dataSize, idxBase, cnt}.template get<Item>();
            return SoATermFieldReadProxy<U, Item>{field.pData, nullptr, pWorld, id, cnt};
          }
 
          const auto field = SoATermViewSetEntity<U, true>{pEntities, pWorld, id, cnt}.template get<Item>();
          return SoATermFieldReadProxy<U, Item>{nullptr, field.pEntities, field.pWorld, field.id, field.cnt};
        }
 
        template <size_t Item>
        GAIA_NODISCARD auto set() {
          if (pData != nullptr) {
            auto field = SoATermViewSetPointer<U>{pData, dataSize, idxBase, cnt}.template set<Item>();
            return SoATermFieldWriteProxy<U, Item>{field.pData, nullptr, pWorld, id, cnt};
          }
 
          if (writeIm) {
            const auto field = SoATermViewSetEntity<U, true>{pEntities, pWorld, id, cnt}.template set<Item>();
            return SoATermFieldWriteProxy<U, Item>{nullptr, field.pEntities, field.pWorld, field.id, field.cnt, true};
          }
 
          const auto field = SoATermViewSetEntity<U, false>{pEntities, pWorld, id, cnt}.template set<Item>();
          return SoATermFieldWriteProxy<U, Item>{nullptr, field.pEntities, field.pWorld, field.id, field.cnt, false};
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
      };
 
      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_pCompIndices = nullptr;
        InheritedTermDataView m_inheritedData;
        const Entity* m_pTermIdMapping = nullptr;
        bool m_writeIm = true;
        uint8_t m_touchedCompIndices[ChunkHeader::MAX_COMPONENTS]{};
        uint8_t m_touchedCompCnt = 0;
        Entity m_touchedTerms[ChunkHeader::MAX_COMPONENTS]{};
        uint8_t m_touchedTermCnt = 0;
        Entity m_entitySnapshot[ChunkHeader::MAX_CHUNK_ENTITIES]{};
        bool m_entitySnapshotValid = false;
        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;
          m_entitySnapshotValid = false;
 
          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_entitySnapshotValid = false;
          m_from = from;
          m_to = to;
        }
 
        GAIA_NODISCARD const Chunk* chunk() const {
          GAIA_ASSERT(m_pChunk != nullptr);
          return m_pChunk;
        }
 
        void set_comp_indices(const uint8_t* pCompIndices) {
          m_pCompIndices = pCompIndices;
        }
 
        void set_inherited_data(InheritedTermDataView inheritedData) {
          m_inheritedData = inheritedData;
        }
 
        void set_term_ids(const Entity* pTermIds) {
          m_pTermIdMapping = pTermIds;
        }
 
        GAIA_NODISCARD const uint8_t* comp_indices() const {
          return m_pCompIndices;
        }
 
        GAIA_NODISCARD InheritedTermDataView inherited_data() const {
          return m_inheritedData;
        }
 
        GAIA_NODISCARD const Entity* term_ids() const {
          return m_pTermIdMapping;
        }
 
        void set_write_im(bool value) {
          m_writeIm = value;
          clear_touched_writes();
        }
 
        GAIA_NODISCARD bool write_im() const {
          return m_writeIm;
        }
 
        void clear_touched_writes() {
          m_touchedCompCnt = 0;
          m_touchedTermCnt = 0;
        }
 
        GAIA_NODISCARD const Entity* entity_snapshot() {
          if (!m_entitySnapshotValid) {
            const auto cnt = size();
            GAIA_ASSERT(cnt <= ChunkHeader::MAX_CHUNK_ENTITIES);
 
            const auto entities = m_pChunk->entity_view();
            GAIA_FOR(cnt) {
              m_entitySnapshot[i] = entities[from() + i];
            }
 
            m_entitySnapshotValid = true;
          }
 
          return m_entitySnapshot;
        }
 
        GAIA_NODISCARD auto touched_comp_indices() const {
          return std::span<const uint8_t>{m_touchedCompIndices, m_touchedCompCnt};
        }
 
        GAIA_NODISCARD auto touched_terms() const {
          return std::span<const Entity>{m_touchedTerms, m_touchedTermCnt};
        }
 
        GAIA_NODISCARD auto entity_rows() {
          if (m_entitySnapshotValid)
            return std::span<const Entity>{m_entitySnapshot, size()};
 
          return std::span<const Entity>{m_pChunk->entity_view().data() + from(), size()};
        }
 
        template <typename U>
        GAIA_NODISCARD auto entity_view_set(Entity termId, bool writeIm) {
          return EntityTermViewSet<U>::entity(entity_snapshot(), world(), termId, size(), writeIm);
        }
 
        template <typename U>
        GAIA_NODISCARD auto entity_soa_view_set(Entity termId, bool writeIm) {
          return SoATermViewSet<U>{nullptr, 0, entity_snapshot(), world(), termId, 0, size(), writeIm};
        }
 
        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 bool uses_out_of_line_component() const {
          using Arg = std::remove_cv_t<std::remove_reference_t<T>>;
          if constexpr (std::is_same_v<Arg, Entity>)
            return false;
          else {
            using FT = typename component_type_t<Arg>::TypeFull;
            if constexpr (is_pair<FT>::value || mem::is_soa_layout_v<Arg>)
              return false;
            else {
              const auto* pItem = comp_cache(*world()).template find<FT>();
              // Type-based iteration switches to the world/store path as soon as the
              // payload stops being chunk-backed, even if the id still fragments.
              return pItem != nullptr && world_is_out_of_line_component(*world(), pItem->entity);
            }
          }
        }
 
        void touch_comp_idx(uint8_t compIdx) {
          GAIA_ASSERT(compIdx != 0xFF);
          GAIA_FOR(m_touchedCompCnt) {
            if (m_touchedCompIndices[i] == compIdx)
              return;
          }
 
          GAIA_ASSERT(m_touchedCompCnt < ChunkHeader::MAX_COMPONENTS);
          m_touchedCompIndices[m_touchedCompCnt++] = compIdx;
        }
 
        void touch_term(Entity term) {
          GAIA_ASSERT(term != EntityBad);
          GAIA_FOR(m_touchedTermCnt) {
            if (m_touchedTerms[i] == term)
              return;
          }
 
          GAIA_ASSERT(m_touchedTermCnt < ChunkHeader::MAX_COMPONENTS);
          m_touchedTerms[m_touchedTermCnt++] = term;
        }
 
        template <typename T>
        void touch_term_by_type() {
          using Arg = std::remove_cv_t<std::remove_reference_t<T>>;
          if constexpr (std::is_same_v<Arg, Entity>)
            return;
          else {
            const auto term = world_query_arg_id<Arg>(*world());
            if (world_is_out_of_line_component(*world(), term))
              touch_term(term);
            else
              touch_comp_idx((uint8_t)m_pChunk->comp_idx(term));
          }
        }
 
        template <typename T>
        GAIA_NODISCARD Entity fallback_term_id(uint32_t termIdx) const {
          if (m_pTermIdMapping != nullptr) {
            const auto termId = m_pTermIdMapping[termIdx];
            if (termId != EntityBad)
              return termId;
          }
 
          using Arg = std::remove_cv_t<std::remove_reference_t<T>>;
          if constexpr (std::is_same_v<Arg, Entity>)
            return EntityBad;
          else
            return world_query_arg_id<Arg>(*const_cast<World*>(world()));
        }
 
        template <typename T>
        GAIA_NODISCARD auto view_any() const {
          using U = typename actual_type_t<T>::Type;
          if constexpr (std::is_same_v<U, Entity> || mem::is_soa_layout_v<U>)
            return m_pChunk->view<T>(from(), to());
          else {
            Entity id = EntityBad;
            if (uses_out_of_line_component<T>()) {
              using Arg = std::remove_cv_t<std::remove_reference_t<T>>;
              using FT = typename component_type_t<Arg>::TypeFull;
              id = comp_cache(*world()).template get<FT>().entity;
            }
 
            if (id != EntityBad)
              return EntityTermViewGet<U>::entity(
                  m_pChunk->entity_view().data() + from(), const_cast<World*>(world()), id, size());
 
            auto* pData = reinterpret_cast<const U*>(m_pChunk->template view<T>(from(), to()).data());
            return EntityTermViewGet<U>::pointer(pData, size());
          }
        }
 
        template <typename T>
        GAIA_NODISCARD auto view_any(uint32_t termIdx) {
          using U = typename actual_type_t<T>::Type;
 
          if constexpr (mem::is_soa_layout_v<U>) {
            const auto compIdx = m_pCompIndices[termIdx];
            if (compIdx == 0xFF) {
              const auto* pEntities = m_pChunk->entity_view().data() + from();
              const auto termId = fallback_term_id<T>(termIdx);
              GAIA_ASSERT(termId != EntityBad);
              return SoATermViewGet<U>{nullptr, 0, pEntities, const_cast<World*>(world()), termId, 0, size()};
            }
 
            GAIA_ASSERT(compIdx < m_pChunk->ids_view().size());
            return SoATermViewGet<U>{
                m_pChunk->comp_ptr(compIdx), m_pChunk->capacity(), nullptr, world(), EntityBad, from(), size()};
          } else {
            const auto termId = fallback_term_id<T>(termIdx);
            const auto compIdx = m_pCompIndices[termIdx];
            if (termId != EntityBad && world_is_out_of_line_component(*world(), termId))
              return EntityTermViewGet<U>::entity(
                  m_pChunk->entity_view().data() + from(), const_cast<World*>(world()), termId, size());
 
            if (compIdx == 0xFF) {
              GAIA_ASSERT(termId != EntityBad);
              if (!m_inheritedData.empty()) {
                const auto* pInheritedValue = reinterpret_cast<const U*>(m_inheritedData[termIdx]);
                if (pInheritedValue != nullptr)
                  return EntityTermViewGet<U>::inherited(pInheritedValue, size());
              }
              if (world_term_uses_inherit_policy(*world(), termId)) {
                return EntityTermViewGet<U>::entity_chunk_stable(
                    m_pChunk->entity_view().data() + from(), m_pChunk, const_cast<World*>(world()), termId, from(),
                    size());
              }
              return EntityTermViewGet<U>::entity(
                  m_pChunk->entity_view().data() + from(), const_cast<World*>(world()), termId, size());
            }
            GAIA_ASSERT(compIdx < m_pChunk->ids_view().size());
 
            auto* pData = reinterpret_cast<const U*>(m_pChunk->comp_ptr_mut(compIdx, from()));
            return EntityTermViewGet<U>::pointer(pData, size());
          }
        }
 
        template <typename T>
        GAIA_NODISCARD auto view() const {
          using U = typename actual_type_t<T>::Type;
          if constexpr (std::is_same_v<U, Entity>)
            return m_pChunk->view<T>(from(), to());
          else if constexpr (mem::is_soa_layout_v<U>) {
            const auto view = m_pChunk->view<T>(from(), to());
            return SoATermViewGetPointer<U>{(const uint8_t*)view.data(), (uint32_t)view.size(), from(), size()};
          } else {
            auto* pData = reinterpret_cast<const U*>(m_pChunk->template view<T>(from(), to()).data());
            return EntityTermViewGetPointer<U>{pData, size()};
          }
        }
 
        template <typename T>
        GAIA_NODISCARD auto view(uint32_t termIdx) const {
          using U = typename actual_type_t<T>::Type;
          const auto compIdx = m_pCompIndices[termIdx];
          GAIA_ASSERT(compIdx != 0xFF);
 
          if constexpr (mem::is_soa_layout_v<U>)
            return SoATermViewGetPointer<U>{m_pChunk->comp_ptr(compIdx), m_pChunk->capacity(), from(), size()};
          else {
            auto* pData = reinterpret_cast<const U*>(m_pChunk->comp_ptr(compIdx, from()));
            return EntityTermViewGetPointer<U>{pData, size()};
          }
        }
 
        template <typename T>
        GAIA_NODISCARD auto view_mut_any() {
          using U = typename actual_type_t<T>::Type;
          static_assert(!std::is_same_v<U, Entity>, "Modifying chunk entities via view_mut is forbidden");
          if constexpr (mem::is_soa_layout_v<U>) {
            touch_term_by_type<T>();
            if (m_writeIm)
              return m_pChunk->view_mut<T>(from(), to());
            return m_pChunk->sview_mut<T>(from(), to());
          } else {
            Entity id = EntityBad;
            if (uses_out_of_line_component<T>()) {
              using Arg = std::remove_cv_t<std::remove_reference_t<T>>;
              using FT = typename component_type_t<Arg>::TypeFull;
              id = comp_cache(*world()).template get<FT>().entity;
            }
 
            if (id != EntityBad) {
              touch_term(id);
              return entity_view_set<U>(id, m_writeIm);
            }
 
            touch_term_by_type<T>();
            auto* pData = reinterpret_cast<U*>((m_writeIm ? m_pChunk->template view_mut<T>(from(), to())
                                                          : m_pChunk->template sview_mut<T>(from(), to()))
                                                   .data());
            return EntityTermViewSet<U>::pointer(pData, size());
          }
        }
 
        template <typename T>
        GAIA_NODISCARD auto view_mut() {
          using U = typename actual_type_t<T>::Type;
          static_assert(!std::is_same_v<U, Entity>, "Modifying chunk entities via view_mut is forbidden");
          touch_term_by_type<T>();
          if constexpr (mem::is_soa_layout_v<U>) {
            auto view = m_writeIm ? m_pChunk->view_mut<T>(from(), to()) : m_pChunk->sview_mut<T>(from(), to());
            return SoATermViewSetPointer<U>{(uint8_t*)view.data(), (uint32_t)view.size(), from(), size()};
          } else {
            auto* pData = reinterpret_cast<U*>((m_writeIm ? m_pChunk->template view_mut<T>(from(), to())
                                                          : m_pChunk->template sview_mut<T>(from(), to()))
                                                   .data());
            return EntityTermViewSetPointer<U>{pData, size()};
          }
        }
 
        template <typename T>
        GAIA_NODISCARD auto view_mut(uint32_t termIdx) {
          using U = typename actual_type_t<T>::Type;
          static_assert(!std::is_same_v<U, Entity>, "Modifying chunk entities via view_mut is forbidden");
          const auto compIdx = m_pCompIndices[termIdx];
          GAIA_ASSERT(compIdx != 0xFF);
          touch_comp_idx(compIdx);
 
          if constexpr (mem::is_soa_layout_v<U>) {
            if (m_writeIm)
              m_pChunk->update_world_version(compIdx);
            return SoATermViewSetPointer<U>{m_pChunk->comp_ptr_mut(compIdx), m_pChunk->capacity(), from(), size()};
          } else {
            if (m_writeIm)
              m_pChunk->update_world_version(compIdx);
            auto* pData = reinterpret_cast<U*>(m_pChunk->comp_ptr_mut(compIdx, from()));
            return EntityTermViewSetPointer<U>{pData, size()};
          }
        }
 
        template <typename T>
        GAIA_NODISCARD auto view_mut_any(uint32_t termIdx) {
          using U = typename actual_type_t<T>::Type;
 
          if constexpr (mem::is_soa_layout_v<U>) {
            const auto compIdx = m_pCompIndices[termIdx];
            if (compIdx == 0xFF) {
              const auto termId = fallback_term_id<T>(termIdx);
              GAIA_ASSERT(termId != EntityBad);
              touch_term(termId);
              return entity_soa_view_set<U>(termId, m_writeIm);
            }
 
            GAIA_ASSERT(compIdx < m_pChunk->comp_rec_view().size());
            touch_comp_idx(compIdx);
            if (m_writeIm)
              m_pChunk->update_world_version(compIdx);
            return SoATermViewSet<U>{m_pChunk->comp_ptr_mut(compIdx),
                                     m_pChunk->capacity(),
                                     nullptr,
                                     world(),
                                     EntityBad,
                                     from(),
                                     size(),
                                     m_writeIm};
          } else {
            const auto termId = fallback_term_id<T>(termIdx);
            const auto compIdx = m_pCompIndices[termIdx];
            if (termId != EntityBad && world_is_out_of_line_component(*world(), termId)) {
              touch_term(termId);
              return entity_view_set<U>(termId, m_writeIm);
            }
 
            if (compIdx == 0xFF) {
              GAIA_ASSERT(termId != EntityBad);
              touch_term(termId);
              return entity_view_set<U>(termId, m_writeIm);
            }
            GAIA_ASSERT(compIdx < m_pChunk->comp_rec_view().size());
 
            touch_comp_idx(compIdx);
            if (m_writeIm)
              m_pChunk->update_world_version(compIdx);
 
            auto* pData = reinterpret_cast<U*>(m_pChunk->comp_ptr_mut(compIdx, from()));
            return EntityTermViewSet<U>::pointer(pData, size());
          }
        }
 
        template <typename T>
        GAIA_NODISCARD auto sview_mut_any() {
          using U = typename actual_type_t<T>::Type;
          static_assert(!std::is_same_v<U, Entity>, "Modifying chunk entities via sview_mut is forbidden");
          if constexpr (mem::is_soa_layout_v<U>)
            return m_pChunk->sview_mut<T>(from(), to());
          else {
            Entity id = EntityBad;
            if (uses_out_of_line_component<T>()) {
              using Arg = std::remove_cv_t<std::remove_reference_t<T>>;
              using FT = typename component_type_t<Arg>::TypeFull;
              id = comp_cache(*world()).template get<FT>().entity;
            }
 
            if (id != EntityBad)
              return entity_view_set<U>(id, false);
 
            auto* pData = reinterpret_cast<U*>(m_pChunk->template sview_mut<T>(from(), to()).data());
            return EntityTermViewSet<U>::pointer(pData, size());
          }
        }
 
        template <typename T>
        GAIA_NODISCARD auto sview_mut() {
          using U = typename actual_type_t<T>::Type;
          static_assert(!std::is_same_v<U, Entity>, "Modifying chunk entities via sview_mut is forbidden");
          if constexpr (mem::is_soa_layout_v<U>) {
            auto view = m_pChunk->sview_mut<T>(from(), to());
            return SoATermViewSetPointer<U>{(uint8_t*)view.data(), (uint32_t)view.size(), from(), size()};
          } else {
            auto* pData = reinterpret_cast<U*>(m_pChunk->template sview_mut<T>(from(), to()).data());
            return EntityTermViewSetPointer<U>{pData, size()};
          }
        }
 
        template <typename T>
        GAIA_NODISCARD auto sview_mut(uint32_t termIdx) {
          using U = typename actual_type_t<T>::Type;
          static_assert(!std::is_same_v<U, Entity>, "Modifying chunk entities via sview_mut is forbidden");
          const auto compIdx = m_pCompIndices[termIdx];
          GAIA_ASSERT(compIdx != 0xFF);
 
          if constexpr (mem::is_soa_layout_v<U>)
            return SoATermViewSetPointer<U>{m_pChunk->comp_ptr_mut(compIdx), m_pChunk->capacity(), from(), size()};
          else {
            auto* pData = reinterpret_cast<U*>(m_pChunk->comp_ptr_mut(compIdx, from()));
            return EntityTermViewSetPointer<U>{pData, size()};
          }
        }
 
        template <typename T>
        GAIA_NODISCARD auto sview_mut_any(uint32_t termIdx) {
          using U = typename actual_type_t<T>::Type;
 
          if constexpr (mem::is_soa_layout_v<U>) {
            const auto compIdx = m_pCompIndices[termIdx];
            if (compIdx == 0xFF) {
              const auto termId = fallback_term_id<T>(termIdx);
              GAIA_ASSERT(termId != EntityBad);
              return entity_soa_view_set<U>(termId, false);
            }
 
            GAIA_ASSERT(compIdx < m_pChunk->ids_view().size());
            return SoATermViewSet<U>{m_pChunk->comp_ptr_mut(compIdx),
                                     m_pChunk->capacity(),
                                     nullptr,
                                     world(),
                                     EntityBad,
                                     from(),
                                     size(),
                                     false};
          } else {
            const auto termId = fallback_term_id<T>(termIdx);
            const auto compIdx = m_pCompIndices[termIdx];
            if (termId != EntityBad && world_is_out_of_line_component(*world(), termId))
              return entity_view_set<U>(termId, false);
 
            if (compIdx == 0xFF) {
              GAIA_ASSERT(termId != EntityBad);
              return entity_view_set<U>(termId, false);
            }
            GAIA_ASSERT(compIdx < m_pChunk->ids_view().size());
 
            auto* pData = reinterpret_cast<U*>(m_pChunk->comp_ptr_mut(compIdx, from()));
            return EntityTermViewSet<U>::pointer(pData, size());
          }
        }
 
        template <typename T, bool TriggerHooks>
        void modify() {
          m_pChunk->modify<T, TriggerHooks>();
        }
 
        template <typename T>
        GAIA_NODISCARD auto view_auto() {
          using UOriginal = typename actual_type_t<T>::TypeOriginal;
          if constexpr (core::is_mut_v<UOriginal>)
            return view_mut<T>();
          else
            return view<T>();
        }
 
        template <typename T>
        GAIA_NODISCARD auto view_auto_any() {
          using UOriginal = typename actual_type_t<T>::TypeOriginal;
          if constexpr (core::is_mut_v<UOriginal>)
            return view_mut_any<T>();
          else
            return view_any<T>();
        }
 
        template <typename T>
        GAIA_NODISCARD auto sview_auto_any() {
          using UOriginal = typename actual_type_t<T>::TypeOriginal;
          if constexpr (core::is_mut_v<UOriginal>)
            return sview_mut_any<T>();
          else
            return view_any<T>();
        }
 
        template <typename T>
        GAIA_NODISCARD auto sview_auto() {
          using UOriginal = typename actual_type_t<T>::TypeOriginal;
          if constexpr (core::is_mut_v<UOriginal>)
            return sview_mut<T>();
          else
            return view<T>();
        }
 
        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 (uint16_t)(to() - from());
        }
 
        GAIA_NODISCARD uint16_t row_begin() const noexcept {
          return from();
        }
 
        GAIA_NODISCARD uint16_t row_end() const noexcept {
          return to();
        }
 
        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;
        }
 
        template <typename T>
        uint32_t acc_index_direct(uint32_t idx) const noexcept {
          (void)sizeof(typename actual_type_t<T>::Type);
          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