Core.hpp

Go to the documentation of this file.

#pragma once
 
#include <concepts>
#include <entt/entt.hpp>
#include <functional>
#include <memory>
#include <typeindex>
#include <unordered_map>
#include <vector>
 
#include "Id.hpp"
#include "Logger.hpp"
#include "plugin/IPlugin.hpp"
#include "scheduler/SchedulerContainer.hpp"
#include "scheduler/Update.hpp"
 
namespace Engine {
 
class Entity;
 
template <typename TScheduler>
concept CScheduler = std::derived_from<TScheduler, Scheduler::AScheduler>;
 
template <typename TPlugin>
concept CPlugin = std::derived_from<TPlugin, IPlugin>;

class Core {
  public:
    using Registry = entt::basic_registry<Id>;

    Core();

    ~Core();

    inline Registry &GetRegistry() { return *_registry; }

    inline const Registry &GetRegistry() const { return *_registry; }

    Entity CreateEntity();

    void KillEntity(Id entity);

    template <typename TResource> TResource &RegisterResource(TResource &&resource);

    template <typename TResource> TResource &GetResource();

    template <typename TResource> const TResource &GetResource() const;

    template <typename TResource> bool HasResource() const;

    template <typename TResource> void DeleteResource();

    template <CScheduler TScheduler, typename... Args> TScheduler &RegisterScheduler(Args &&...args);

    template <CScheduler TScheduler> TScheduler &GetScheduler();

    Scheduler::AScheduler &GetScheduler(std::type_index id);

    template <typename TSchedulerA, typename TSchedulerB> inline void SetSchedulerBefore()
    {
        this->_schedulers.Before<TSchedulerA, TSchedulerB>();
    }

    template <typename TSchedulerA, typename TSchedulerB> inline void SetSchedulerAfter()
    {
        this->_schedulers.After<TSchedulerA, TSchedulerB>();
    }

    template <typename TSchedulerA, typename TSchedulerB> inline void RemoveDependencyAfter()
    {
        this->_schedulers.RemoveDependencyAfter<TSchedulerA, TSchedulerB>();
    }

    template <typename TSchedulerA, typename TSchedulerB> inline void RemoveDependencyBefore()
    {
        this->_schedulers.RemoveDependencyBefore<TSchedulerA, TSchedulerB>();
    }

    bool IsRunning();

    void Stop();

    void RunCore();

    template <CScheduler TScheduler, typename... Systems> decltype(auto) RegisterSystem(Systems... systems);

    template <typename... Systems> decltype(auto) RegisterSystem(Systems... systems);

    template <CScheduler TScheduler, typename System, typename ErrorCallback>
    decltype(auto) RegisterSystemWithErrorHandler(System system, ErrorCallback callback);

    template <typename System, typename ErrorCallback>
    decltype(auto) RegisterSystemWithErrorHandler(System system, ErrorCallback callback);

    template <CScheduler TScheduler> void DeleteScheduler();

    void RunSystems();

    bool IsEntityValid(Id entity) const;

    template <CPlugin... TPlugins> void AddPlugins();

    template <CPlugin TPlugin> bool HasPlugin() const;

    bool HasPlugin(std::type_index type) const;

    void ClearEntities();

    template <CScheduler TScheduler> inline void SetDefaultScheduler()
    {
        SetDefaultScheduler(std::type_index(typeid(TScheduler)));
    }

    void SetDefaultScheduler(std::type_index scheduler);

    void SetErrorPolicyForAllSchedulers(Scheduler::SchedulerErrorPolicy policy);
 
  private:
    template <CPlugin TPlugin> void AddPlugin();
 
  private:
    std::unique_ptr<Registry> _registry;
    Engine::SchedulerContainer _schedulers;
    std::type_index _defaultScheduler = typeid(Engine::Scheduler::Update);
    std::vector<std::type_index> _schedulersToDelete;
    std::unordered_map<std::type_index, std::unique_ptr<IPlugin>> _plugins;
    bool _running = false;
};
} // namespace Engine
 
#include "core/Core.inl"