GUI.hpp

#pragma once
#if !RVE_SERVER
#include <RmlUi/Core.h>
#include "SpinLock.hpp"
#include "Queue.hpp"
#include "Map.hpp"
#include "Queryable.hpp"
#include "IInputListener.hpp"
#include "Function.hpp"
#include "Ref.hpp"
#include <RmlUi/Core/ElementDocument.h>
#include "Types.hpp"
 
namespace Rml {
    class Context;
    class ElementDocument;
}
 
namespace RavEngine{
class GUIComponent : public AutoCTTI{
protected:
    friend class RenderEngine;
    struct GUIData;
    
    struct GUIData : public RavEngine::IInputListener{
        Rml::Context* context = nullptr;
        locked_hashmap<std::string, Rml::ElementDocument*, SpinLock> documents;
        ~GUIData();
        
        ConcurrentQueue<Function<void(void)>> q_a, q_b;
        std::atomic<decltype(q_a)*> current = &q_a, inactive = &q_b;
 
        SpinLock mtx;
        
        uint32_t modifier_state = 0;
        
        void AnyActionDown(const int charcode) override;
        
        void AnyActionUp(const int charcode) override;
        
        struct {
            float x = 0, y = 0;
        } MousePos;
        
        template<typename T>
        inline void ExclusiveAccess(const T& func){
            mtx.lock();
            func();
            mtx.unlock();
        }
        
        template<typename T>
        constexpr inline void EnqueueUIUpdate(const T& func){
            current.load()->enqueue(func);
        }
        
        void ScrollY(float amt);
        void MouseMove();
        void SetDimensions(uint32_t width, uint32_t height);
    };
    Ref<GUIData> data = std::make_shared<GUIData>();
    
    
public:
    
    inline decltype(data) GetData() const{
        return data;
    }
    
    void MouseMove(){
        data->MouseMove();
    }
    
    enum class RenderMode{
        Screenspace,
        Worldspace
    } Mode = RenderMode::Screenspace;
    
    GUIComponent();
    
    MOVE_NO_COPY(GUIComponent);
 
    GUIComponent(int width, int height, float DPI = 1);
    
    void SetDPIScale(float scale);
    
    Rml::ElementDocument* AddDocument(const std::string& name);
    
    void RemoveDocument(const std::string& name);
    
    bool IsDocumentLoaded(const std::string& name) const;
    
    Rml::ElementDocument* GetDocument(const std::string& name) const;
    
    void SetDimensions(uint32_t width, uint32_t height){
        data->SetDimensions(width, height);
    }
    
    void MouseX(float normalized_pos);
    
    void MouseY(float normalized_pos);
    
    void ScrollY(float amt){
        data->ScrollY(amt);
    }
 
    template<typename T>
    constexpr inline void ExclusiveAccess(const T& func) {
        data->ExclusiveAccess(func);
    }
 
    template<typename T>
    constexpr inline void EnqueueUIUpdate(const T& func){
        data->EnqueueUIUpdate(func);
    }
    
    static bool LoadFont(const std::string& filename);
    
    void Debug();
        
    bool Update();
    
    bool Render();
};
}
#endif