command_buffer.h

#pragma once
#include "gaia/config/config.h"
 
#include <cstdint>
#include <type_traits>
 
#include "gaia/cnt/darray_ext.h"
#include "gaia/cnt/dbitset.h"
#include "gaia/ecs/archetype.h"
#include "gaia/ecs/command_buffer_fwd.h"
#include "gaia/ecs/common.h"
#include "gaia/ecs/component.h"
#include "gaia/ecs/component_cache.h"
#include "gaia/ecs/component_cache_item.h"
#include "gaia/ecs/id.h"
#include "gaia/ecs/world.h"
#include "gaia/ser/ser_buffer_binary.h"
 
namespace gaia {
  namespace ecs {
    struct AccessContextST {
      void lock() {}
      void unlock() {}
    };
 
    struct AccessContextMT {
      mt::SpinLock m_lock;
 
      void lock() {
        m_lock.lock();
      }
 
      void unlock() {
        m_lock.unlock();
      }
    };
 
    namespace detail {
      template <typename AccessContext>
      class CommandBuffer final {
        enum class OpType : uint8_t {
          NONE = 0,
          ADD_ENTITY,
          CPY_ENTITY,
          DEL_ENTITY,
          ADD_COMPONENT,
          ADD_COMPONENT_DATA,
          SET_COMPONENT,
          DEL_COMPONENT,
        };
 
        struct Op {
          OpType type;
          uint32_t off;
          Entity target;
          Entity other;
        };
 
        ecs::World& m_world;
        cnt::darray_ext<Op, 128> m_ops;
        cnt::darray_ext<Entity, 128> m_temp2real;
        cnt::dbitset<mem::DefaultAllocatorAdaptor> m_tmpFlags;
        uint32_t m_nextTemp = 0;
        bool m_needsSort = false;
 
        bool m_haveReal = false;
        bool m_haveTemp = false;
        Entity m_lastRealTarget = EntityBad;
        Entity m_lastTempTarget = EntityBad;
 
        BinarySerializer m_data;
        AccessContext m_acc;
 
      public:
        explicit CommandBuffer(World& world): m_world(world) {}
        ~CommandBuffer() = default;
 
        CommandBuffer(CommandBuffer&&) = delete;
        CommandBuffer(const CommandBuffer&) = delete;
        CommandBuffer& operator=(CommandBuffer&&) = delete;
        CommandBuffer& operator=(const CommandBuffer&) = delete;
 
        GAIA_NODISCARD Entity add(EntityKind kind = EntityKind::EK_Gen) {
          core::lock_scope lock(m_acc);
 
          Entity temp = add_temp(kind);
          push_op({OpType::ADD_ENTITY, 0, temp, EntityBad});
          return temp;
        }
 
        GAIA_NODISCARD Entity copy(Entity entityFrom) {
          core::lock_scope lock(m_acc);
 
          Entity temp = add_temp(entityFrom.kind());
          push_op({OpType::CPY_ENTITY, 0, temp, entityFrom});
          return temp;
        }
 
        template <typename T>
        void add(Entity entity) {
          verify_comp<T>();
          core::lock_scope lock(m_acc);
 
          // Make sure the component is registered
          const auto& item = comp_cache_add<T>(m_world);
 
          push_op({OpType::ADD_COMPONENT, 0, entity, item.entity});
        }
 
        void add(Entity entity, Entity other) {
          core::lock_scope lock(m_acc);
 
          push_op({OpType::ADD_COMPONENT, 0, entity, other});
        }
 
        template <typename T>
        void add(Entity entity, T&& value) {
          verify_comp<T>();
          core::lock_scope lock(m_acc);
 
          // Make sure the component is registered
          const auto& item = comp_cache_add<T>(m_world);
 
          const auto pos = m_data.tell();
          item.save(&m_data, &value, 0, 1, 1);
          push_op({OpType::ADD_COMPONENT_DATA, pos, entity, item.entity});
        }
 
        template <typename T>
        void set(Entity entity, T&& value) {
          verify_comp<T>();
          core::lock_scope lock(m_acc);
 
          // Make sure the component is registered
          const auto& item = comp_cache(m_world).template get<T>();
 
          const auto pos = m_data.tell();
          item.save(&m_data, &value, 0, 1, 1);
          push_op({OpType::SET_COMPONENT, pos, entity, item.entity});
        }
 
        void del(Entity entity) {
          core::lock_scope lock(m_acc);
 
          push_op({OpType::DEL_ENTITY, 0, entity, EntityBad});
        }
 
        template <typename T>
        void del(Entity entity) {
          verify_comp<T>();
          core::lock_scope lock(m_acc);
 
          // Make sure the component is registered
          const auto& item = comp_cache(m_world).template get<T>();
 
          push_op({OpType::DEL_COMPONENT, 0, entity, item.entity});
        }
 
        void del(Entity entity, Entity object) {
          core::lock_scope lock(m_acc);
 
          push_op({OpType::DEL_COMPONENT, 0, entity, object});
        }
 
      private:
        GAIA_NODISCARD bool is_rel(OpType t) const {
          return (uint32_t)t >= (uint32_t)OpType::ADD_COMPONENT;
        }
 
        GAIA_NODISCARD bool is_tmp(Entity e) const {
          return e.data.tmp != 0;
        }
 
        GAIA_NODISCARD Entity resolve(Entity e) const {
          if (!is_tmp(e))
            return e;
 
          const auto ti = e.id();
          if (ti < m_temp2real.size())
            return m_temp2real[ti];
 
          return EntityBad;
        }
 
        GAIA_NODISCARD bool is_canceled_temp(uint32_t idx) const {
          const uint32_t base = idx * 3;
          if (base + 2 >= m_tmpFlags.size())
            return false;
 
          const bool destroy = m_tmpFlags.test(base);
          const bool usedOther = m_tmpFlags.test(base + 2);
 
          // If deleted in this batch and not referenced by others, cancel entirely
          return destroy && !usedOther;
        }
 
        GAIA_NODISCARD Entity add_temp(EntityKind kind) {
          m_temp2real.push_back(EntityBad);
          Entity tmp(m_nextTemp++, 0, true, false, kind);
          // Use the unused flag to mark temporary entities
          tmp.data.tmp = 1;
          return tmp;
        }
 
        GAIA_NODISCARD bool less_target(Entity a, Entity b) const {
          const bool ta = is_tmp(a);
          const bool tb = is_tmp(b);
 
          // Real entities always come first in order. Temps come last.
          if (ta != tb)
            return !ta && tb;
 
          // Within same domain, normal numeric order.
          return a.id() < b.id();
        }
 
        void check_sort(const Op& op) {
          if (is_tmp(op.target)) {
            if (m_haveTemp) {
              // Only compare temp indices against previous temp target
              const uint32_t prev = m_lastTempTarget.id();
              const uint32_t curr = op.target.id();
              if (curr < prev)
                m_needsSort = true;
            }
            m_lastTempTarget = op.target;
            m_haveTemp = true;
          } else {
            if (m_haveReal) {
              // Only compare real IDs against previous real target
              if (op.target.id() < m_lastRealTarget.id())
                m_needsSort = true;
            }
            m_lastRealTarget = op.target;
            m_haveReal = true;
          }
        }
 
        void push_op(Op&& op) {
          check_sort(op);
          m_ops.push_back(GAIA_MOV(op));
        }
 
        void clear() {
          m_ops.clear();
          m_temp2real.clear();
          m_tmpFlags.reset();
          m_nextTemp = 0;
          m_data.reset();
 
          m_needsSort = false;
          m_haveReal = false;
          m_haveTemp = false;
          m_lastRealTarget = EntityBad;
          m_lastTempTarget = EntityBad;
        }
 
      public:
        void commit() {
          core::lock_scope lock(m_acc);
 
          if (m_ops.empty())
            return;
 
          GAIA_PROF_SCOPE(cmdbuf::commit);
 
          // Build flags + allocate entities
          if (m_nextTemp > 0) {
            GAIA_PROF_SCOPE(cmdbuf::alloc);
 
            // Bit layout for each temporary entity:
            // bit 0 -> marked for destruction (DEL_ENTITY recorded)
            // bit 1 -> used as a relation target (appeared as target in component ops)
            // bit 2 -> used as a relation source / dependency (appeared as other in component ops)
            m_tmpFlags.resize(m_nextTemp * 3);
 
            // Pre-map surviving temps for ADD/CPY (avoid allocating canceled temps)
            if (m_temp2real.size() < m_nextTemp) {
              const auto from = m_temp2real.size();
              m_temp2real.resize(m_nextTemp);
              GAIA_FOR2(from, m_nextTemp) m_temp2real[i] = EntityBad;
            }
 
            // Build all flags
            for (const Op& o: m_ops) {
              // Set flag bits
              if (is_tmp(o.target)) {
                const uint32_t ti = o.target.id();
 
                if (o.type == OpType::DEL_ENTITY)
                  m_tmpFlags.set((ti * 3) + 0, true);
                else if (is_rel(o.type))
                  m_tmpFlags.set((ti * 3) + 1, true);
              }
 
              if (is_tmp(o.other) && o.other.id() < m_tmpFlags.size())
                m_tmpFlags.set((o.other.id() * 3) + 2, true);
            }
 
            // Allocate real entities for the surviving temporaries
            for (const Op& o: m_ops) {
              if (!is_tmp(o.target))
                continue;
 
              const uint32_t ti = o.target.id();
              if (is_canceled_temp(ti))
                continue;
 
              if (o.type == OpType::ADD_ENTITY) {
                if (m_temp2real[ti] == EntityBad)
                  m_temp2real[ti] = m_world.add(o.target.kind());
              } else if (o.type == OpType::CPY_ENTITY) {
                if (m_temp2real[ti] == EntityBad) {
                  const Entity src = resolve(o.other);
                  if (src != EntityBad)
                    m_temp2real[ti] = m_world.copy(src);
                }
              }
            }
          }
 
          // Sort by (target, other), reduce last-wins, apply relations.
          // DEL_COMPONENT last per target.
          if (m_needsSort) {
            GAIA_PROF_SCOPE(cmdbuf::sort);
 
            m_needsSort = false;
            core::sort(m_ops.begin(), m_ops.end(), [](const Op& a, const Op& b) {
              if (a.target != b.target)
                return a.target < b.target;
              if (a.other != b.other)
                return a.other < b.other;
              return false;
            });
          }
 
          // Replay batched operations
          Entity lastKey = EntityBad;
          Entity lastResolved = EntityBad;
          auto resolve_cached = [&](Entity e) {
            if (e == lastKey)
              return lastResolved;
            lastKey = e;
            return lastResolved = resolve(e);
          };
          for (uint32_t p = 0; p < m_ops.size();) {
            GAIA_PROF_SCOPE(cmdbuf::merge);
 
            const Entity tgtKey = m_ops[p].target;
 
            const bool tgtIsTemp = is_tmp(tgtKey);
            const uint32_t ti = tgtIsTemp ? tgtKey.id() : 0u;
            const Entity tgtReal =
                tgtIsTemp ? (ti < m_temp2real.size() ? m_temp2real[ti] : EntityBad) : resolve_cached(tgtKey);
 
            // Range for this target
            uint32_t q = p;
            bool hasDelEntity = false;
            while (q < m_ops.size() && m_ops[q].target == tgtKey) {
              if (m_ops[q].type == OpType::DEL_ENTITY)
                hasDelEntity = true;
              ++q;
            }
 
            // Skip canceled or non-existent temporary entities
            if (tgtReal == EntityBad) {
              p = q;
              continue;
            }
            if (tgtIsTemp && is_canceled_temp(ti)) {
              p = q;
              continue;
            }
 
            enum : uint8_t { F_ADD = 1 << 0, F_ADD_DATA = 1 << 1, F_SET = 1 << 2, F_DEL = 1 << 3 };
 
            // Emit relation groups.
            // Inside [p..q) range (same target), process groups by 'other'.
            // We perform per-component reduction.
            for (uint32_t i = p; i < q;) {
              const Entity othKey = m_ops[i].other;
              const Entity othReal = resolve_cached(othKey);
 
              // Group ops with same (target, other)
              uint32_t j = i + 1;
              while (j < q && m_ops[j].other == othKey)
                ++j;
 
              if (tgtReal != EntityBad) {
                const uint32_t groupSize = j - i;
                // Fast path - single op
                if (groupSize == 1) {
                  const Op& op = m_ops[i];
                  switch (op.type) {
                    case OpType::DEL_COMPONENT:
                      World::EntityBuilder(m_world, tgtReal).del(othReal);
                      break;
                    case OpType::ADD_COMPONENT:
                      World::EntityBuilder(m_world, tgtReal).add(othReal);
                      break;
                    case OpType::ADD_COMPONENT_DATA:
                      World::EntityBuilder(m_world, tgtReal).add(othReal);
                      GAIA_FALLTHROUGH;
                    case OpType::SET_COMPONENT: {
                      const auto& ec = m_world.m_recs.entities[tgtReal.id()];
                      const auto row = tgtReal.kind() == EntityKind::EK_Uni ? 0U : ec.row;
                      const auto compIdx = ec.pChunk->comp_idx(othReal);
                      auto* pComponentData = (void*)ec.pChunk->comp_ptr_mut(compIdx, 0);
 
                      // Component data
                      m_data.seek(op.off);
                      const auto& item = m_world.comp_cache().get(othReal);
                      item.load(&m_data, pComponentData, row, row + 1, ec.pChunk->capacity());
                    } break;
                    default:
                      break;
                  }
                }
                // Slow path: merge multiple ops
                else {
                  uint8_t mask = 0;
                  uint32_t dataPos = 0;
 
                  for (uint32_t k = i; k < j; ++k) {
                    const Op& op = m_ops[k];
                    switch (op.type) {
                      case OpType::ADD_COMPONENT:
                        mask |= F_ADD;
                        break;
                      case OpType::ADD_COMPONENT_DATA:
                        mask |= F_ADD_DATA;
                        dataPos = op.off;
                        break;
                      case OpType::SET_COMPONENT:
                        mask |= F_SET;
                        dataPos = op.off;
                        break;
                      case OpType::DEL_COMPONENT:
                        mask |= F_DEL;
                        break;
                      default:
                        break;
                    }
                  }
 
                  const bool hasAdd = mask & F_ADD;
                  const bool hasAddData = mask & F_ADD_DATA;
                  const bool hasSet = mask & F_SET;
                  const bool hasDel = mask & F_DEL;
 
                  // 1) ADD(+DATA) + DEL = no-op
                  if (hasDel && (hasAdd || hasAddData)) {
                  }
                  // 2) DEL only
                  else if (hasDel) {
                    World::EntityBuilder(m_world, tgtReal).del(othReal);
                  }
                  // 3) ADD_WITH_DATA or ADD+SET = ADD_WITH_DATA
                  else if (hasAddData || (hasAdd && hasSet)) {
                    World::EntityBuilder(m_world, tgtReal).add(othReal);
 
                    const auto& ec = m_world.m_recs.entities[tgtReal.id()];
                    const auto row = tgtReal.kind() == EntityKind::EK_Uni ? 0U : ec.row;
                    const auto compIdx = ec.pChunk->comp_idx(othReal);
                    auto* pComponentData = (void*)ec.pChunk->comp_ptr_mut(compIdx, 0);
 
                    // Component data
                    m_data.seek(dataPos);
                    const auto& item = m_world.comp_cache().get(othReal);
                    item.load(&m_data, pComponentData, row, row + 1, ec.pChunk->capacity());
                  }
                  // 4) ADD only
                  else if (hasAdd) {
                    World::EntityBuilder(m_world, tgtReal).add(othReal);
                  }
                  // 5) SET only
                  else if (hasSet) {
                    const auto& ec = m_world.m_recs.entities[tgtReal.id()];
                    const auto row = tgtReal.kind() == EntityKind::EK_Uni ? 0U : ec.row;
                    const auto compIdx = ec.pChunk->comp_idx(othReal);
                    auto* pComponentData = (void*)ec.pChunk->comp_ptr_mut(compIdx, 0);
 
                    // Component data
                    m_data.seek(dataPos);
                    const auto& item = m_world.comp_cache().get(othReal);
                    item.load(&m_data, pComponentData, row, row + 1, ec.pChunk->capacity());
                  }
                }
              }
 
              // Advance to next component group
              i = j;
            }
 
            // Safely delete entity only if it was actually created
            if (hasDelEntity)
              m_world.del(tgtReal);
 
            // Advance to next target group
            p = q;
          }
 
          clear();
        }
      };
    } // namespace detail
 
    using CommandBufferST = detail::CommandBuffer<AccessContextST>;
    using CommandBufferMT = detail::CommandBuffer<AccessContextMT>;
 
    inline CommandBufferST* cmd_buffer_st_create(World& world) {
      return new CommandBufferST(world);
    }
    inline void cmd_buffer_destroy(CommandBufferST& cmdBuffer) {
      delete &cmdBuffer;
    }
    inline void cmd_buffer_commit(CommandBufferST& cmdBuffer) {
      cmdBuffer.commit();
    }
 
    inline CommandBufferMT* cmd_buffer_mt_create(World& world) {
      return new CommandBufferMT(world);
    }
    inline void cmd_buffer_destroy(CommandBufferMT& cmdBuffer) {
      delete &cmdBuffer;
    }
    inline void cmd_buffer_commit(CommandBufferMT& cmdBuffer) {
      cmdBuffer.commit();
    }
  } // namespace ecs
} // namespace gaia