component_cursor.h

#pragma once
#include "gaia/config/config.h"
 
#include <cstdint>
#include <cstring>
 
#include "gaia/ecs/component_cache.h"
#include "gaia/ecs/component_cache_item.h"
#include "gaia/ecs/id.h"
#include "gaia/util/str.h"
 
namespace gaia {
  namespace ecs {
    class World;
    void world_finish_write(World& world, Entity term, Entity entity);
 
    enum ComponentRawViewFlags : uint32_t {
      ComponentRawViewFlag_None = 0,
      ComponentRawViewFlag_Valid = 1U << 0
    };
 
    struct ComponentRawView {
      const void* data = nullptr;
      uint32_t size = 0;
      uint32_t flags = ComponentRawViewFlag_None;
 
      GAIA_NODISCARD bool valid() const noexcept {
        return (flags & ComponentRawViewFlag_Valid) != 0;
      }
    };
    static_assert(sizeof(ComponentRawView) == 16, "ComponentRawView must stay compact");
 
    struct ComponentRawMutView {
      void* data = nullptr;
      uint32_t size = 0;
      uint32_t flags = ComponentRawViewFlag_None;
 
      GAIA_NODISCARD bool valid() const noexcept {
        return (flags & ComponentRawViewFlag_Valid) != 0;
      }
    };
    static_assert(sizeof(ComponentRawMutView) == 16, "ComponentRawMutView must stay compact");
 
    enum class ComponentWriteResult : uint8_t { Ok, Invalid, ReadOnly, OutOfRange };
 
    struct ComponentCursor {
      static constexpr uint32_t MaxDepth = 32;
 
      ComponentCursor() = default;
 
      GAIA_NODISCARD static ComponentCursor
      from_raw(const ComponentCache& components, Entity component, ComponentRawView view) {
        ComponentCursor cursor{};
        if (!view.valid())
          return cursor;
 
        cursor.m_components = &components;
        cursor.m_stack[0].type = component;
        cursor.m_stack[0].data = view.data;
        cursor.m_stack[0].size = view.size;
        cursor.m_valid = true;
        return cursor;
      }
 
      GAIA_NODISCARD static ComponentCursor from_raw(
          World& world, const ComponentCache& components, Entity entity, Entity component, ComponentRawMutView view) {
        ComponentCursor cursor{};
        if (!view.valid())
          return cursor;
 
        cursor.m_world = &world;
        cursor.m_components = &components;
        cursor.m_entity = entity;
        cursor.m_rootType = component;
        cursor.m_stack[0].type = component;
        cursor.m_stack[0].data = view.data;
        cursor.m_stack[0].mutData = view.data;
        cursor.m_stack[0].size = view.size;
        cursor.m_stack[0].writable = true;
        cursor.m_valid = true;
        return cursor;
      }
 
      GAIA_NODISCARD bool valid() const noexcept {
        return m_valid;
      }
 
      GAIA_NODISCARD uint32_t depth() const noexcept {
        return m_depth;
      }
 
      GAIA_NODISCARD Entity type() const noexcept {
        return m_valid ? m_stack[m_depth].type : EntityBad;
      }
 
      GAIA_NODISCARD uint32_t size() const noexcept {
        return m_valid ? m_stack[m_depth].size : 0;
      }
 
      GAIA_NODISCARD const void* ptr() const noexcept {
        return m_valid ? m_stack[m_depth].data : nullptr;
      }
 
      GAIA_NODISCARD void* mut_ptr() const noexcept {
        return m_valid ? m_stack[m_depth].mutData : nullptr;
      }
 
      GAIA_NODISCARD uint32_t field_count() const {
        const auto* pItem = current_item();
        return pItem != nullptr ? pItem->field_count() : 0;
      }
 
      bool field(uint32_t index) {
        const auto* pItem = current_item();
        if (pItem == nullptr || index >= pItem->field_count())
          return false;
        return descend(pItem->fields[index]);
      }
 
      bool field(util::str_view name) {
        const auto* pItem = current_item();
        if (pItem == nullptr)
          return false;
 
        const RuntimeField* pField = nullptr;
        if (!pItem->field(name, &pField) || pField == nullptr)
          return false;
        return descend(*pField);
      }
 
      bool parent() noexcept {
        if (!m_valid || m_depth == 0)
          return false;
        --m_depth;
        return true;
      }
 
      GAIA_NODISCARD bool get_f32(float* value) const noexcept {
        if (value == nullptr || !m_valid || size() != sizeof(float) || ptr() == nullptr)
          return false;
        memcpy(value, ptr(), sizeof(float));
        return true;
      }
 
      ComponentWriteResult write_bytes(const void* data, uint32_t byteCount) noexcept {
        if (!m_valid)
          return ComponentWriteResult::Invalid;
        if (!m_stack[m_depth].writable || m_world == nullptr || m_entity == EntityBad || m_rootType == EntityBad)
          return ComponentWriteResult::ReadOnly;
        if (byteCount != size())
          return ComponentWriteResult::OutOfRange;
        if (byteCount == 0)
          return ComponentWriteResult::Ok;
        if (data == nullptr || mut_ptr() == nullptr)
          return ComponentWriteResult::Invalid;
 
        memcpy(mut_ptr(), data, byteCount);
        world_finish_write(*m_world, m_rootType, m_entity);
        return ComponentWriteResult::Ok;
      }
 
    private:
      struct Scope {
        Entity type = EntityBad;
        const void* data = nullptr;
        void* mutData = nullptr;
        uint32_t size = 0;
        bool writable = false;
      };
 
      World* m_world = nullptr;
      const ComponentCache* m_components = nullptr;
      Entity m_entity = EntityBad;
      Entity m_rootType = EntityBad;
      Scope m_stack[MaxDepth]{};
      uint32_t m_depth = 0;
      bool m_valid = false;
 
      GAIA_NODISCARD const ComponentCacheItem* current_item() const noexcept {
        if (!m_valid || m_components == nullptr)
          return nullptr;
        return m_components->find(m_stack[m_depth].type);
      }
 
      bool descend(const RuntimeField& field) noexcept {
        if (!m_valid || m_components == nullptr || m_depth + 1 >= MaxDepth)
          return false;
 
        const auto* pType = m_components->find(field.type);
        if (pType == nullptr)
          return false;
 
        const auto elemSize = pType->comp.size();
        const auto elemCount = ComponentCacheItem::field_element_count(field);
        const auto fieldSize64 = (uint64_t)elemSize * (uint64_t)elemCount;
        const auto end = (uint64_t)field.offset + fieldSize64;
        if (fieldSize64 > UINT32_MAX || end > m_stack[m_depth].size)
          return false;
 
        Scope next{};
        next.type = field.type;
        next.size = (uint32_t)fieldSize64;
        next.writable = m_stack[m_depth].writable;
        if (m_stack[m_depth].data != nullptr)
          next.data = (const uint8_t*)m_stack[m_depth].data + field.offset;
        if (m_stack[m_depth].mutData != nullptr)
          next.mutData = (uint8_t*)m_stack[m_depth].mutData + field.offset;
 
        m_stack[++m_depth] = next;
        return true;
      }
    };
  } // namespace ecs
} // namespace gaia