axmol/extensions/ImGuiEXT/CCImGuiEXT.cpp

#include "CCImGuiEXT.h"
#include <assert.h>
#include "imgui_impl_adxe.h"
#include "imgui_internal.h"

NS_CC_EXT_BEGIN

static uint32_t fourccValue(const std::string& str) {
    if (str.empty() || str[0] != '#') return (uint32_t)-1;
    uint32_t value = 0;
    memcpy(&value, str.c_str() + 1, std::min(sizeof(value), str.size() - 1));
    return value;
}

class ImGuiEXTEventTracker {
public:
    virtual ~ImGuiEXTEventTracker() {}
};

// Track scene event and check whether routed to the scene graph
class ImGuiEXTSceneEventTracker : public ImGuiEXTEventTracker
{
public:
    bool initWithScene(Scene* scene)
    {
#ifdef CC_PLATFORM_PC
        _trackLayer = utils::newInstance<Layer>();

        // note: when at the first click to focus the window, this will not take effect
        auto listener = EventListenerTouchOneByOne::create();
        listener->setSwallowTouches(true);
        listener->onTouchBegan = [this](Touch* touch, Event*) -> bool {
            return ImGui::GetIO().WantCaptureMouse;
        };
        _trackLayer->getEventDispatcher()->addEventListenerWithSceneGraphPriority(listener, _trackLayer);

        // add by halx99
        auto stopAnyMouse = [=](EventMouse* event) {
            if (ImGui::GetIO().WantCaptureMouse) {
                event->stopPropagation();
            }
        };
        auto mouseListener = EventListenerMouse::create();
        mouseListener->onMouseDown = mouseListener->onMouseUp = stopAnyMouse;
        _trackLayer->getEventDispatcher()->addEventListenerWithSceneGraphPriority(mouseListener, _trackLayer);
        scene->addChild(_trackLayer, INT_MAX);
#endif
        // add an empty sprite to avoid render problem
        // const auto sp = Sprite::create();
        // sp->setGlobalZOrder(1);
        // sp->setOpacity(0);
        // addChild(sp, 1);

        /*
        * There a 3 choice for schedule frame for ImGui render loop
        * a. at visit/draw to call beginFrame/endFrame, but at ImGui loop, we can't game object and add to Scene directly, will cause damage iterator
        * b. scheduleUpdate at onEnter to call beginFrame, at visit/draw to call endFrame, it's solve iterator damage problem, but when director is paused
        *    the director will stop call 'update' function of Scheduler
        *    And need modify engine code to call _scheduler->update(_deltaTime) even director is paused, pass 0 for update
        * c. Director::EVENT_BEFORE_DRAW call beginFrame, EVENT_AFTER_VISIT call endFrame
        */

        return true;
    }

    ~ImGuiEXTSceneEventTracker()
    {
#ifdef CC_PLATFORM_PC
        if (_trackLayer) {
            if (_trackLayer->getParent())
                _trackLayer->removeFromParent();
            _trackLayer->release();
        }
#endif
    }

private:
    Layer* _trackLayer = nullptr;
};

class ImGuiEXTGlobalEventTracker : public ImGuiEXTEventTracker
{
    static const int highestPriority = (std::numeric_limits<int>::min)();
public:
    bool init()
    {
#ifdef CC_PLATFORM_PC
        // note: when at the first click to focus the window, this will not take effect

        auto eventDispatcher = Director::getInstance()->getEventDispatcher();

        _touchListener = utils::newInstance<EventListenerTouchOneByOne>();
        _touchListener->setSwallowTouches(true);
        _touchListener->onTouchBegan = [this](Touch* touch, Event*) -> bool {
            return ImGui::GetIO().WantCaptureMouse;
        };
        eventDispatcher->addEventListenerWithFixedPriority(_touchListener, highestPriority);

        // add by halx99
        auto stopAnyMouse = [=](EventMouse* event) {
            if (ImGui::GetIO().WantCaptureMouse) {
                event->stopPropagation();
            }
        };
        _mouseListener = utils::newInstance<EventListenerMouse>();
        _mouseListener->onMouseDown = _mouseListener->onMouseUp = stopAnyMouse;
        eventDispatcher->addEventListenerWithFixedPriority(_mouseListener, highestPriority);
#endif
        return true;
    }

    ~ImGuiEXTGlobalEventTracker() {
#ifdef CC_PLATFORM_PC
        auto eventDispatcher = Director::getInstance()->getEventDispatcher();
        eventDispatcher->removeEventListener(_mouseListener);
        eventDispatcher->removeEventListener(_touchListener);

        _mouseListener->release();
        _touchListener->release();
#endif
    }

    EventListenerTouchOneByOne* _touchListener = nullptr;
    EventListenerMouse* _mouseListener = nullptr;
};

static ImGuiEXT* _instance = nullptr;
std::function<void(ImGuiEXT*)> ImGuiEXT::_onInit;

ImGuiEXT* ImGuiEXT::getInstance()
{
    if (_instance == nullptr)
    {
        _instance = new ImGuiEXT();
        _instance->init();
        if (_onInit)
            _onInit(_instance);
    }
    return _instance;
}

void ImGuiEXT::destroyInstance()
{
    if (_instance)
    {
        _instance->cleanup();
        delete _instance;
        _instance = nullptr;
    }
}

void ImGuiEXT::init()
{
    ImGui_ImplAdxe_Init(true);
    ImGui_ImplAdxe_SetCustomFontLoader(&ImGuiEXT::loadCustomFonts, this);

    ImGui::StyleColorsClassic();

    auto eventDispatcher = Director::getInstance()->getEventDispatcher();
    eventDispatcher->addCustomEventListener(Director::EVENT_BEFORE_DRAW, [=](EventCustom*) { beginFrame(); });
    eventDispatcher->addCustomEventListener(Director::EVENT_AFTER_VISIT, [=](EventCustom*) { endFrame(); });
}

void ImGuiEXT::cleanup()
{
    auto eventDispatcher = Director::getInstance()->getEventDispatcher();
    eventDispatcher->removeCustomEventListeners(Director::EVENT_AFTER_VISIT);
    eventDispatcher->removeCustomEventListeners(Director::EVENT_BEFORE_DRAW);

    ImGui_ImplAdxe_SetCustomFontLoader(nullptr, nullptr);
    ImGui_ImplAdxe_Shutdown();

    CC_SAFE_RELEASE_NULL(_fontsTexture);
}

void ImGuiEXT::setOnInit(const std::function<void(ImGuiEXT*)>& callBack)
{
    _onInit = callBack;
}

void ImGuiEXT::loadCustomFonts(void* ud)
{
    auto thiz = (ImGuiEXT*)ud;

    auto imFonts = ImGui::GetIO().Fonts;
    imFonts->Clear();

    auto contentZoomFactor = thiz->_contentZoomFactor;
    for (auto& fontInfo : thiz->_fontsInfoMap) {
        const ImWchar* imChars = nullptr;
        switch (fontInfo.second.glyphRange) {
        case CHS_GLYPH_RANGE::GENERAL:
            imChars = imFonts->GetGlyphRangesChineseSimplifiedCommon();
            break;
        case CHS_GLYPH_RANGE::FULL:
            imChars = imFonts->GetGlyphRangesChineseFull();
            break;
        default:;
        }

        auto fontData = FileUtils::getInstance()->getDataFromFile(fontInfo.first);
        CCASSERT(!fontData.isNull(), "Cannot load font for IMGUI");

        ssize_t bufferSize = 0;
        auto* buffer = fontData.takeBuffer(&bufferSize); // Buffer automatically freed by IMGUI

        imFonts->AddFontFromMemoryTTF(buffer, bufferSize, fontInfo.second.fontSize * contentZoomFactor, nullptr, imChars);
    }
}

float ImGuiEXT::scaleAllByDPI(float userScale)
{
    // Gets scale
    float xscale = 1.0f;
    glfwGetMonitorContentScale(glfwGetPrimaryMonitor(), &xscale, nullptr);
    auto zoomFactor = userScale * xscale;

    auto imFonts = ImGui::GetIO().Fonts;

    // clear before add new font
    auto fontConf = imFonts->ConfigData; // copy font config data

    if (zoomFactor != _contentZoomFactor) {
        for (auto& fontConf : imFonts->ConfigData)
        {
            fontConf.SizePixels = (fontConf.SizePixels / _contentZoomFactor) * zoomFactor;
        }

        // Destory font informations, let implcocos2dx recreate at newFrame
        ImGui_ImplAdxe_SetDeviceObjectsDirty();

        ImGui::GetStyle().ScaleAllSizes(zoomFactor);

        _contentZoomFactor = zoomFactor;
    }

    return zoomFactor;
}

void ImGuiEXT::addFont(const std::string& fontFile, float fontSize, CHS_GLYPH_RANGE glyphRange)
{
    if (FileUtils::getInstance()->isFileExistInternal(fontFile)) {
        if(_fontsInfoMap.emplace(fontFile, FontInfo{ fontSize, glyphRange }).second)
            ImGui_ImplAdxe_SetDeviceObjectsDirty();
    }
}

void ImGuiEXT::removeFont(const std::string& fontFile)
{
    auto count = _fontsInfoMap.size();
    _fontsInfoMap.erase(fontFile);
    if(count != _fontsInfoMap.size())
        ImGui_ImplAdxe_SetDeviceObjectsDirty();
}

void ImGuiEXT::clearFonts()
{
    bool haveCustomFonts = !_fontsInfoMap.empty();
    _fontsInfoMap.clear();
    if(haveCustomFonts)
        ImGui_ImplAdxe_SetDeviceObjectsDirty();

    // auto drawData = ImGui::GetDrawData();
    // if(drawData) drawData->Clear();
}

void ImGuiEXT::end()
{
    _purgeNextLoop = true;
}

/*
* begin ImGui frame and draw ImGui stubs
*/
void ImGuiEXT::beginFrame()
{ // drived by event Director::EVENT_BEFORE_DRAW from engine mainLoop
    if(_purgeNextLoop)
    {
        Director::getInstance()->end();
        return;
    }
    if (!_renderPiplines.empty()) {
        // create frame
        ImGui_ImplAdxe_NewFrame();

        // move to endFrame?
        _fontsTexture = (Texture2D*)ImGui_ImplAdxe_GetFontsTexture();
        assert(_fontsTexture != nullptr);
        _fontsTexture->retain();

        // draw all gui
        this->update();

        ++_beginFrames;
    }
}

/*
* flush ImGui draw data to engine
*/
void ImGuiEXT::endFrame() {
    if (_beginFrames > 0) {
        // render
        ImGui::Render();

        auto drawData = ImGui::GetDrawData();
        if (drawData)
            ImGui_ImplAdxe_RenderDrawData(drawData);

        ImGui_ImplAdxe_RenderPlatform();
        --_beginFrames;

        CC_SAFE_RELEASE_NULL(_fontsTexture);
    }
}

void ImGuiEXT::update()
{
    // clear things from last frame
    usedCCRefIdMap.clear();
    usedCCRef.clear();
    // drawing commands
    for (auto& pipline : _renderPiplines)
        pipline.second.frame();

    // commands will be processed after update
}

bool ImGuiEXT::addRenderLoop(const std::string& id, std::function<void()> func, Scene* target)
{
    // TODO: check whether exist
    auto fourccId = fourccValue(id);
    if (_renderPiplines.find(fourccId) != _renderPiplines.end())
    {
        return false;
    }

    ImGuiEXTEventTracker* tracker;
    if (target)
        tracker = utils::newInstance<ImGuiEXTSceneEventTracker>(&ImGuiEXTSceneEventTracker::initWithScene, target);
    else
        tracker = utils::newInstance<ImGuiEXTGlobalEventTracker>();

    if (tracker) {
        _renderPiplines.emplace(fourccId, RenderPipline{ tracker, std::move(func) });
        return true;
    }
    return false;
}

void ImGuiEXT::removeRenderLoop(const std::string& id)
{
    auto fourccId = fourccValue(id);
    const auto iter = _renderPiplines.find(fourccId);
    if (iter != _renderPiplines.end()) {
        auto tracker = iter->second.tracker;
        delete tracker;
        _renderPiplines.erase(iter);
    }

    if (_renderPiplines.empty())
        deactiveImGuiViewports();
}

void ImGuiEXT::deactiveImGuiViewports() {
    ImGuiContext& g = *GImGui;
    if (!(g.ConfigFlagsCurrFrame & ImGuiConfigFlags_ViewportsEnable))
        return;

    // Create/resize/destroy platform windows to match each active viewport.
    // Skip the main viewport (index 0), which is always fully handled by the application!
    for (int i = 1; i < g.Viewports.Size; i++)
    {
        ImGuiViewportP* viewport = g.Viewports[i];
        viewport->Window->Active = false;
    }
}

static std::tuple<ImVec2, ImVec2> getTextureUV(Sprite* sp)
{
    ImVec2 uv0, uv1;
    if (!sp || !sp->getTexture())
        return std::tuple<ImVec2, ImVec2>{ uv0,uv1 };
    const auto& rect = sp->getTextureRect();
    const auto tex = sp->getTexture();
    const float atlasWidth = (float)tex->getPixelsWide();
    const float atlasHeight = (float)tex->getPixelsHigh();
    uv0.x = rect.origin.x / atlasWidth;
    uv0.y = rect.origin.y / atlasHeight;
    uv1.x = (rect.origin.x + rect.size.width) / atlasWidth;
    uv1.y = (rect.origin.y + rect.size.height) / atlasHeight;
    return std::tuple<ImVec2, ImVec2>{ uv0,uv1 };
}

void ImGuiEXT::image(Texture2D* tex, const ImVec2& size, const ImVec2& uv0, const ImVec2& uv1,
    const ImVec4& tint_col, const ImVec4& border_col)
{
    if (!tex)
        return;
    auto size_ = size;
    if (size_.x <= 0.f) size_.x = tex->getPixelsWide();
    if (size_.y <= 0.f) size_.y = tex->getPixelsHigh();
    ImGui::PushID(getCCRefId(tex));
    ImGui::Image((ImTextureID)tex, size_, uv0, uv1, tint_col, border_col);
    ImGui::PopID();
}

void ImGuiEXT::image(Sprite* sprite, const ImVec2& size, const ImVec4& tint_col, const ImVec4& border_col)
{
    if (!sprite || !sprite->getTexture())
        return;
    auto size_ = size;
    const auto& rect = sprite->getTextureRect();
    if (size_.x <= 0.f) size_.x = rect.size.width;
    if (size_.y <= 0.f) size_.y = rect.size.height;
    ImVec2 uv0, uv1;
    std::tie(uv0, uv1) = getTextureUV(sprite);
    ImGui::PushID(getCCRefId(sprite));
    ImGui::Image((ImTextureID)sprite->getTexture(), size_, uv0, uv1, tint_col, border_col);
    ImGui::PopID();
}

bool ImGuiEXT::imageButton(Texture2D* tex, const ImVec2& size, const ImVec2& uv0, const ImVec2& uv1,
    int frame_padding, const ImVec4& bg_col, const ImVec4& tint_col)
{
    if (!tex)
        return false;
    auto size_ = size;
    if (size_.x <= 0.f) size_.x = tex->getPixelsWide();
    if (size_.y <= 0.f) size_.y = tex->getPixelsHigh();
    ImGui::PushID(getCCRefId(tex));
    const auto ret = ImGui::ImageButton((ImTextureID)tex,
        size_, uv0, uv1, frame_padding, bg_col, tint_col);
    ImGui::PopID();
    return ret;
}

bool ImGuiEXT::imageButton(Sprite* sprite, const ImVec2& size, int frame_padding, const ImVec4& bg_col,
    const ImVec4& tint_col)
{
    if (!sprite || !sprite->getTexture())
        return false;
    auto size_ = size;
    const auto& rect = sprite->getTextureRect();
    if (size_.x <= 0.f) size_.x = rect.size.width;
    if (size_.y <= 0.f) size_.y = rect.size.height;
    ImVec2 uv0, uv1;
    std::tie(uv0, uv1) = getTextureUV(sprite);
    ImGui::PushID(getCCRefId(sprite));
    const auto ret = ImGui::ImageButton((ImTextureID)sprite->getTexture(),
        size_, uv0, uv1, frame_padding, bg_col, tint_col);
    ImGui::PopID();
    return ret;
}

void ImGuiEXT::node(Node* node, const ImVec4& tint_col, const ImVec4& border_col)
{
    if (!node)
        return;
    const auto size = node->getContentSize();
    const auto pos = ImGui::GetCursorScreenPos();
    Mat4 tr;
    tr.m[5] = -1;
    tr.m[12] = pos.x;
    tr.m[13] = pos.y + size.height;
    if (border_col.w > 0.f)
    {
        tr.m[12] += 1;
        tr.m[13] += 1;
    }
    node->setNodeToParentTransform(tr);
    ImGui::PushID(getCCRefId(node));
    ImGui::Image((ImTextureID)node,
        ImVec2(size.width, size.height), ImVec2(0, 0), ImVec2(1, 1), tint_col, border_col);
    ImGui::PopID();
}

bool ImGuiEXT::nodeButton(Node* node, int frame_padding, const ImVec4& bg_col, const ImVec4& tint_col)
{
    if (!node)
        return false;
    const auto size = node->getContentSize();
    const auto pos = ImGui::GetCursorScreenPos();
    Mat4 tr;
    tr.m[5] = -1;
    tr.m[12] = pos.x;
    tr.m[13] = pos.y + size.height;
    if (frame_padding >= 0)
    {
        tr.m[12] += (float)frame_padding;
        tr.m[13] += (float)frame_padding;
    }
    else
    {
        tr.m[12] += ImGui::GetStyle().FramePadding.x;
        tr.m[13] += ImGui::GetStyle().FramePadding.y;
    }
    node->setNodeToParentTransform(tr);
    ImGui::PushID(getCCRefId(node));
    const auto ret = ImGui::ImageButton((ImTextureID)node,
        ImVec2(size.width, size.height), ImVec2(0, 0), ImVec2(1, 1), frame_padding, bg_col, tint_col);
    ImGui::PopID();
    return ret;
}

std::tuple<ImTextureID, int> ImGuiEXT::useTexture(Texture2D* texture)
{
    if (!texture)
        return std::tuple<ImTextureID, int>{ nullptr,0 };
    return std::tuple<ImTextureID, int>{ (ImTextureID)texture,getCCRefId(texture) };
}

std::tuple<ImTextureID, ImVec2, ImVec2, int> ImGuiEXT::useSprite(Sprite* sprite)
{
    if (!sprite || !sprite->getTexture())
        return std::tuple<ImTextureID, ImVec2, ImVec2, int>{ nullptr,{},{},0 };
    ImVec2 uv0, uv1;
    std::tie(uv0, uv1) = getTextureUV(sprite);
    return std::tuple<ImTextureID, ImVec2, ImVec2, int>{ (ImTextureID)sprite->getTexture(),uv0,uv1,getCCRefId(sprite) };
}

std::tuple<ImTextureID, ImVec2, ImVec2, int> ImGuiEXT::useNode(Node* node, const ImVec2& pos)
{
    if (!node)
        return std::tuple<ImTextureID, ImVec2, ImVec2, int>{ nullptr,{},{},0 };
    const auto size = node->getContentSize();
    Mat4 tr;
    tr.m[5] = -1;
    tr.m[12] = pos.x;
    tr.m[13] = pos.y + size.height;
    node->setNodeToParentTransform(tr);
    return std::tuple<ImTextureID, ImVec2, ImVec2, int>{ (ImTextureID)node,pos,ImVec2(pos.x + size.width,pos.y + size.height),getCCRefId(node) };
}

void ImGuiEXT::setNodeColor(Node* node, const ImVec4& col)
{
    if (node)
    {
        node->setColor({ uint8_t(col.x * 255),uint8_t(col.y * 255),uint8_t(col.z * 255) });
        node->setOpacity(uint8_t(col.w * 255));
    }
}

void ImGuiEXT::setNodeColor(Node* node, ImGuiCol col)
{
    if (node && 0 <= col && col < ImGuiCol_COUNT)
        setNodeColor(node, ImGui::GetStyleColorVec4(col));
}

void ImGuiEXT::setLabelColor(Label* label, const ImVec4& col)
{
    if (label)
    {
        label->setTextColor(
            { uint8_t(col.x * 255),uint8_t(col.y * 255),uint8_t(col.z * 255),uint8_t(col.w * 255) });
    }
}

void ImGuiEXT::setLabelColor(Label* label, bool disabled)
{
    if (label)
        setLabelColor(label, ImGui::GetStyleColorVec4(disabled ? ImGuiCol_TextDisabled : ImGuiCol_Text));
}

void ImGuiEXT::setLabelColor(Label* label, ImGuiCol col)
{
    if (label && 0 <= col && col < ImGuiCol_COUNT)
        setLabelColor(label, ImGui::GetStyleColorVec4(col));
}

ImWchar* ImGuiEXT::addGlyphRanges(const std::string& key, const std::vector<ImWchar>& ranges)
{
    auto it = glyphRanges.find(key);
    // the pointer must be persistant, do not replace
    if (it != glyphRanges.end())
        return it->second.data();
    glyphRanges[key] = ranges;
    if (ranges.empty())
        glyphRanges[key].push_back(0);
    return glyphRanges[key].data();
}

void ImGuiEXT::mergeFontGlyphs(ImFont* dst, ImFont* src, ImWchar start, ImWchar end)
{
    if (!dst || !src || start > end)
        return;
    for (auto i = start; i <= end; ++i)
    {
        const auto g = src->FindGlyphNoFallback(i);
        if (g)
        {
            dst->AddGlyph(nullptr, g->Codepoint, g->X0, g->Y0, g->X1, g->Y1, g->U0, g->V0, g->U1, g->V1, g->AdvanceX);
        }
    }
    dst->BuildLookupTable();
}

int ImGuiEXT::getCCRefId(Ref* p)
{
    int id = 0;
    const auto it = usedCCRefIdMap.find(p);
    if (it == usedCCRefIdMap.end())
    {
        usedCCRefIdMap[p] = 0;
        usedCCRef.pushBack(p);
    }
    else
        id = ++it->second;
    // BKDR hash
    constexpr unsigned int seed = 131;
    unsigned int hash = 0;
    for (auto i = 0u; i < sizeof(void*); ++i)
        hash = hash * seed + ((const char*)&p)[i];
    for (auto i = 0u; i < sizeof(int); ++i)
        hash = hash * seed + ((const char*)&id)[i];
    return (int)hash;
}

#if defined(HAVE_IMGUI_MARKDOWN)
#include "imgui_markdown/imgui_markdown.h"

static ImGuiEXT::MdLinkCallback ImGuiMarkdownLinkCallback = nullptr;
static ImGuiEXT::MdImageCallback ImGuiMarkdownImageCallback = nullptr;
static ImGui::MarkdownImageData ImGuiMarkdownInvalidImageData = { false, false, nullptr, {0.f, 0.f} };

void MarkdownLinkCallback(ImGui::MarkdownLinkCallbackData data)
{
    if (ImGuiMarkdownLinkCallback)
    {
        ImGuiMarkdownLinkCallback(
            { data.text, (size_t)data.textLength }, { data.link, (size_t)data.linkLength }, data.isImage);
    }
}

ImGui::MarkdownImageData MarkdownImageCallback(ImGui::MarkdownLinkCallbackData data)
{
    if (!data.isImage || !ImGuiMarkdownImageCallback)
        return ImGuiMarkdownInvalidImageData;
    Sprite* sp; ImVec2 size; ImVec4 tint_col; ImVec4 border_col;
    std::tie(sp, size, tint_col, border_col) = ImGuiMarkdownImageCallback(
        { data.text, (size_t)data.textLength },
        { data.link, (size_t)data.linkLength });
    if (!sp || !sp->getTexture())
        return ImGuiMarkdownInvalidImageData;
    auto size_ = size;
    const auto rect = sp->getTextureRect();
    if (size_.x <= 0.f) size_.x = rect.size.width;
    if (size_.y <= 0.f) size_.y = rect.size.height;
    ImVec2 uv0, uv1;
    std::tie(uv0, uv1) = getTextureUV(sp);
    ImGuiEXT::getInstance()->getCCRefId(sp);
    return { true, true, (ImTextureID)sp->getTexture(), size_,uv0, uv1, tint_col, border_col };
}

static std::string ImGuiMarkdownLinkIcon;
static ImGui::MarkdownConfig ImGuiMarkdownConfig = {
    MarkdownLinkCallback, MarkdownImageCallback, "" };

void ImGuiEXT::setMarkdownLinkCallback(const MdLinkCallback& f)
{
    ImGuiMarkdownLinkCallback = f;
}

void ImGuiEXT::setMarkdownImageCallback(const MdImageCallback& f)
{
    ImGuiMarkdownImageCallback = f;
}

void ImGuiEXT::setMarkdownFont(int index, ImFont* font, bool seperator, float scale)
{
    if (index < 0 || index >= ImGui::MarkdownConfig::NUMHEADINGS)
        return;
    ImGuiMarkdownConfig.headingFormats[index] = { font,seperator };
    ImGuiMarkdownConfig.headingScales[index] = scale;
}

void ImGuiEXT::setMarkdownLinkIcon(const std::string& icon)
{
    ImGuiMarkdownLinkIcon = icon;
    ImGuiMarkdownConfig.linkIcon = ImGuiMarkdownLinkIcon.c_str();
}

void ImGuiEXT::markdown(const std::string& content)
{
    ImGui::Markdown(content.c_str(), content.size(), ImGuiMarkdownConfig);
}

#endif

NS_CC_EXT_END