chunk_header.h

#pragma once
#include "gaia/config/config.h"
 
#include <cstdint>
 
#include "gaia/cnt/bitset.h"
#include "gaia/core/utility.h"
#include "gaia/ecs/archetype_common.h"
#include "gaia/ecs/chunk_allocator.h"
#include "gaia/ecs/component.h"
#include "gaia/ecs/id.h"
 
namespace gaia {
  namespace ecs {
    class World;
    class ComponentCache;
    struct ComponentCacheItem;
 
    struct GAIA_API ChunkDataOffsets {
      ChunkDataVersionOffset firstByte_Versions{};
      ChunkDataOffset firstByte_CompEntities{};
      ChunkDataOffset firstByte_Records{};
      ChunkDataOffset firstByte_EntityData{};
    };
 
    struct GAIA_API ComponentRecord {
      Component comp;
      uint8_t* pData;
      const ComponentCacheItem* pItem;
    };
 
    struct GAIA_API ChunkRecords {
      ComponentVersion* pVersions{};
      Entity* pCompEntities{};
      ComponentRecord* pRecords{};
      Entity* pEntities{};
    };
 
    struct GAIA_API ChunkHeader final {
      static constexpr uint32_t MAX_COMPONENTS_BITS = 5U;
      static constexpr uint32_t MAX_COMPONENTS = 1U << MAX_COMPONENTS_BITS;
 
      static constexpr uint16_t MAX_CHUNK_ENTITIES = (mem_block_size(2) - 64) / sizeof(Entity);
      static constexpr uint16_t MAX_CHUNK_ENTITIES_BITS = (uint16_t)core::count_bits(MAX_CHUNK_ENTITIES);
 
      static constexpr uint16_t CHUNK_LIFESPAN_BITS = 4;
      static constexpr uint16_t MAX_CHUNK_LIFESPAN = (1 << CHUNK_LIFESPAN_BITS) - 1;
 
      const World* world;
      const ComponentCache* cc;
      uint32_t index;
      uint32_t deleteQueueIndex;
      uint16_t count;
      uint16_t countEnabled;
      uint16_t capacity;
 
      uint16_t rowFirstEnabledEntity : MAX_CHUNK_ENTITIES_BITS;
      uint16_t hasAnyCustomGenCtor : 1;
      uint16_t hasAnyCustomUniCtor : 1;
      uint16_t hasAnyCustomGenDtor : 1;
      uint16_t hasAnyCustomUniDtor : 1;
      uint16_t lifespanCountdown : CHUNK_LIFESPAN_BITS;
      uint16_t dead : 1;
      uint16_t unused : 11;
 
      uint8_t genEntities;
      uint8_t cntEntities;
      uint32_t& worldVersion;
      uint32_t entityOrderVersion;
 
      static inline uint32_t s_worldVersionDummy = 0;
      ChunkHeader(): worldVersion(s_worldVersionDummy), entityOrderVersion(0) {}
 
      ChunkHeader(
          const World& wld, const ComponentCache& compCache, uint32_t chunkIndex, uint16_t cap, uint8_t genEntitiesCnt,
          uint32_t& version):
          world(&wld), cc(&compCache), index(chunkIndex), deleteQueueIndex(BadIndex), count(0), countEnabled(0),
          capacity(cap),
          //
          rowFirstEnabledEntity(0), hasAnyCustomGenCtor(0), hasAnyCustomUniCtor(0), hasAnyCustomGenDtor(0),
          hasAnyCustomUniDtor(0), lifespanCountdown(0), dead(0), unused(0),
          //
          genEntities(genEntitiesCnt), cntEntities(0), worldVersion(version), entityOrderVersion(0) {
        // Make sure the alignment is right
        GAIA_ASSERT(uintptr_t(this) % (sizeof(size_t)) == 0);
      }
 
      bool has_disabled_entities() const {
        return rowFirstEnabledEntity > 0;
      }
 
      bool has_enabled_entities() const {
        return countEnabled > 0;
      }
    };
  } // namespace ecs
} // namespace gaia