Core.ipp

Go to the documentation of this file.

#include "Logger.hpp"
#include "core/Core.hpp"
#include "exception/MissingResourceError.hpp"
#include "exception/MissingSchedulerError.hpp"
#include "system/WrappedSystem.hpp"
 
namespace Engine {
 
template <typename TResource> inline TResource &Core::RegisterResource(TResource &&resource)
{
    return this->_registry->ctx().insert_or_assign<TResource>(std::forward<TResource>(resource));
}
 
template <typename TResource> inline TResource &Core::GetResource()
{
    if (!this->_registry->ctx().contains<TResource>())
    {
        throw Exception::MissingResourceError(
            fmt::format("Resource not found in the core registry: {}", typeid(TResource).name()));
    }
    return this->_registry->ctx().get<TResource>();
}
 
template <typename TResource> inline bool Core::HasResource() const
{
    return this->_registry->ctx().contains<TResource>();
}
 
template <typename TResource> inline void Core::DeleteResource() { this->_registry->ctx().erase<TResource>(); }
 
template <typename TResource> inline const TResource &Core::GetResource() const
{
    return this->_registry->ctx().get<TResource>();
}
 
template <CScheduler TScheduler, typename... Args> inline TScheduler &Core::RegisterScheduler(Args &&...args)
{
    this->_schedulers.AddScheduler<TScheduler>(*this, std::forward<Args>(args)...);
    return this->_schedulers.GetScheduler<TScheduler>();
}
 
template <CScheduler TScheduler> void Core::DeleteScheduler()
{
    this->_schedulersToDelete.push_back(std::type_index(typeid(TScheduler)));
}
 
template <CScheduler TScheduler> inline TScheduler &Core::GetScheduler()
{
    return this->_schedulers.GetScheduler<TScheduler>();
}
 
inline Scheduler::AScheduler &Core::GetScheduler(std::type_index id)
{
    if (!this->_schedulers.Contains(id))
    {
        throw Exception::MissingSchedulerError(fmt::format("Scheduler not found in the core: {}", id.name()));
    }
    return *(this->_schedulers.GetScheduler(id));
}
 
template <CScheduler TScheduler, typename... Systems> inline decltype(auto) Core::RegisterSystem(Systems... systems)
{
    return this->_schedulers.GetScheduler<TScheduler>().AddSystems(systems...);
}
 
template <typename TSchedulerA, typename TSchedulerB> void Core::SetSchedulerBefore()
{
    this->_schedulers.Before<TSchedulerA, TSchedulerB>();
}
 
template <typename TSchedulerA, typename TSchedulerB> void Core::SetSchedulerAfter()
{
    this->_schedulers.After<TSchedulerA, TSchedulerB>();
}
 
template <typename TSchedulerA, typename TSchedulerB> void Core::RemoveDependencyAfter()
{
    this->_schedulers.RemoveDependencyAfter<TSchedulerA, TSchedulerB>();
}
 
template <typename TSchedulerA, typename TSchedulerB> void Core::RemoveDependencyBefore()
{
    this->_schedulers.RemoveDependencyBefore<TSchedulerA, TSchedulerB>();
}
 
template <typename... Systems> inline decltype(auto) Core::RegisterSystem(Systems... systems)
{
    if (!this->_schedulers.Contains(_defaultScheduler))
    {
        Log::Warning(fmt::format("Trying to register systems with a default scheduler that does not exist: {}",
                                 _defaultScheduler.name()));
    }
    return this->_schedulers.GetScheduler(_defaultScheduler)->AddSystems(systems...);
}
 
template <CScheduler TScheduler, typename System, typename ErrorCallback>
inline decltype(auto) Core::RegisterSystemWithErrorHandler(System system, ErrorCallback callback)
{
    return this->RegisterSystem<TScheduler>(WrappedSystem(system, callback));
}
 
template <typename System, typename ErrorCallback>
inline decltype(auto) Core::RegisterSystemWithErrorHandler(System system, ErrorCallback callback)
{
    return this->RegisterSystem(WrappedSystem(system, callback));
}
 
template <CPlugin... TPlugins> void Core::AddPlugins() { (AddPlugin<TPlugins>(), ...); }
 
template <CPlugin TPlugin> void Core::AddPlugin()
{
    if (this->_plugins.contains(std::type_index(typeid(TPlugin))))
    {
        Log::Warning(fmt::format("Plugin {} already added", typeid(TPlugin).name()));
    }
    this->_plugins.emplace(std::type_index(typeid(TPlugin)), std::make_unique<TPlugin>(*this));
    this->_plugins.at(std::type_index(typeid(TPlugin)))->Bind();
}
 
template <CPlugin TPlugin> bool Core::HasPlugin() const
{
    return this->_plugins.contains(std::type_index(typeid(TPlugin)));
}
 
template <CScheduler TScheduler> void Core::SetDefaultScheduler()
{
    SetDefaultScheduler(std::type_index(typeid(TScheduler)));
}
 
inline void Core::SetDefaultScheduler(std::type_index scheduler)
{
    if (!this->_schedulers.Contains(scheduler))
    {
        Log::Warning(fmt::format("Trying to set a default scheduler that does not exist: {}", scheduler.name()));
    }
    this->_defaultScheduler = scheduler;
}
} // namespace Engine