schedule.hpp

Go to the documentation of this file.

#pragma once
 
#include <co_ecs/registry.hpp>
#include <co_ecs/thread_pool/thread_pool.hpp>
 
#include <co_ecs/system/stage.hpp>
#include <co_ecs/system/system.hpp>
 
namespace co_ecs {
 
class schedule_executor;
 
class schedule {
private:
    using self_type = schedule;
 
public:
    template<typename... Args>
    auto add_init_system(Args&&... args) -> self_type& {
        _init_stage.add_system(std::forward<Args>(args)...);
        return *this;
    }
 
    auto begin_stage(std::string_view name = {}) -> stage& {
        return _stages.emplace_back(*this, name);
    }
 
    auto create_executor(registry& registry, void* user_context = nullptr) -> std::unique_ptr<schedule_executor> {
        std::vector<std::unique_ptr<stage_executor>> stage_executors;
        for (auto& stage : _stages) {
            stage_executors.emplace_back(stage.create_executor(registry, user_context));
        }
 
        return std::make_unique<schedule_executor>(
            registry, std::move(stage_executors), _init_stage.create_executor(registry, user_context));
    }
 
private:
    stage _init_stage{ *this };
    std::vector<stage> _stages;
};
 
class schedule_executor {
public:
    schedule_executor(registry& registry,
        std::vector<std::unique_ptr<stage_executor>> stages,
        std::unique_ptr<stage_executor> init) :
        _registry(registry), _stages(std::move(stages)), _init(std::move(init)) {
        // Run initial systems
        _init->run();
 
        // Flush commands
        command_buffer::flush(_registry);
    }
 
    void run_once() {
        for (auto& stage : _stages) {
            stage->run();
        }
 
        // Flush commands
        command_buffer::flush(_registry);
    }
 
private:
    registry& _registry;
    std::vector<std::unique_ptr<stage_executor>> _stages;
    std::unique_ptr<stage_executor> _init;
};
 
} // namespace co_ecs