ComponentUI.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Entity/Entity.hpp"
 
namespace CeresEngine::Editor::UI {
 
    class ComponentUI {
        friend class ComponentUIRegistry;
 
    private:
        ComponentUI* next = nullptr;
 
        ComponentUI* previous = nullptr;
 
    public:
        ComponentUI();
 
        virtual ~ComponentUI();
 
    public:
        [[nodiscard]] virtual String getName() const = 0;
 
        [[nodiscard]] virtual bool supports(Entity entity) const = 0;
 
        virtual void render(Entity entity) = 0;
 
        virtual void addComponent(Entity entity) = 0;
 
        virtual void removeComponent(Entity entity) = 0;
    };
 
    template<typename C, typename EO = EntityObject<C>> class BasicComponentUI : public ComponentUI {
    public:
        [[nodiscard]] bool supports(Entity entity) const override { return entity.has<C>(); }
 
        void render(Entity entity) final { render(entity.get<C>(), entity); }
 
        virtual void render(C& component, Entity entity) = 0;
 
        void addComponent(Entity entity) override { EO::make(entity); }
 
        void removeComponent(Entity entity) override { entity.remove<C>(); }
    };
 
    template<typename C, typename EO = EntityObject<C>> class TComponentUI : public ComponentUI {
    public:
        String name;
        std::function<void(C&, EO)> render_;
        std::function<bool(Entity)> supports_;
        std::function<void(Entity)> addComponent_;
        std::function<void(Entity)> removeComponent_;
 
    public:
        template<typename Constructor> CE_EXPLICIT(false) TComponentUI(Constructor&& constructor) { // NOLINT
            name = typeid(C).name();
            supports_ = [](Entity entity) {
                return entity.has<C>();
            };
            addComponent_ = [](Entity entity) {
                if constexpr(std::is_default_constructible_v<C>) {
                    entity.add<C>();
                }
            };
            removeComponent_ = [](Entity entity) {
                entity.remove<C>();
            };
            constructor(*this, name, supports_, addComponent_, removeComponent_, render_);
        }
 
    public:
        [[nodiscard]] bool supports(const Entity entity) const override {
            if(supports_) {
                return supports_(entity);
            }
            return false;
        }
 
        void render(Entity entity) override {
            if(render_) {
                render_(entity.get<C>(), entity.as<EO>());
            }
        }
 
        void addComponent(const Entity entity) override {
            if(addComponent_) {
                addComponent_(entity);
            }
        }
 
        void removeComponent(const Entity entity) override {
            if(removeComponent_) {
                removeComponent_(entity);
            }
        }
 
        [[nodiscard]] String getName() const final { return name; }
    };
 
    class ComponentUIRegistry {
        friend class ComponentUI;
 
    private:
        static inline ComponentUI* first = nullptr;
 
        static inline ComponentUI* last = nullptr;
 
    public:
        [[nodiscard]] static bool anySupport(Entity entity);
        static void renderUI(Entity entity);
    };
 
#define CE_EDITOR_COMPONENT_TOKENPASTE(x, y) x##y
#define CE_EDITOR_COMPONENT_TOKENPASTE2(x, y) CE_EDITOR_COMPONENT_TOKENPASTE(x, y)
#define CE_EDITOR_COMPONENT(...)                                                                                                                     \
    static const ::CeresEngine::Editor::UI::TComponentUI<__VA_ARGS__> CE_EDITOR_COMPONENT_TOKENPASTE2(componentUI, __COUNTER__) [[maybe_unused]] = [ \
    ](::CeresEngine::Editor::UI::TComponentUI<__VA_ARGS__> & ui, ::CeresEngine::String & name, auto& supports, auto& add, auto& remove, auto& render) noexcept
#define CE_EDITOR_COMPONENT_ADVANCED(EditorClass) \
    static const EditorClass CE_EDITOR_COMPONENT_TOKENPASTE2(componentUI, EditorClass) [[maybe_unused]] {}
#define CE_EDITOR_COMPONENT_ADVANCED_BEGIN(Name, ...) struct Name##ComponentUI final : public ::CeresEngine::Editor::UI::TComponentUI<__VA_ARGS__>
#define CE_EDITOR_COMPONENT_ADVANCED_DECL(Name)                      \
    Name##ComponentUI() : TComponentUI<__VA_ARGS__>(constructor_){}; \
    static inline const auto constructor_ = [                        \
    ](Name##ComponentUI & ui, ::CeresEngine::String & name, auto& supports, auto& add, auto& remove, auto& render) noexcept
#define CE_EDITOR_COMPONENT_ADVANCED_END(Name) static const Name##ComponentUI CE_EDITOR_COMPONENT_TOKENPASTE2(componentUI, __COUNTER__) [[maybe_unused]]{};
 
} // namespace CeresEngine::Editor::UI