system.inl

#include "gaia/config/config.h"
 
#include <cinttypes>
 
#include "gaia/ecs/chunk_iterator.h"
#include "gaia/ecs/id.h"
#include "gaia/ecs/query.h"
#include "gaia/mt/jobhandle.h"
 
#if GAIA_SYSTEMS_ENABLED
namespace gaia {
  namespace ecs {
 
  #if GAIA_PROFILER_CPU
    inline constexpr const char* sc_system_query_func_str = "System_exec";
    util::str_view entity_name(const World& world, Entity entity);
  #endif
 
    struct System_ {
      Entity entity = EntityBad;
      Query query;
      QueryExecType execType = QueryExecType::Default;
      mt::JobHandle jobHandle = mt::JobNull;
 
      System_() = default;
 
      ~System_() {
        // If the query contains a job handle we can only
        // destroy the query once the task associated with the handle is finished.
        if (jobHandle != (mt::JobHandle)mt::JobNull_t{}) {
          auto& tp = mt::ThreadPool::get();
          tp.wait(jobHandle);
          // Job handles created by queries are MANUAL_DELETE so delete it explicitly.
          tp.del(jobHandle);
        }
      }
 
      void exec(World& world) {
        [[maybe_unused]] auto& queryInfo = query.fetch();
 
  #if GAIA_PROFILER_CPU
        const auto name = entity_name(*queryInfo.world(), entity);
        const char* pScopeName = !name.empty() ? name.data() : sc_system_query_func_str;
        GAIA_PROF_SCOPE2(pScopeName);
  #endif
 
        auto* pRuntime = world.systems().data_try(entity);
        GAIA_ASSERT(pRuntime != nullptr);
        if (pRuntime == nullptr || !pRuntime->on_each_func)
          return;
 
        static_cast<void>(pRuntime->on_each_func(query, execType, SystemRuntimeData::RunMode::Immediate));
      }
 
      GAIA_NODISCARD mt::JobHandle job_handle(World& world) {
        if (jobHandle == (mt::JobHandle)mt::JobNull_t{}) {
          auto& tp = mt::ThreadPool::get();
          mt::Job syncJob;
          syncJob.func = [this, &world]() {
            exec(world);
          };
          syncJob.flags = mt::JobCreationFlags::ManualDelete;
          jobHandle = tp.add(GAIA_MOV(syncJob));
        }
        return jobHandle;
      }
 
      GAIA_NODISCARD SchedJob job(World& world) {
        auto* pRuntime = world.systems().data_try(entity);
        GAIA_ASSERT(pRuntime != nullptr);
        if (pRuntime == nullptr || !pRuntime->on_each_func)
          return {};
 
        return pRuntime->on_each_func(query, execType, SystemRuntimeData::RunMode::DeferredJob);
      }
 
      template <typename Serializer>
      void save(Serializer& s) const {
        (void)s;
      }
      template <typename Serializer>
      void load(Serializer& s) {
        (void)s;
      }
    };
 
    class SystemBuilder {
      World& m_world;
      Entity m_entity;
 
      void validate() const {
        GAIA_ASSERT(m_world.valid(m_entity));
      }
 
      System_& data() {
        auto ss = m_world.acc_mut(m_entity);
        auto& sys = ss.smut<System_>();
        return sys;
      }
 
      const System_& data() const {
        auto ss = m_world.acc(m_entity);
        const auto& sys = ss.get<System_>();
        return sys;
      }
 
      SystemRuntimeData& runtime_data() {
        return m_world.systems().data(m_entity);
      }
 
      const SystemRuntimeData& runtime_data() const {
        return m_world.systems().data(m_entity);
      }
 
    public:
      SystemBuilder(World& world, Entity entity): m_world(world), m_entity(entity) {}
 
      //------------------------------------------------
 
 
      SystemBuilder& kind(QueryCacheKind kind) {
        validate();
        data().query.kind(kind);
        return *this;
      }
 
      SystemBuilder& scope(QueryCacheScope scope) {
        validate();
        data().query.scope(scope);
        return *this;
      }
 
      //------------------------------------------------
 
 
      SystemBuilder& add(QueryInput item) {
        validate();
        data().query.add(item);
        return *this;
      }
 
      //------------------------------------------------
 
      SystemBuilder& is(Entity entity, const QueryTermOptions& options = {}) {
        return all(Pair(Is, entity), options);
      }
 
      //------------------------------------------------
 
      SystemBuilder& in(Entity entity, QueryTermOptions options = {}) {
        options.in();
        return all(Pair(Is, entity), options);
      }
 
      //------------------------------------------------
 
      SystemBuilder& all(Entity entity, const QueryTermOptions& options = {}) {
        validate();
        data().query.all(entity, options);
        return *this;
      }
 
      SystemBuilder& any(Entity entity, const QueryTermOptions& options = {}) {
        validate();
        data().query.any(entity, options);
        return *this;
      }
 
      SystemBuilder& or_(Entity entity, const QueryTermOptions& options = {}) {
        validate();
        data().query.or_(entity, options);
        return *this;
      }
 
      SystemBuilder& no(Entity entity, const QueryTermOptions& options = {}) {
        validate();
        data().query.no(entity, options);
        return *this;
      }
 
      SystemBuilder& match_prefab() {
        validate();
        data().query.match_prefab();
        return *this;
      }
 
      SystemBuilder& changed(Entity entity) {
        validate();
        data().query.changed(entity);
        return *this;
      }
 
      template <typename T>
      SystemBuilder& all(const QueryTermOptions& options);
 
      template <typename T>
      SystemBuilder& any(const QueryTermOptions& options);
 
      template <typename T>
      SystemBuilder& or_(const QueryTermOptions& options);
 
      template <typename T>
      SystemBuilder& no(const QueryTermOptions& options);
 
      //------------------------------------------------
 
      template <typename T>
      SystemBuilder& all();
 
      template <typename T>
      SystemBuilder& any();
 
      template <typename T>
      SystemBuilder& or_();
 
      template <typename T>
      SystemBuilder& no();
 
      template <typename T>
      SystemBuilder& changed();
 
      //------------------------------------------------
 
 
      SystemBuilder& depth_order(Entity relation = ChildOf) {
        data().query.depth_order(relation);
        return *this;
      }
 
      template <typename Rel>
      SystemBuilder& depth_order();
 
      //------------------------------------------------
 
      SystemBuilder& group_by(Entity entity, TGroupByFunc func = group_by_func_default) {
        data().query.group_by(entity, func);
        return *this;
      }
 
      template <typename T>
      SystemBuilder& group_by(TGroupByFunc func = group_by_func_default);
 
      template <typename Rel, typename Tgt>
      SystemBuilder& group_by(TGroupByFunc func = group_by_func_default);
 
      //------------------------------------------------
 
      SystemBuilder& group_dep(Entity relation) {
        data().query.group_dep(relation);
        return *this;
      }
 
      template <typename Rel>
      SystemBuilder& group_dep();
 
      //------------------------------------------------
 
      SystemBuilder& group_id(GroupId groupId) {
        data().query.group_id(groupId);
        return *this;
      }
 
      SystemBuilder& group_id(Entity entity) {
        GAIA_ASSERT(!entity.pair());
        data().query.group_id(entity.id());
        return *this;
      }
 
      template <typename T>
      SystemBuilder& group_id();
 
      //------------------------------------------------
 
 
      SystemBuilder& name(const char* name, uint32_t len = 0) {
        m_world.name(m_entity, name, len);
        return *this;
      }
 
      SystemBuilder& name_raw(const char* name, uint32_t len = 0) {
        m_world.name_raw(m_entity, name, len);
        return *this;
      }
 
      SystemBuilder& phase(Entity phaseEntity) {
        validate();
        GAIA_ASSERT(m_world.valid(phaseEntity));
        GAIA_ASSERT(!phaseEntity.pair());
        m_world.add(m_entity, {ChildOf, phaseEntity});
        m_world.add(m_entity, {DependsOn, phaseEntity});
        return *this;
      }
 
      //------------------------------------------------
 
 
      SystemBuilder& mode(QueryExecType type) {
        auto& ctx = data();
        ctx.execType = type;
        return *this;
      }
 
 
      SystemBuilder& ctx(void* pCtx) {
        validate();
        data().query.ctx(pCtx);
        return *this;
      }
 
      GAIA_NODISCARD void* ctx() const {
        validate();
        return data().query.ctx();
      }
 
      SystemBuilder& main_thread(bool required = true) {
        validate();
        data().query.main_thread(required);
        return *this;
      }
 
      SystemBuilder& reads(Entity entity) {
        validate();
        data().query.reads(entity);
        return *this;
      }
 
      template <typename T>
      SystemBuilder& reads() {
        validate();
        data().query.template reads<T>();
        return *this;
      }
 
      SystemBuilder& writes(Entity entity) {
        validate();
        data().query.writes(entity);
        return *this;
      }
 
      template <typename T>
      SystemBuilder& writes() {
        validate();
        data().query.template writes<T>();
        return *this;
      }
 
      template <typename Func, std::enable_if_t<detail::is_query_iter_callback_v<Func>, int> = 0>
      SystemBuilder& on_each(Func func) {
        validate();
 
        auto& runtime = runtime_data();
        runtime.on_each_func = [func](Query& query, QueryExecType execType, SystemRuntimeData::RunMode mode) mutable {
          if (mode == SystemRuntimeData::RunMode::DeferredJob)
            return query.job(func, execType);
 
          query.each_runtime_erased(
              execType, static_cast<void*>(&func), &detail::QueryImpl::template invoke_runtime_iter<Func, Iter>,
              Constraints::EnabledOnly);
          return SchedJob{};
        };
 
        return (SystemBuilder&)*this;
      }
 
      template <typename Func, std::enable_if_t<!detail::is_query_iter_callback_v<Func>, int> = 0>
      SystemBuilder& on_each(Func func);
 
      GAIA_NODISCARD Entity entity() const {
        return m_entity;
      }
 
      void exec() {
        auto& ctx = data();
        ctx.exec(m_world);
      }
 
      GAIA_NODISCARD SchedJob job() {
        auto& ctx = data();
        return ctx.job(m_world);
      }
 
      GAIA_NODISCARD mt::JobHandle job_handle() {
        auto& ctx = data();
        return ctx.job_handle(m_world);
      }
    };
 
  } // namespace ecs
} // namespace gaia
 
  #include "gaia/ecs/system_typed.inl"
#else
namespace gaia {
  namespace ecs {
    struct System_ {};
  } // namespace ecs
} // namespace gaia
#endif