VexUI.hpp

Go to the documentation of this file.

 
#pragma once
 
#ifndef VK_NO_PROTOTYPES
    #define VK_NO_PROTOTYPES 1
#endif
#define VMA_STATIC_VULKAN_FUNCTIONS 0
#define VMA_DYNAMIC_VULKAN_FUNCTIONS 1
#include <vk_mem_alloc.h>
#include <vector>
#include <string>
#include <unordered_map>
#include <functional>
#include <glm/glm.hpp>
#include <nlohmann/json.hpp>
#include "Layout.hpp"
#include "components/ECS/ECS.hpp"
#include <SDL3/SDL.h>
#include <volk.h>
 
#include "../../../src/components/backends/vulkan/context.hpp"
#include "../../../src/components/backends/vulkan/Resources.hpp"
#include "components/VirtualFileSystem.hpp"
#include "components/ResolutionManager.hpp"
 
#include "../../../thirdparty/stb/stb_truetype.h"
 
namespace vex {
 
class VexUI;

enum class UIUnitType { Auto, Px, Psp, Vw, Vh, Percent };

struct UIUnitValue {
    float value = 0.f;
    UIUnitType type = UIUnitType::Psp;
 
    UIUnitValue() = default;
    UIUnitValue(float v) : value(v), type(UIUnitType::Psp) {}
    UIUnitValue(float v, UIUnitType t) : value(v), type(t) {}
 
    // Allows backward compatibility.
    UIUnitValue& operator=(float v) {
        value = v;
        return *this;
    }

    void parse(const nlohmann::json& jval);
 
    static UIUnitValue parseJson(const nlohmann::json& jval) {
        UIUnitValue v; v.parse(jval); return v;
    }

    nlohmann::json toJson() const;

    float getPixels(const VexUI* ui) const;
};

struct UIUnitVec2 {
    UIUnitValue x{0.f, UIUnitType::Auto};
    UIUnitValue y{0.f, UIUnitType::Auto};
};

struct FontAtlas {
    stbtt_fontinfo info{};
    std::vector<stbtt_bakedchar> cdata;
    VkImage image = VK_NULL_HANDLE;
    VmaAllocation alloc = VK_NULL_HANDLE;
    VkImageView view = VK_NULL_HANDLE;
    uint32_t texIdx = 0;
    int width = 0, height = 0;
    float ascent = 0.f;
    float descent = 0.f;
    float scale = 0.f;
    float bakedSize = 0.f;
};

struct UIStyle {
    glm::vec4 color{1,1,1,1};
    glm::vec4 bgColor{-1,-1,-1,-1};
    glm::vec4 borderColor = {0,0,0,0};
    std::string font;
    UIUnitValue fontSize{16.f, UIUnitType::Psp};
    UIUnitValue borderWidth{0.f, UIUnitType::Psp};
};

enum class TextAlign { Left, Center, Right };

struct UIQuad {
    uint32_t vertexOffset;
    float texIndex;  // -1 = solid color
};

enum class WidgetType { Container, Label, Image, Button };

struct Widget {
    WidgetType type = WidgetType::Container;
    std::string id;
    std::string text;
    std::string image;
 
    UIUnitVec2 size;
    float rotation = 0.f;
    UIStyle style;
 
    nlohmann::json nodeJson;
 
    LayoutNode* layoutNode = nullptr;
    std::vector<Widget*> children;
    Widget* parent = nullptr;
    std::function<void()> onClick = nullptr;
    std::function<void()> onFocusEnter = nullptr;
    std::function<void()> onFocusLost = nullptr;
    VexUI* ui = nullptr;
    TextAlign textAlign = TextAlign::Left;
 
    ~Widget();
    void applyLayout(VexUI* uiManager);
};

class VexUI {
public:
    VexUI(VulkanContext& ctx, VirtualFileSystem* vfs, VulkanResources* res, ResolutionManager* resMgr);
    ~VexUI();

    bool init();
    void load(const std::string& path);
    void render(VkCommandBuffer cmd, VkPipeline pipeline, VkPipelineLayout pipelineLayout, int currentFrame);
    void processEvent(const SDL_Event& ev);

    Widget* getFocusedWidget() const { return m_focusedWidget; }

    void setText(const std::string& id, const std::string& txt);

    void setOnClick(const std::string& id, std::function<void()> cb);

    Widget* getWidget(const std::string& id) {
        if (Widget* w = findById(m_root, id)) return w;
        log("Widget not found");
        return nullptr;
    }

    UIStyle* getStyle(const std::string& id) {
        if (Widget* w = findById(m_root, id)) return &w->style;
        log("Widget not found");
        return nullptr;
    }

    void setStyle(const std::string& id, const UIStyle& style) {
        if (initialized) {
            if (Widget* w = findById(m_root, id)) w->style = style;
        } else {
            pendingSetters.push_back([this, id, style]() {
                if (Widget* w = findById(m_root, id)) w->style = style;
            });
        }
    }

    void setRotation(const std::string& id, float degrees);

    void setPosition(const std::string& id, UIUnitValue x, UIUnitValue y);

    void setSize(const std::string& id, UIUnitValue w, UIUnitValue h);

    void setImage(const std::string& id, const std::string& path);

    void setFont(const std::string& id, const std::string& fontPath, UIUnitValue fontSize);

    void setColor(const std::string& id, glm::vec4 color);

    void setBackgroundColor(const std::string& id, glm::vec4 color);

    void setBorder(const std::string& id, UIUnitValue width, glm::vec4 color);

    bool isInitialized() { return initialized; }

    int getZIndex() { return zIndex; }

    void setZIndex(int zIndex) {
        if(initialized) { this->zIndex = zIndex; }
        else { pendingSetters.push_back([this, zIndex]() { this->zIndex = zIndex; }); }
    }

    void update(float deltaTime = 0.016f) {
        if (initialized) {
            if (m_gamepadNavigationCooldown > 0.0f) m_gamepadNavigationCooldown -= deltaTime;
            if (loadPending) {
                loadPending = false;
                load(loadPath);
            }
            for (auto& setter : pendingSetters) setter();
            pendingSetters.clear();
        }
    }
 
    float getPspMultiplier() const;
    glm::uvec2 getRenderResolution() const { return m_ctx.currentRenderResolution; }
 
private:
    VulkanContext& m_ctx;
    VirtualFileSystem* m_vfs;
    VulkanResources* m_res;
    ResolutionManager* m_resMgr;
 
    Widget* m_root = nullptr;
    bool initialized = false;
    int zIndex = 0;
 
    glm::uvec2 m_lastRenderRes{0, 0};
    float m_lastPspMult = 0.f;
 
    std::vector<std::function<void()>> pendingSetters;
 
    bool loadPending = false;
    std::string loadPath = "";
 
    std::unordered_map<std::string, FontAtlas> m_fontAtlases;
 
    VkBuffer m_vb = VK_NULL_HANDLE;
    VmaAllocation m_vbAlloc = VK_NULL_HANDLE;
    size_t m_vbSize = 0;
    VkSampler m_uiSampler = VK_NULL_HANDLE;
 
    Widget* m_focusedWidget = nullptr;
    float m_gamepadAxisX = 0.0f;
    float m_gamepadAxisY = 0.0f;
    Widget* m_previousFocusedWidget = nullptr;
    float m_gamepadNavigationCooldown = 0.0f;
    static constexpr float GAMEPAD_NAV_COOLDOWN = 0.2f;
    static constexpr float GAMEPAD_AXIS_THRESHOLD = 0.5f;

    void loadFonts(Widget* w);

    void loadImages(Widget* w);

    void layout(glm::uvec2 res);

    void batch(Widget* w, std::vector<float>& verts, glm::vec2 parentOffset = {0.f, 0.f});

    void uploadVerts(const std::vector<float>& verts);

    Widget* parseNode(const nlohmann::json& j);

    void freeTree(Widget* w);

    Widget* findWidgetAt(Widget* w, glm::vec2 pos, glm::vec2 parentOffset = {0.f, 0.f});

    Widget* findById(Widget* w, const std::string& id);

    std::vector<std::string> wrapText(const std::string& text, const FontAtlas& a, float maxWidth);

    glm::vec2 calculateTextSize(Widget* w, float maxWidth = FLT_MAX);

    static void measureTextNode(LayoutNode* node, float width, float height);

    void safeUpdate(const std::string& id, std::function<void(Widget*)> action);

    void navigateToWidget(float dirX, float dirY);

    void getNavigableWidgets(std::vector<Widget*>& out);

    void collectNavigableWidgets(Widget* w, std::vector<Widget*>& out);

    bool isWidgetNavigable(Widget* w) const;

    glm::vec2 getWidgetCenter(Widget* w);

    Widget* findClosestNavigableWidget(const glm::vec2& fromPos, const glm::vec2& direction, const std::vector<Widget*>& candidates);

    void setFocusedWidget(Widget* w);
};
 
} // namespace vex