system.inl

#include "gaia/config/config.h"
 
#include <cinttypes>
// TODO: Currently necessary due to std::function. Replace them!
#include <functional>
 
#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_ {
      using TSystemExecFunc = std::function<void(Query&, QueryExecType)>;
 
      Entity entity = EntityBad;
      TSystemExecFunc on_each_func;
      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() {
        [[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
 
        on_each_func(query, execType);
      }
 
      GAIA_NODISCARD mt::JobHandle job_handle() {
        if (jobHandle == (mt::JobHandle)mt::JobNull_t{}) {
          auto& tp = mt::ThreadPool::get();
          mt::Job syncJob;
          syncJob.func = [&]() {
            exec();
          };
          syncJob.flags = mt::JobCreationFlags::ManualDelete;
          jobHandle = tp.add(syncJob);
        }
        return jobHandle;
      }
 
      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() {
        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;
      }
 
    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) {
        validate();
        data().query.template all<T>(options);
        return *this;
      }
 
      template <typename T>
      SystemBuilder& any(const QueryTermOptions& options) {
        validate();
        data().query.template any<T>(options);
        return *this;
      }
 
      template <typename T>
      SystemBuilder& or_(const QueryTermOptions& options) {
        validate();
        data().query.template or_<T>(options);
        return *this;
      }
 
      template <typename T>
      SystemBuilder& no(const QueryTermOptions& options) {
        validate();
        data().query.template no<T>(options);
        return *this;
      }
 
      //------------------------------------------------
 
      template <typename T>
      SystemBuilder& all() {
        validate();
        data().query.all<T>();
        return *this;
      }
 
      template <typename T>
      SystemBuilder& any() {
        validate();
        data().query.any<T>();
        return *this;
      }
 
      template <typename T>
      SystemBuilder& or_() {
        validate();
        data().query.or_<T>();
        return *this;
      }
 
      template <typename T>
      SystemBuilder& no() {
        validate();
        data().query.no<T>();
        return *this;
      }
 
      template <typename T>
      SystemBuilder& changed() {
        validate();
        data().query.changed<T>();
        return *this;
      }
 
      //------------------------------------------------
 
      SystemBuilder& depth_order(Entity relation = ChildOf) {
        data().query.depth_order(relation);
        return *this;
      }
 
      template <typename Rel>
      SystemBuilder& depth_order() {
        data().query.template depth_order<Rel>();
        return *this;
      }
 
      //------------------------------------------------
 
      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) {
        data().query.group_by<T>(func);
        return *this;
      }
 
      template <typename Rel, typename Tgt>
      SystemBuilder& group_by(TGroupByFunc func = group_by_func_default) {
        data().query.group_by<Rel, Tgt>(func);
        return *this;
      }
 
      //------------------------------------------------
 
      SystemBuilder& group_dep(Entity relation) {
        data().query.group_dep(relation);
        return *this;
      }
 
      template <typename Rel>
      SystemBuilder& group_dep() {
        data().query.template group_dep<Rel>();
        return *this;
      }
 
      //------------------------------------------------
 
      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() {
        data().query.template group_id<T>();
        return *this;
      }
 
      //------------------------------------------------
 
      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& mode(QueryExecType type) {
        auto& ctx = data();
        ctx.execType = type;
        return *this;
      }
 
      template <typename Func>
      SystemBuilder& on_each(Func func) {
        validate();
 
        auto& ctx = data();
        using InputArgs = decltype(core::func_args(&Func::operator()));
 
  #if GAIA_ASSERT_ENABLED
        // Make sure we only use components specified in the query.
        // Constness is respected. Therefore, if a type is const when registered to query,
        // it has to be const (or immutable) also in each().
        if constexpr (
            !std::is_invocable_v<Func, IterAll&> && //
            !std::is_invocable_v<Func, Iter&> && //
            !std::is_invocable_v<Func, IterDisabled&> //
        ) {
          auto& queryInfo = ctx.query.fetch();
          GAIA_ASSERT(ctx.query.unpack_args_into_query_has_all(queryInfo, InputArgs{}));
        }
  #endif
 
        ctx.on_each_func = [func](Query& query, QueryExecType execType) {
          query.each(func, execType);
        };
 
        return (SystemBuilder&)*this;
      }
 
      GAIA_NODISCARD Entity entity() const {
        return m_entity;
      }
 
      void exec() {
        auto& ctx = data();
        ctx.exec();
      }
 
      GAIA_NODISCARD mt::JobHandle job_handle() {
        auto& ctx = data();
        return ctx.job_handle();
      }
    };
 
  } // namespace ecs
} // namespace gaia
 
#endif