builder_i.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "../query/builder_i.hpp"
 
namespace flecs 
{

template<typename Base, typename ... Components>
struct system_builder_i : query_builder_i<Base, Components ...> {
private:
    using BaseClass = query_builder_i<Base, Components ...>;
 
public:
    system_builder_i(ecs_system_desc_t *desc) 
        : BaseClass(&desc->query)
        , desc_(desc) { }

    Base& kind(entity_t phase) {
        flecs::entity_t cur_phase = ecs_get_target(
            world_v(), desc_->entity, EcsDependsOn, 0);
        if (cur_phase) {
            ecs_remove_id(world_v(), desc_->entity, ecs_dependson(cur_phase));
            ecs_remove_id(world_v(), desc_->entity, cur_phase);
        }
        if (phase) {
            ecs_add_id(world_v(), desc_->entity, ecs_dependson(phase));
            ecs_add_id(world_v(), desc_->entity, phase);
        }
        return *this;
    }

    template <typename E, if_t<is_enum<E>::value> = 0>
    Base& kind(E phase)
    {
        const auto& et = enum_type<E>(this->world_v());
        flecs::entity_t target = et.entity(phase);
        return this->kind(target);
    }

    template <typename Phase>
    Base& kind() {
        return this->kind(_::type<Phase>::id(world_v()));
    }

    Base& multi_threaded(bool value = true) {
        desc_->multi_threaded = value;
        return *this;
    }

    Base& immediate(bool value = true) {
        desc_->immediate = value;
        return *this;
    }

    Base& interval(ecs_ftime_t interval) {
        desc_->interval = interval;
        return *this;
    }

    Base& rate(const entity_t tick_source, int32_t rate) {
        desc_->rate = rate;
        desc_->tick_source = tick_source;
        return *this;
    }

    Base& rate(int32_t rate) {
        desc_->rate = rate;
        return *this;
    }

    template<typename T>
    Base& tick_source() {
        desc_->tick_source = _::type<T>::id(world_v());
        return *this;
    }

    Base& tick_source(flecs::entity_t tick_source) {
        desc_->tick_source = tick_source;
        return *this;
    }

    Base& ctx(void *ptr) {
        desc_->ctx = ptr;
        return *this;
    }

    Base& run(ecs_iter_action_t action) {
        desc_->run = action;
        return *this;
    }
 
protected:
    virtual flecs::world_t* world_v() override = 0;
 
private:
    operator Base&() {
        return *static_cast<Base*>(this);
    }
 
    ecs_system_desc_t *desc_;
};
 
}