ImGui

void RenderRayGui()
{
    ImGui::EndFrame();
    ImGui::Render();
    ImDrawData * draw_data = ImGui::GetDrawData();
    assert(draw_data != nullptr);

    if (draw_data->CmdListsCount == 0) {
        return;
    }

    ImGuiIO & io = ImGui::GetIO();

    // Avoid rendering when minimized,
    // scale coordinates for retina displays
    // (screen coordinates != framebuffer coordinates)
    auto const FRAME_BUFFER_WIDTH  = (int)(draw_data->DisplaySize.x * draw_data->FramebufferScale.x);
    auto const FRAME_BUFFER_HEIGHT = (int)(draw_data->DisplaySize.y * draw_data->FramebufferScale.y);
    if (FRAME_BUFFER_WIDTH <= 0 || FRAME_BUFFER_HEIGHT <= 0) {
        return;
    }

    // Will project scissor/clipping rectangles into framebuffer space
    ImVec2 const CLIP_OFF = draw_data->DisplayPos;         // (0,0) unless using multi-viewports
    ImVec2 const CLIP_SCALE = draw_data->FramebufferScale; // (1,1) unless using retina display which are often (2,2)

    // TODO: Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled
    // TODO: Setup viewport covering draw_data->DisplayPos to draw_data->DisplayPos + draw_data->DisplaySize
    // TODO: Setup orthographic projection matrix cover draw_data->DisplayPos to draw_data->DisplayPos + draw_data->DisplaySize
    // TODO: Setup shader: vertex { float2 pos, float2 uv, u32 color }, fragment shader sample color from 1 texture, multiply by vertex color.

    // Render command lists
    for (int n = 0; n < draw_data->CmdListsCount; n++) {
        ImDrawList const * cmd_list   = draw_data->CmdLists[n];
        ImDrawVert const * vtx_buffer = cmd_list->VtxBuffer.Data;
        ImDrawIdx  const * idx_buffer = cmd_list->IdxBuffer.Data;

        for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.Size; cmd_i++) {
            ImDrawCmd const * pcmd = &cmd_list->CmdBuffer[cmd_i];
            if (pcmd->UserCallback) {
                pcmd->UserCallback(cmd_list, pcmd);
            } else {
                // The texture for the draw call is specified by pcmd->TextureId.
                // The vast majority of draw calls will use the imgui texture atlas, which value you have set yourself during initialization.
                //MyEngineBindTexture((MyTexture*)pcmd->TextureId);

                // We are using scissoring to clip some objects. All low-level graphics API should supports it.
                // - If your engine doesn't support scissoring yet, you may ignore this at first. You will get some small glitches
                //   (some elements visible outside their bounds) but you can fix that once everything else works!
                // - Clipping coordinates are provided in imgui coordinates space (from draw_data->DisplayPos to draw_data->DisplayPos + draw_data->DisplaySize)
                //   In a single viewport application, draw_data->DisplayPos will always be (0,0) and draw_data->DisplaySize will always be == io.DisplaySize.
                //   However, in the interest of supporting multi-viewport applications in the future (see 'viewport' branch on github),
                //   always subtract draw_data->DisplayPos from clipping bounds to convert them to your viewport space.
                // - Note that pcmd->ClipRect contains Min+Max bounds. Some graphics API may use Min+Max, other may use Min+Size (size being Max-Min)
                ImVec2 pos = draw_data->DisplayPos;
                //MyEngineScissor((int)(pcmd->ClipRect.x - pos.x), (int)(pcmd->ClipRect.y - pos.y), (int)(pcmd->ClipRect.z - pos.x), (int)(pcmd->ClipRect.w - pos.y));

                // Render 'pcmd->ElemCount/3' indexed triangles.
                // By default the indices ImDrawIdx are 16-bits, you can change them to 32-bits in imconfig.h if your engine doesn't support 16-bits indices.
                //MyEngineDrawIndexedTriangles(pcmd->ElemCount, sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, idx_buffer, vtx_buffer);

                auto texture_id = (std::intptr_t)pcmd->TextureId;
                rlEnableTexture((unsigned int)texture_id);
                rlBegin(RL_TRIANGLES);

                assert(pcmd->ElemCount >= 3 && pcmd->ElemCount % 3 == 0);
                auto const TRIANGLE_COUNT = pcmd->ElemCount / 3;

                for (int i = 0; i < TRIANGLE_COUNT; ++i) {
                    auto const POINT0 = vtx_buffer[idx_buffer[(i*3)+0]];
                    auto const POINT1 = vtx_buffer[idx_buffer[(i*3)+1]];
                    auto const POINT2 = vtx_buffer[idx_buffer[(i*3)+2]];

                    auto const COLOR0 = GetColor(POINT0.col);
                    auto const COLOR1 = GetColor(POINT1.col);
                    auto const COLOR2 = GetColor(POINT2.col);

                    rlColor4ub(COLOR0.r, COLOR0.g, COLOR0.b, COLOR0.a);
                    rlTexCoord2f(POINT0.uv.x, POINT0.uv.y);
                    rlVertex2f(POINT0.pos.x, POINT0.pos.y);

                    rlColor4ub(COLOR1.r, COLOR1.g, COLOR1.b, COLOR1.a);
                    rlTexCoord2f(POINT1.uv.x, POINT1.uv.y);
                    rlVertex2f(POINT1.pos.x, POINT1.pos.y);

                    rlColor4ub(COLOR2.r, COLOR2.g, COLOR2.b, COLOR2.a);
                    rlTexCoord2f(POINT2.uv.x, POINT2.uv.y);
                    rlVertex2f(POINT2.pos.x, POINT2.pos.y);
                }
                rlEnd();
                rlDisableTexture();
            }
            idx_buffer += pcmd->ElemCount;
        }
    }
}

#include <imgui/imgui.h>
#include <imgui/imgui-sfml.h>

#include <SFML/Graphics/RenderWindow.hpp>
#include <SFML/Graphics/CircleShape.hpp>
#include <SFML/System/Clock.hpp>
#include <SFML/Window/Event.hpp>

int runDefaultImGuiSfml()
{
    sf::RenderWindow window(sf::VideoMode(200, 200), LIBWORLD_MAIN_TITLE);
    window.setVerticalSyncEnabled(true);
    ImGui::SFML::Init(window);

    sf::Clock deltaClock;
    while (window.isOpen()) {
        sf::Event event;

        while (window.pollEvent(event)) {
            ImGui::SFML::ProcessEvent(event);

            if (event.type == sf::Event::Closed) {
                window.close();
            }
        }

        ImGui::SFML::Update(deltaClock.restart());

        ImGui::Begin(LIBWORLD_MAIN_TITLE); // begin window
        ImGui::End(); // end window

        window.clear();
        ImGui::Render();
        window.display();
    }

    ImGui::SFML::Shutdown();

    return 0;
}

ImGuiManager::ImGuiManager()
{
    IMGUI_CHECKVERSION();
    ImGui::CreateContext();
    ImGui::StyleColorsDark();
    ImGuiIO& io = ImGui::GetIO();
    io.Fonts->AddFontFromFileTTF("C:\\Windows\\Fonts\\malgun.ttf", 18.0f, NULL, io.Fonts->GetGlyphRangesKorean());
}

ImGuiManager::~ImGuiManager()
{
    ImGui::DestroyContext();
}

ImGuiIO& io = ImGui::GetIO();
io.Fonts->AddFontFromFileTTF("C:\\Windows\\Fonts\\malgun.ttf", 18.0f, NULL, io.Fonts->GetGlyphRangesKorean());

    #pragma region IMGUI INTERFACE
    if (ImGui::Begin("Chatting Box"))
    {

        ImGui::TextColored(color,isConnect.c_str());
        //연결이 안되어 있으면 연결 재 시도
        if (!m_Net.m_bConnect)
        {
            if (ImGui::Button(u8"연결 재시도"))
            {
                if (m_Net.Connect(g_hWnd, SOCK_STREAM, 10000, IP_DD))
                {
                    m_bConnect = true;
                }
            }
        }
        else
        {
            ImGui::BeginChild(u8"채팅창", ImVec2(0, -ImGui::GetItemsLineHeightWithSpacing() - 15));
            ImGui::Text(chatItems);
            ImGui::EndChild();
            ImGui::Dummy(ImVec2(0.0f, 5));
            ImGui::InputText("", buffer, sizeof(buffer));
            ImGui::SameLine();
            if (ImGui::Button("Send"))
            {
                char clear[MAX_PATH] = { 0, };
                KPacket kPacket(PACKET_CHAT_MSG);
                kPacket << 123 << "Test" << (short)12 << buffer;

                //리턴 값이 0보다 작으면 전송되지 않았음
                if (m_Net.SendMsg(m_Net.m_Sock, kPacket.m_uPacket) < 0)
                {
                    ZeroMemory(&chatItems, sizeof(char) * 2048);
                    strcat(chatItems, "Error\n");
                    m_Net.m_bConnect = false;
                }

                strcpy(buffer, clear);
            }
        }
    }
    ImGui::End();
#pragma endregion

bool openMyPopup = false;
if (ImGui::BeginPopupContextItem("BeginPopupContextItem")) {
    if (ImGui::MenuItem("Rename")) {
        openMyPopup = true;
    }
    ImGui::EndPopup(); // <--- remember this
}
if (openMyPopup) {
    ImGui::OpenPopup("OpenPopup");
}
if (ImGui::BeginPopupModal("OpenPopup")) {
    // ...
    ImGui::EndPopup();
}