SystemUI.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/System.hpp"
#include "CeresEngine/Entity/SystemManager.hpp"
 
#include <type_traits>
 
namespace CeresEngine::Editor::UI {
 
    class SystemUI {
        friend class SystemUIRegistry;
 
    private:
        SystemUI* next = nullptr;
 
        SystemUI* previous = nullptr;
 
    public:
        SystemUI();
 
        virtual ~SystemUI();
 
    public:
        [[nodiscard]] virtual String getName() const = 0;
 
        [[nodiscard]] virtual bool supports(SystemManager& systemManager) const = 0;
        virtual void render(SystemManager& systemManager) = 0;
        virtual void addSystem(SystemManager& systemManager) = 0;
        virtual void removeSystem(SystemManager& systemManager) = 0;
    };
 
    template<typename S, bool = std::is_default_constructible_v<S>> class BasicSystemUI : public SystemUI {
    public:
        [[nodiscard]] bool supports(SystemManager& systemManager) const override { return systemManager.has<S>(); }
 
        void render(SystemManager& systemManager) final { render(systemManager.get<S>()); }
 
        virtual void render(S& system) = 0;
 
        void addSystem(SystemManager& systemManager) override {}
 
        void removeSystem(SystemManager& systemManager) override { systemManager.remove<S>(); }
    };
 
    template<typename S> class BasicSystemUI<S, true> : public BasicSystemUI<S, false> {
    public:
        void addSystem(SystemManager& systemManager) override { systemManager.add<S>(); }
    };
 
    template<typename S> class TSystemUI final : public SystemUI {
    public:
        String name;
        std::function<bool(SystemManager&)> supports_;
        std::function<void(SystemManager&)> addSystem_;
        std::function<void(SystemManager&)> removeSystem_;
        std::function<void(S&)> render_;
 
    public:
        template<typename Constructor> CE_EXPLICIT(false) TSystemUI(Constructor&& constructor) { // NOLINT
            name = typeid(S).name();
            supports_ = [](SystemManager& systemManager) {
                return systemManager.has<S>();
            };
            addSystem_ = [](SystemManager& systemManager) {
                if constexpr(std::is_default_constructible_v<S>) { // NOLINT
                    systemManager.add<S>();
                }
            };
            removeSystem_ = [](SystemManager& systemManager) {
                systemManager.remove<S>();
            };
            constructor(*this, name, supports_, addSystem_, removeSystem_, render_);
        }
 
    public:
        [[nodiscard]] bool supports(SystemManager& systemManager) const final {
            if(supports_) {
                return supports_(systemManager);
            }
            return false;
        }
 
        void render(SystemManager& systemManager) final {
            if(render_) {
                render_(systemManager.get<S>());
            }
        }
 
        void addSystem(SystemManager& systemManager) final {
            if(addSystem_) {
                addSystem_(systemManager);
            }
        }
 
        void removeSystem(SystemManager& systemManager) final {
            if(removeSystem_) {
                removeSystem_(systemManager);
            }
        }
 
        [[nodiscard]] String getName() const final { return name; }
    };
 
    class SystemUIRegistry {
        friend class SystemUI;
 
    private:
        static inline SystemUI* first = nullptr;
 
        static inline SystemUI* last = nullptr;
 
    public:
        static void renderUI(SystemManager& systemManager);
    };
 
#define CE_EDITOR_SYSTEM_TOKENPASTE(x, y) x##y
#define CE_EDITOR_SYSTEM_TOKENPASTE2(x, y) CE_EDITOR_SYSTEM_TOKENPASTE(x, y)
#define CE_EDITOR_SYSTEM(...)                                                                                                               \
    static const ::CeresEngine::Editor::UI::TSystemUI<__VA_ARGS__> CE_EDITOR_SYSTEM_TOKENPASTE2(systemUI, __COUNTER__) [[maybe_unused]] = [ \
    ](::CeresEngine::Editor::UI::TSystemUI<__VA_ARGS__> & ui, ::CeresEngine::String & name, auto& supports, auto& add, auto& remove, auto& render) noexcept
#define CE_EDITOR_SYSTEM_ADVANCED(EditorClass) static const EditorClass CE_EDITOR_SYSTEM_TOKENPASTE2(systemUI, EditorClass) [[maybe_unused]]{};
#define CE_EDITOR_SYSTEM_ADVANCED2(Name, ClassName, ...)                                           \
    struct Name##SystemUI final : public ::CeresEngine::Editor::UI::BasicSystemUI<ClassName> {     \
        __VA_ARGS__ [[nodiscard]] ::CeresEngine::String getName() const override { return #Name; } \
    };                                                                                             \
    CE_EDITOR_SYSTEM_ADVANCED(Name##SystemUI)
 
} // namespace CeresEngine::Editor::UI