observer.h

#pragma once
 
#include "gaia/config/config.h"
 
#include <cinttypes>
 
#include "gaia/ecs/id.h"
#include "gaia/ecs/observer_event.h"
#include "gaia/ecs/query.h"
#include "gaia/util/move_func.h"
 
#if GAIA_OBSERVERS_ENABLED
namespace gaia {
  namespace ecs {
    class World;
    class Archetype;
 
  #if GAIA_PROFILER_CPU
    inline constexpr const char* sc_observer_query_func_str = "Observer_exec";
    util::str_view entity_name(const World& world, Entity entity);
  #endif
 
    struct ObserverContext {
      World* world;
      Entity entity;
      ObserverEvent event;
      Archetype* archetype; // Current archetype
      Archetype* archetype_prev; // Previous archetype (for OnAdd/OnDel)
      uint32_t index_in_chunk;
      Chunk* chunk;
      const void* old_ptr; // Previous component value (OnSet only)
    };
 
    struct ObserverPlan {
      enum class ExecKind : uint8_t { DirectQuery, DirectFast, DiffLocal, DiffPropagated, DiffFallback };
      enum class FastPath : uint8_t { None, SinglePositiveTerm, SingleNegativeTerm, Disabled };
      using TObserverIterFunc = util::MoveFunc<void(Iter&)>;
 
      struct DiffPlan {
        enum class DispatchKind : uint8_t { LocalTargets, PropagatedTraversal, GlobalFallback };
 
        Entity bindingVar = EntityBad;
        Entity bindingRelation = EntityBad;
        Entity traversalRelation = EntityBad;
 
        DispatchKind dispatchKind = DispatchKind::LocalTargets;
        QueryTravKind travKind = QueryTravKind::None;
        bool enabled = false;
        uint8_t travDepth = QueryTermOptions::TravDepthUnlimited;
        QueryEntityArray traversalTriggerTerms{};
        uint8_t traversalTriggerTermCount = 0;
        QueryEntityArray traversalRelations{};
        uint8_t traversalRelationCount = 0;
      };
 
      FastPath fastPath = FastPath::None;
      uint8_t termCount = 0;
      bool hasNegativeTerm = false;
      bool monitorsQuery = false;
      ExecKind execKind = ExecKind::DirectQuery;
      DiffPlan diff;
 
      void refresh_exec_kind() {
        if (monitorsQuery || diff.enabled) {
          switch (diff.dispatchKind) {
            case DiffPlan::DispatchKind::LocalTargets:
              execKind = ExecKind::DiffLocal;
              break;
            case DiffPlan::DispatchKind::PropagatedTraversal:
              execKind = ExecKind::DiffPropagated;
              break;
            case DiffPlan::DispatchKind::GlobalFallback:
              execKind = ExecKind::DiffFallback;
              break;
          }
        } else if (fastPath == FastPath::SinglePositiveTerm || fastPath == FastPath::SingleNegativeTerm)
          execKind = ExecKind::DirectFast;
        else
          execKind = ExecKind::DirectQuery;
      }
 
      GAIA_NODISCARD ExecKind exec_kind() const {
        return execKind;
      }
 
      GAIA_NODISCARD bool uses_diff_dispatch() const {
        switch (exec_kind()) {
          case ExecKind::DiffLocal:
          case ExecKind::DiffPropagated:
          case ExecKind::DiffFallback:
            return true;
          case ExecKind::DirectQuery:
          case ExecKind::DirectFast:
            return false;
        }
 
        return false;
      }
 
      GAIA_NODISCARD bool uses_direct_dispatch() const {
        return !uses_diff_dispatch();
      }
 
      GAIA_NODISCARD bool uses_local_diff_targets() const {
        return exec_kind() == ExecKind::DiffLocal;
      }
 
      GAIA_NODISCARD bool uses_propagated_diff_targets() const {
        return exec_kind() == ExecKind::DiffPropagated;
      }
 
      GAIA_NODISCARD bool uses_fallback_diff_dispatch() const {
        return exec_kind() == ExecKind::DiffFallback;
      }
 
      GAIA_NODISCARD bool is_fast_positive() const {
        return fastPath == FastPath::SinglePositiveTerm;
      }
 
      GAIA_NODISCARD bool is_fast_negative() const {
        return fastPath == FastPath::SingleNegativeTerm;
      }
 
      void add_term_desc(QueryOpKind op, bool allowFastPath) {
        ++termCount;
        hasNegativeTerm |= op == QueryOpKind::Not;
 
        if (!allowFastPath) {
          fastPath = FastPath::Disabled;
          return;
        }
 
        if (fastPath == FastPath::Disabled)
          return;
 
        if (termCount != 1) {
          fastPath = FastPath::Disabled;
          return;
        }
 
        switch (op) {
          case QueryOpKind::All:
          case QueryOpKind::Any:
          case QueryOpKind::Or:
            fastPath = FastPath::SinglePositiveTerm;
            break;
          case QueryOpKind::Not:
            fastPath = FastPath::SingleNegativeTerm;
            break;
          default:
            fastPath = FastPath::Disabled;
            break;
        }
 
        refresh_exec_kind();
      }
    };
 
    struct ObserverRuntimeData {
      using TObserverIterFunc = util::MoveFunc<void(Iter&)>;
 
      ObserverRuntimeData() {
        GAIA_FOR(MAX_ITEMS_IN_QUERY) {
          queryTermIds[i] = EntityBad;
        }
      }
 
      Entity entity = EntityBad;
      TObserverIterFunc on_each_func;
      Query query;
      ObserverPlan plan;
      QueryEntityArray queryTermIds{};
      QueryOpKind queryTermOps[MAX_ITEMS_IN_QUERY]{};
      QueryMatchKind queryTermMatchKinds[MAX_ITEMS_IN_QUERY]{};
      uint64_t lastMatchStamp = 0;
 
      void exec(Iter& iter, EntitySpan targets, ObserverEvent reportedEvent);
    };
 
    struct Observer_ {
      Entity entity = EntityBad;
      ObserverEvent event = ObserverEvent::OnAdd;
      bool monitorsQuery = false;
 
      template <typename Serializer>
      void save(Serializer& s) const {
        (void)s;
      }
      template <typename Serializer>
      void load(Serializer& s) {
        (void)s;
      }
    };
 
  } // namespace ecs
} // namespace gaia
#else
namespace gaia {
  namespace ecs {
    struct Observer_ {};
  } // namespace ecs
} // namespace gaia
#endif