NAP: imguiservice.h Source File

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */


#pragma once


// Local Includes

#include "imgui/imgui.h"

#include "imguiicon.h"


// External includes

#include <nap/service.h>

#include <renderwindow.h>

#include <inputevent.h>

#include <nap/resourceptr.h>

#include <descriptorsetallocator.h>

#include <nap/signalslot.h>

#include <color.h>


// ImGUI forward declares

struct ImGuiContext;


namespace nap

{

    // Forward Declares

    class RenderService;

    class Display;

    class GuiWindow;

    class IMGuiService;


    namespace icon

    {

        inline constexpr const char* save       = "save.png";

        inline constexpr const char* saveAs     = "save_as.png";

        inline constexpr const char* cancel     = "cancel.png";

        inline constexpr const char* ok         = "ok.png";

        inline constexpr const char* del        = "delete.png";

        inline constexpr const char* file       = "file.png";

        inline constexpr const char* help       = "help.png";

        inline constexpr const char* settings   = "settings.png";

        inline constexpr const char* reload     = "reload.png";

        inline constexpr const char* folder     = "folder.png";

        inline constexpr const char* load       = "load.png";

        inline constexpr const char* info       = "info.png";

        inline constexpr const char* warning    = "warning.png";

        inline constexpr const char* error      = "error.png";

        inline constexpr const char* copy       = "copy.png";

        inline constexpr const char* paste      = "paste.png";

        inline constexpr const char* insert     = "insert.png";

        inline constexpr const char* edit       = "edit.png";

        inline constexpr const char* remove     = "remove.png";

        inline constexpr const char* add        = "add.png";

        inline constexpr const char* change     = "change.png";

        inline constexpr const char* subtract   = "subtract.png";

    }


    // GUI

    namespace gui

    {

        inline constexpr float dpi = 96.0f;

        inline constexpr int pointerInvalidID = -3;

        inline constexpr int pointerMouseID = -2;

        inline constexpr int pointerTouchID = -1;


        enum class EColorScheme

        {

            Light       = 0,

            Dark        = 1,

            HyperDark   = 2,

            Classic     = 3,

            Custom      = 4

        };


        struct NAPAPI ColorPalette

        {

            ColorPalette() = default;

            RGBColor8 mBackgroundColor = { 0x2D, 0x2D, 0x2D };

            RGBColor8 mDarkColor = { 0x00, 0x00, 0x00 };

            RGBColor8 mMenuColor = { 0x8D, 0x8B, 0x84 };

            RGBColor8 mFront1Color = { 0x8D, 0x8B, 0x84 };

            RGBColor8 mFront2Color = { 0xAE, 0xAC, 0xA4 };

            RGBColor8 mFront3Color = { 0xCD, 0xCD, 0xC3 };

            RGBColor8 mFront4Color = { 0xFF, 0xFF, 0xFF };

            RGBColor8 mHighlightColor1 = { 0x29, 0x58, 0xff };

            RGBColor8 mHighlightColor2 = { 0xD6, 0xFF, 0xA3 };

            RGBColor8 mHighlightColor3 = { 0xFF, 0xEA, 0x30 };

            RGBColor8 mHighlightColor4 = { 0xFF, 0x50, 0x50 };

            bool mInvertIcon = false;

        };


        struct NAPAPI Style

        {

            Style() = default;

            bool mAntiAliasedLines = true;

            bool mAntiAliasedFill = true;

            glm::vec2 mWindowPadding = { 10.0, 10.0f };

            float mWindowRounding = 0.0f;

            glm::vec2 mFramePadding = { 5.0f, 5.0f };

            float mFrameRounding = 0.0f;

            glm::vec2 mItemSpacing = { 12.0f, 6.0f };

            glm::vec2 mItemInnerSpacing = { 8.0f, 6.0f };

            float mIndentSpacing = 25.0f;

            float mScrollbarSize = 13.0f;

            float mScrollbarRounding = 0.0f;

            float mGrabMinSize = 5.0f;

            float mGrabRounding = 0.0f;

            float mWindowBorderSize = 0.0f;

            float mPopupRounding = 0.0f;

            float mChildRounding = 0.0f;

            glm::vec2 mWindowTitleAlign = { 0.5f, 0.5f };

            float mPopupBorderSize = 0.0f;

            float mTabRounding = 0.0f;

            glm::vec2 mTouchExtraPadding = { 0.0f, 0.0f };

        };

    }


    class NAPAPI IMGuiServiceConfiguration : public ServiceConfiguration

    {

        RTTI_ENABLE(ServiceConfiguration)

    public:

        gui::EColorScheme mColorScheme = gui::EColorScheme::Dark;

        float mFontSize = 17.0f;

        float mScale = 1.0f;

        std::string mFontFile = "";

        glm::ivec2 mFontOversampling = { 5, 3 };

        float mFontSpacing = 0.25f;

        gui::ColorPalette mCustomColors;

        gui::Style mStyle;

        virtual rtti::TypeInfo getServiceType() const override  { return RTTI_OF(IMGuiService); }

    };


    class NAPAPI IMGuiService : public Service

    {

        RTTI_ENABLE(Service)

        friend class GuiWindow;

    public:

        IMGuiService(ServiceConfiguration* configuration);


        void draw();


        void selectWindow(nap::ResourcePtr<RenderWindow> window);


        ImGuiContext* getContext(nap::ResourcePtr<RenderWindow> window);


        ImGuiContext* findContext(int windowID);


        float getScale() const;


        float getScale(const ImGuiContext* context) const;


        const gui::ColorPalette& getPalette() const;


        ImGuiContext* processInputEvent(const InputEvent& event);


        bool isCapturingKeyboard(ImGuiContext* context);


        bool isCapturingMouse(ImGuiContext* context);


        ImTextureID getTextureHandle(const nap::Texture2D& texture) const;


        nap::Icon& getIcon(std::string&& name);


        bool loadIcon(const std::string& name, const nap::Module& module, utility::ErrorState& error);


    protected:

        virtual bool init(utility::ErrorState& error) override;


        virtual void getDependentServices(std::vector<rtti::TypeInfo>& dependencies) override;


        virtual void update(double deltaTime) override;


        virtual void postUpdate(double deltaTime) override;


        virtual void preShutdown() override;


        virtual void shutdown() override;


        virtual void registerObjectCreators(rtti::Factory& factory) override;


    private:


        struct NAPAPI GUIContext

        {

            GUIContext(ImGuiContext* context, ImGuiStyle* style);

            ~GUIContext();


            using ESource = PointerEvent::ESource;

            static constexpr int keyCount = 512;

            using KeyArray = std::array<bool, keyCount>;


            std::array<bool,3> mMousePressed                = { false };

            std::array<bool,3> mMouseRelease                = { false };

            std::array<bool,3> mModPressed                  = { false };

            std::array<bool,3> mModRelease                  = { false };

            std::array<int, 3> mPointerID                   = { gui::pointerInvalidID };

            KeyArray mKeyPressed                            = { false };

            std::vector<int> mKeyRelease;

            glm::ivec2 mMousePosition                       = { 0, 0 };

            float mMouseWheel                               = 0.0f;

            float mScale                                    = 1.0f;

            const Display* mDisplay                         = nullptr;

            ImGuiContext* mContext                          = nullptr;

            ImGuiContext* mPreviousContext                  = nullptr;

            ImGuiStyle* mStyle                              = nullptr;


            // Activates current context

            void activate();


            // Deactivates current context, restores previous

            void deactivate();

        };


        void onWindowAdded(RenderWindow& window);

        nap::Slot<RenderWindow&> mWindowAddedSlot   = { this, &IMGuiService::onWindowAdded };


        void onWindowRemoved(RenderWindow& window);

        nap::Slot<RenderWindow&> mWindowRemovedSlot = { this, &IMGuiService::onWindowRemoved };


        void onWindowEvent(const WindowEvent& windowEvent);

        nap::Slot<const WindowEvent&> mWindowEventSlot = { this, &IMGuiService::onWindowEvent };


        void createVulkanResources(nap::RenderWindow& window);


        void newFrame(RenderWindow& window, GUIContext& context, double deltaTime);


        void pushScale(GUIContext& context, const Display& display);


        void handleKeyEvent(const KeyEvent& keyEvent, GUIContext& context);


        void handlePointerEvent(const PointerEvent& pointerEvent, GUIContext& context);


        void handleTouchEvent(const TouchEvent& touchEvent, GUIContext& context);


        // Everything related to ImGUI

        RenderService* mRenderService = nullptr;

        mutable std::unordered_map<const Texture2D*, VkDescriptorSet> mDescriptors;

        std::unique_ptr<DescriptorSetAllocator> mAllocator;

        std::unordered_map<RenderWindow*, std::unique_ptr<GUIContext>> mContexts;

        std::unique_ptr<ImFontAtlas> mFontAtlas = nullptr;

        std::unique_ptr<ImGuiStyle> mStyle = nullptr;

        float mGuiScale = 1.0f;

        float mDPIScale = 1.0f;


        // Selected colour palette and style

        IMGuiServiceConfiguration* mConfiguration = nullptr;

        const gui::ColorPalette* mColorPalette = nullptr;


        // Icons

        std::unordered_map<std::string, std::unique_ptr<Icon>> mIcons;

    };

}