Pipeline.hpp

Go to the documentation of this file.

 
 
#ifndef ECSTASY_SYSTEM_PIPELINE_HPP_
#define ECSTASY_SYSTEM_PIPELINE_HPP_
 
#include <map>
#include <typeindex>
#include <vector>
#include "ecstasy/system/ISystem.hpp"
#include "ecstasy/system/Timer.hpp"
 
namespace ecstasy
{
    class Registry;
 
    class Pipeline {
      public:
        using SystemIterator = std::vector<std::type_index>::const_iterator;
        using PhaseId = std::size_t;
 
        enum class PredefinedPhases : std::size_t {
            OnLoad = 100,     
            PostLoad = 200,   
            PreUpdate = 300,  
            OnUpdate = 400,   
            OnValidate = 500, 
            PostUpdate = 600, 
            PreStore = 700,   
            OnStore = 800,    
        };
 
        class Phase {
          private:
            Phase(Pipeline &pipeline, PhaseId id) : _pipeline(pipeline), _begin(), _size(0), _id(id)
            {
            }
 
          public:
            void run();
 
            [[nodiscard]] constexpr std::size_t getSize() const noexcept
            {
                return _size;
            }
 
            [[nodiscard]] constexpr PhaseId getId() const noexcept
            {
                return _id;
            }
 
            [[nodiscard]] SystemIterator begin() const noexcept;
 
            [[nodiscard]] SystemIterator end() const noexcept;
 
            [[nodiscard]] constexpr Timer &getTimer() noexcept
            {
                return _timer;
            }
 
            [[nodiscard]] constexpr const Timer &getTimer() const noexcept
            {
                return _timer;
            }
 
          private:
            Pipeline &_pipeline;
            std::size_t _begin;
            std::size_t _size;
            PhaseId _id;
            Timer _timer;
 
            [[nodiscard]] constexpr std::size_t begin_idx() const
            {
                return _begin;
            }
 
            [[nodiscard]] constexpr std::size_t end_idx() const
            {
                return _begin + _size;
            }
 
            friend Pipeline;
        };
 
        Pipeline(Registry &registry);
 
        [[nodiscard]] Phase &getPhase(PhaseId id, bool autoRegister = true);
 
        [[nodiscard]] const Phase &getSystemPhase(std::type_index system) const;
 
        template <std::derived_from<ISystem> S>
        [[nodiscard]] const Phase &getSystemPhase() const
        {
            return getSystemPhase(typeid(S));
        }
 
        Phase &registerPhase(PhaseId id);
 
        void addSystem(std::type_index system, PhaseId phase = static_cast<std::size_t>(PredefinedPhases::OnUpdate));
 
        void run();
 
        void run(PhaseId phase);
 
      private:
        std::vector<std::type_index> _systemsIds;
        std::map<PhaseId, Phase> _phases;
        Registry &_registry;
    };
} // namespace ecstasy
 
#endif /* !ECSTASY_SYSTEM_PIPELINE_HPP_ */