builder.hpp

Go to the documentation of this file.

 
#pragma once
 
#define ECS_EVENT_DESC_ID_COUNT_MAX (8)
 
namespace flecs {
 
template <typename Base, typename E>
struct event_builder_base {
    event_builder_base(flecs::world_t *world, flecs::entity_t event)
        : world_(world)
        , desc_{}
        , ids_{}
        , ids_array_{}
    {
        desc_.event = event;
    }
 
    template <typename T>
    Base& id() {
        ids_.array = ids_array_;
        ids_.array[ids_.count] = _::type<T>().id(world_);
        ids_.count ++;
        return *this;
    }
    
    template <typename First, typename Second>
    Base& id() {
        return id(
            ecs_pair(_::type<First>::id(this->world_), 
                _::type<Second>::id(this->world_)));
    }
 
    template <typename First>
    Base& id(entity_t second) {
        return id(ecs_pair(_::type<First>::id(this->world_), second));
    }
 
    Base& id(entity_t first, entity_t second) {
        return id(ecs_pair(first, second));
    }
 
    template <typename Enum, if_t<is_enum<Enum>::value> = 0>
    Base& id(Enum value) {
        const auto& et = enum_type<Enum>(this->world_);
        flecs::entity_t target = et.entity(value);
        return id(et.entity(), target);
    }
 
    Base& id(flecs::id_t id) {
        ids_.array = ids_array_;
        ids_.array[ids_.count] = id;
        ids_.count ++;
        return *this;
    }
 
    Base& entity(flecs::entity_t e) {
        desc_.entity = e;
        return *this;
    }
 
    Base& table(flecs::table_t *t, int32_t offset = 0, int32_t count = 0) {
        desc_.table = t;
        desc_.offset = offset;
        desc_.count = count;
        return *this;
    }
 
    Base& ctx(const E* ptr) {
        desc_.const_param = ptr;
        return *this;
    }
 
    Base& ctx(E* ptr) {
        desc_.param = ptr;
        return *this;
    }
 
    void emit() {
        ids_.array = ids_array_;
        desc_.ids = &ids_;
        desc_.observable = const_cast<flecs::world_t*>(ecs_get_world(world_));
        ecs_emit(world_, &desc_);
    }
 
    void enqueue() {
        ids_.array = ids_array_;
        desc_.ids = &ids_;
        desc_.observable = const_cast<flecs::world_t*>(ecs_get_world(world_));
        ecs_enqueue(world_, &desc_);
    }
 
protected:
    flecs::world_t *world_;
    ecs_event_desc_t desc_;
    flecs::type_t ids_;
    flecs::id_t ids_array_[ECS_EVENT_DESC_ID_COUNT_MAX];
 
private:
    operator Base&() {
        return *static_cast<Base*>(this);
    }
};
 
struct event_builder : event_builder_base<event_builder, void> {
    using event_builder_base::event_builder_base;
};
 
template <typename E>
struct event_builder_typed : event_builder_base<event_builder_typed<E>, E> {
private:
    using Class = event_builder_typed<E>;
 
public:
    using event_builder_base<Class, E>::event_builder_base;
 
    Class& ctx(const E& ptr) {
        this->desc_.const_param = &ptr;
        return *this;
    }
 
    Class& ctx(E&& ptr) {
        this->desc_.param = &ptr;
        return *this;
    }
};
 
}