imguiservice.h

/* 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 "imguiicon.h"
#include "imguistyle.h"
 
// External includes
#include <nap/service.h>
#include <renderwindow.h>
#include <inputevent.h>
#include <nap/resourceptr.h>
#include <descriptorsetallocator.h>
#include <nap/signalslot.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";
        inline constexpr const char* frame      = "frame.png";
    }
 
 
    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;
 
        void setPalette(gui::EColorScheme palette);
 
        ImGuiContext* processInputEvent(const InputEvent& event);
 
        bool isCapturingKeyboard(ImGuiContext* context);
 
        bool isCapturingMouse(ImGuiContext* context);
 
        void addInputCharachter(ImGuiContext* context, nap::uint character);
 
        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:
        bool init(utility::ErrorState& error) override;
 
        void getDependentServices(std::vector<rtti::TypeInfo>& dependencies) override;
 
        void update(double deltaTime) override;
 
        void postUpdate(double deltaTime) override;
 
        void preShutdown() override;
 
        void shutdown() override;
 
        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;                         
            int mDisplayIndex                               = -1;                           
            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 nap::RenderWindow& window);
 
        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;
        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 mReferenceScale = 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;
 
        // Vulkan data associated with ImGUI
        std::unique_ptr<DescriptorSetAllocator> mAllocator;                             
        VkDescriptorPool mDescriptorPool = VK_NULL_HANDLE;                              
        VkDescriptorSetLayout mDescriptorSetLayout = VK_NULL_HANDLE;                    
        VkSampler mSampler = VK_NULL_HANDLE;                                            
        mutable std::unordered_map<const Texture2D*, VkDescriptorSet> mDescriptors;     
    };
}