Not Rending Fonts / Invalid Characters on ImGui 1.90.7

[matthewfarstad]

I have a complicated dealio but basically I have cmake-imgui with dear-bindings to C and a confirmed good / functional GUI w/ SDL2 and OpenGL3.

However, I have gone as far as to whittle the program down to something like this:

    // Simple menu for TUI
    if (ImGui_BeginMainMenuBar()) {
        if (ImGui_BeginMenu("File##file")) {
            if (ImGui_MenuItem("Exit##exit")) {
                return WGUI_EXIT;
            }
            ImGui_EndMenu();
        }
        ImGui_EndMainMenuBar();
    }

All text shows up as an invalid char of some kind (but in the right spot!).

Tried w/ ImGUi freetype and messing w/ locale, but other TUIs work fine so I think this is a setup / me problem, but made issue anyway. Is this something an older version of ImGui might fix?

[matthewfarstad]

This made it work for me:

*ncurses.cpp

/*! \file imtui-impl-ncurses.cpp
 *  \brief Enter description here.
 */

#include "imtui.hpp"
#include "imtui-impl-ncurses.hpp"
#include "imtui-impl-text.hpp"

#ifdef _WIN32
#define NCURSES_MOUSE_VERSION
#include <pdcurses.h>
#define set_escdelay(X)

#define KEY_OFFSET 0xec00

#define KEY_CODE_YES     (KEY_OFFSET + 0x00) /* If get_wch() gives a key code */

#define KEY_BREAK        (KEY_OFFSET + 0x01) /* Not on PC KBD */
#define KEY_DOWN         (KEY_OFFSET + 0x02) /* Down arrow key */
#define KEY_UP           (KEY_OFFSET + 0x03) /* Up arrow key */
#define KEY_LEFT         (KEY_OFFSET + 0x04) /* Left arrow key */
#define KEY_RIGHT        (KEY_OFFSET + 0x05) /* Right arrow key */
#define KEY_HOME         (KEY_OFFSET + 0x06) /* home key */
#define KEY_BACKSPACE    (8) /* not on pc */
#define KEY_F0           (KEY_OFFSET + 0x08) /* function keys; 64 reserved */
#else
#include <ncurses.h>
#endif

#include <array>
#include <chrono>
#include <map>
#include <vector>
#include <string>
#include <thread>
#include <cstring>  // For memset

namespace {
    struct VSync {
        VSync(double fps_active = 60.0, double fps_idle = 60.0) :
            tStepActive_us(1000000.0/fps_active),
            tStepIdle_us(1000000.0/fps_idle) {}

        uint64_t tStepActive_us;
        uint64_t tStepIdle_us;
        uint64_t tLast_us = t_us();
        uint64_t tNext_us = tLast_us;

        inline uint64_t t_us() const {
            return std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count(); // duh ..
        }

        inline void wait(bool active) {
            uint64_t tNow_us = t_us();

            auto tStep_us = active ? tStepActive_us : tStepIdle_us;
            auto tNextCur_us = tNext_us + tStep_us;

            while (tNow_us < tNextCur_us - 100) {
                if (tNow_us + 0.5*tStepActive_us < tNextCur_us) {
                    int ch = getch();

                    if (ch != ERR) {
                        ungetch(ch);
                        tNextCur_us = tNow_us;

                        return;
                    }
                }

                std::this_thread::sleep_for(std::chrono::microseconds(
                        std::min((uint64_t)(0.9*tStepActive_us),
                                 (uint64_t) (0.9*(tNextCur_us - tNow_us))
                                 )));

                tNow_us = t_us();
            }

            tNext_us += tStep_us;
        }

        inline float delta_s() {
            uint64_t tNow_us = t_us();
            uint64_t res = tNow_us - tLast_us;
            tLast_us = tNow_us;

            return float(res)/1e6f;
        }
    };
}

static VSync g_vsync;
static ImTui::TScreen * g_screen = nullptr;

ImTui::TScreen * ImTui_ImplNcurses_Init(bool mouseSupport, float fps_active, float fps_idle) {
    if (g_screen == nullptr) {
        g_screen = new ImTui::TScreen();
    }

    if (fps_idle < 0.0) {
        fps_idle = fps_active;
    }
    fps_idle = std::min(fps_active, fps_idle);
    g_vsync = VSync(fps_active, fps_idle);

    initscr();
    use_default_colors();

    g_has_colors = has_colors();
    if (g_has_colors) {
        start_color();
        g_has_256_colors = (COLORS >= 256);
    }

    cbreak();
    noecho(); 
    curs_set(0);
    nodelay(stdscr, TRUE);
    timeout(0);
    set_escdelay(25);
    keypad(stdscr, true);

    if (mouseSupport) {
        mouseinterval(0);
        mousemask(ALL_MOUSE_EVENTS | REPORT_MOUSE_POSITION, NULL);
        printf("\033[?1003h\n");
    }

    ImGui::GetIO().KeyMap[ImGuiKey_Tab]         = 9;
    ImGui::GetIO().KeyMap[ImGuiKey_LeftArrow]   = 260;
    ImGui::GetIO().KeyMap[ImGuiKey_RightArrow]  = 261;
    ImGui::GetIO().KeyMap[ImGuiKey_UpArrow]     = 259;
    ImGui::GetIO().KeyMap[ImGuiKey_DownArrow]   = 258;
    ImGui::GetIO().KeyMap[ImGuiKey_PageUp]      = 339;
    ImGui::GetIO().KeyMap[ImGuiKey_PageDown]    = 338;
    ImGui::GetIO().KeyMap[ImGuiKey_Home]        = 262;
    ImGui::GetIO().KeyMap[ImGuiKey_End]         = 360;
    ImGui::GetIO().KeyMap[ImGuiKey_Insert]      = 331;
    ImGui::GetIO().KeyMap[ImGuiKey_Delete]      = 330;
    ImGui::GetIO().KeyMap[ImGuiKey_Backspace]   = 263;
    ImGui::GetIO().KeyMap[ImGuiKey_Space]       = 32;
    ImGui::GetIO().KeyMap[ImGuiKey_Enter]       = 10;
    ImGui::GetIO().KeyMap[ImGuiKey_Escape]      = 27;
    ImGui::GetIO().KeyMap[ImGuiKey_KeypadEnter] = 343;
    ImGui::GetIO().KeyMap[ImGuiKey_A]           = 1;
    ImGui::GetIO().KeyMap[ImGuiKey_C]           = 3;
    ImGui::GetIO().KeyMap[ImGuiKey_V]           = 22;
    ImGui::GetIO().KeyMap[ImGuiKey_X]           = 24;
    ImGui::GetIO().KeyMap[ImGuiKey_Y]           = 25;
    ImGui::GetIO().KeyMap[ImGuiKey_Z]           = 26;

    ImGui::GetIO().KeyRepeatDelay = 0.050;
    ImGui::GetIO().KeyRepeatRate = 0.050;

	int screenSizeX = 0;
	int screenSizeY = 0;

	getmaxyx(stdscr, screenSizeY, screenSizeX);
	ImGui::GetIO().DisplaySize = ImVec2(screenSizeX, screenSizeY);

    return g_screen;
}

void ImTui_ImplNcurses_Shutdown() {
    // ref #11 : https://github.com/ggerganov/imtui/issues/11
    printf("\033[?1003l\n"); // Disable mouse movement events, as l = low

    endwin();

    if (g_screen) {
        delete g_screen;
    }

    g_screen = nullptr;
}

bool ImTui_ImplNcurses_NewFrame() {
    bool hasInput = false;

	int screenSizeX = 0;
	int screenSizeY = 0;

	getmaxyx(stdscr, screenSizeY, screenSizeX);
	ImGui::GetIO().DisplaySize = ImVec2(screenSizeX, screenSizeY);

    static int mx = 0;
    static int my = 0;
    static int lbut = 0;
    static int rbut = 0;
    static unsigned long mstate = 0;
    static char input[5];  // Increased buffer for wide/UTF-8 characters

    memset(input, 0, sizeof(input));

    auto & keysDown = ImGui::GetIO().KeysDown;
    std::fill(keysDown, keysDown + 512, 0);

    ImGui::GetIO().KeyCtrl = false;
    ImGui::GetIO().KeyShift = false;

    while (true) {
        int c = getch();

        if (c == ERR) {
            if ((mstate & 0xf) == 0x1) {
                lbut = 0;
                rbut = 0;
            }
            break;
        } else if (c == KEY_MOUSE) {
            MEVENT event;
            if (getmouse(&event) == OK) {
                mx = event.x;
                my = event.y;
                mstate = event.bstate;
                if ((mstate & 0x000f) == 0x0002) lbut = 1;
                if ((mstate & 0x000f) == 0x0001) lbut = 0;
                if ((mstate & 0xf000) == 0x2000) rbut = 1;
                if ((mstate & 0xf000) == 0x1000) rbut = 0;
                //printf("mstate = 0x%016lx\n", mstate);
                ImGui::GetIO().KeyCtrl |= ((mstate & 0x0F000000) == 0x01000000);
            }
        } else {
            // Handle wide characters and special text input
            if (c >= 32 && c < 127) {
                // Standard ASCII printable characters
                input[0] = c;
                input[1] = 0;
                if (c != ImGui::GetIO().KeyMap[ImGuiKey_Enter]) {
                    ImGui::GetIO().AddInputCharactersUTF8(input);
                }
            } else if (c >= 128 && c <= 255) {
                // Extended ASCII characters
                input[0] = c;
                input[1] = 0;
                ImGui::GetIO().AddInputCharactersUTF8(input);
            } else if ((c & KEY_CODE_YES) == KEY_CODE_YES) {
                // Function keys and special keys are handled below
            } else if (c > 255) {
                // Handle potential wide characters
                input[0] = (c & 0x000000FF);
                input[1] = (c & 0x0000FF00) >> 8;
                input[2] = (c & 0x00FF0000) >> 16;
                input[3] = (c & 0xFF000000) >> 24;
                input[4] = 0;
                ImGui::GetIO().AddInputCharactersUTF8(input);
            }
            if (c == 330) {
                ImGui::GetIO().KeysDown[ImGui::GetIO().KeyMap[ImGuiKey_Delete]] = true;
            } else if (c == KEY_BACKSPACE || c == KEY_DC || c == 127) {
                ImGui::GetIO().KeysDown[ImGui::GetIO().KeyMap[ImGuiKey_Backspace]] = true;
            // Shift + arrows (probably not portable :()
            } else if (c == 393) {
                ImGui::GetIO().KeysDown[ImGui::GetIO().KeyMap[ImGuiKey_LeftArrow]] = true;
                ImGui::GetIO().KeyShift = true;
            } else if (c == 402) {
                ImGui::GetIO().KeysDown[ImGui::GetIO().KeyMap[ImGuiKey_RightArrow]] = true;
                ImGui::GetIO().KeyShift = true;
            } else if (c == 337) {
                ImGui::GetIO().KeysDown[ImGui::GetIO().KeyMap[ImGuiKey_UpArrow]] = true;
                ImGui::GetIO().KeyShift = true;
            } else if (c == 336) {
                ImGui::GetIO().KeysDown[ImGui::GetIO().KeyMap[ImGuiKey_DownArrow]] = true;
                ImGui::GetIO().KeyShift = true;
            } else if (c == KEY_BACKSPACE) {
                ImGui::GetIO().KeysDown[ImGui::GetIO().KeyMap[ImGuiKey_Backspace]] = true;
            } else if (c == KEY_LEFT) {
                ImGui::GetIO().KeysDown[ImGui::GetIO().KeyMap[ImGuiKey_LeftArrow]] = true;
            } else if (c == KEY_RIGHT) {
                ImGui::GetIO().KeysDown[ImGui::GetIO().KeyMap[ImGuiKey_RightArrow]] = true;
            } else if (c == KEY_UP) {
                ImGui::GetIO().KeysDown[ImGui::GetIO().KeyMap[ImGuiKey_UpArrow]] = true;
            } else if (c == KEY_DOWN) {
                ImGui::GetIO().KeysDown[ImGui::GetIO().KeyMap[ImGuiKey_DownArrow]] = true;
            } else {
                keysDown[c] = true;
            }
        }

        hasInput = true;
    }

    if (ImGui::GetIO().KeysDown[ImGui::GetIO().KeyMap[ImGuiKey_A]]) ImGui::GetIO().KeyCtrl = true;
    if (ImGui::GetIO().KeysDown[ImGui::GetIO().KeyMap[ImGuiKey_C]]) ImGui::GetIO().KeyCtrl = true;
    if (ImGui::GetIO().KeysDown[ImGui::GetIO().KeyMap[ImGuiKey_V]]) ImGui::GetIO().KeyCtrl = true;
    if (ImGui::GetIO().KeysDown[ImGui::GetIO().KeyMap[ImGuiKey_X]]) ImGui::GetIO().KeyCtrl = true;
    if (ImGui::GetIO().KeysDown[ImGui::GetIO().KeyMap[ImGuiKey_Y]]) ImGui::GetIO().KeyCtrl = true;
    if (ImGui::GetIO().KeysDown[ImGui::GetIO().KeyMap[ImGuiKey_Z]]) ImGui::GetIO().KeyCtrl = true;

    ImGui::GetIO().MousePos.x = mx;
    ImGui::GetIO().MousePos.y = my;
    ImGui::GetIO().MouseDown[0] = lbut;
    ImGui::GetIO().MouseDown[1] = rbut;

    ImGui::GetIO().DeltaTime = g_vsync.delta_s();

    return hasInput;
}

// state
static int nColPairs = 1;
static int nActiveFrames = 10;
static ImTui::TScreen screenPrev;
static std::vector<uint8_t> curs;
static std::array<std::pair<bool, int>, 256*256> colPairs;
bool g_has_colors = false;
bool g_has_256_colors = false;

void ImTui_ImplNcurses_DrawScreen(bool active) {
    if (active) nActiveFrames = 10;

    refresh();

    int nx = g_screen->nx;
    int ny = g_screen->ny;

    bool compare = true;

    if (screenPrev.nx != nx || screenPrev.ny != ny) {
        screenPrev.resize(nx, ny);
        compare = false;
    }

    int ic = 0;
    curs.resize(nx + 1);

    for (int y = 0; y < ny; ++y) {
        bool isSame = compare;
        if (compare) {
            for (int x = 0; x < nx; ++x) {
                if (screenPrev.data[y*nx + x] != g_screen->data[y*nx + x]) {
                    isSame = false;
                    break;
                }
            }
        }
        if (isSame) continue;

        int lastp = 0xFFFFFFFF;
        move(y, 0);
        for (int x = 0; x < nx; ++x) {
            const auto cell = g_screen->data[y*nx + x];
            const uint16_t f = (cell & 0x00FF0000) >> 16;
            const uint16_t b = (cell & 0xFF000000) >> 24;
            const uint16_t p = b*256 + f;

            if (g_has_colors && colPairs[p].first == false) {
                if (nColPairs < COLOR_PAIRS - 1) {
                    init_pair(nColPairs, f, b);
                    colPairs[p].first = true;
                    colPairs[p].second = nColPairs;
                    ++nColPairs;
                } else {
                    colPairs[p].first = true;
                    colPairs[p].second = 0;
                }
            }


            if (lastp != (int) p) {
                if (ic > 0) {
                    curs[ic] = 0;
                    addstr((char *) curs.data());
                    ic = 0;
                }
                if (g_has_colors) {
                    attron(COLOR_PAIR(colPairs[p].second));
                }
                lastp = p;
            }

            const uint16_t c = cell & 0x0000FFFF;

            if (c == ' ') {
                curs[ic] = c > 0 ? c : ' ';
            } else {
                curs[ic] = c > 0 ? c + 1 : ' ';
            }

            ic += 1;
        }

        if (ic > 0) {
            curs[ic] = 0;
            addstr((char *) curs.data());
            ic = 0;
        }

        if (compare) {
            memcpy(screenPrev.data + y*nx, g_screen->data + y*nx, nx*sizeof(ImTui::TCell));
        }
    }

    if (!compare) {
        memcpy(screenPrev.data, g_screen->data, nx*ny*sizeof(ImTui::TCell));
    }

    g_vsync.wait(nActiveFrames --> 0);
}

bool ImTui_ImplNcurses_ProcessEvent() {
    return true;
}

*text.cpp

/*! \file imtui-impl-text.cpp
 *  \brief Enter description here.
 */

#if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS)
#define _CRT_SECURE_NO_WARNINGS
#endif

#include "imtui.hpp"
#include "imtui-impl-text.hpp"
#include "imtui-impl-ncurses.hpp"

#include <cmath>
#include <algorithm>
#include <vector>
#include <unordered_map>

#define ABS(x) ((x >= 0) ? x : -x)

void ScanLine(int x1, int y1, int x2, int y2, int ymax, std::vector<int> & xrange) {
    int sx, sy, dx1, dy1, dx2, dy2, x, y, m, n, k, cnt;

    sx = x2 - x1;
    sy = y2 - y1;

    if (sx > 0) dx1 = 1;
    else if (sx < 0) dx1 = -1;
    else dx1 = 0;

    if (sy > 0) dy1 = 1;
    else if (sy < 0) dy1 = -1;
    else dy1 = 0;

    m = ABS(sx);
    n = ABS(sy);
    dx2 = dx1;
    dy2 = 0;

    if (m < n)
    {
        m = ABS(sy);
        n = ABS(sx);
        dx2 = 0;
        dy2 = dy1;
    }

    x = x1; y = y1;
    cnt = m + 1;
    k = n / 2;

    while (cnt--) {
        if ((y >= 0) && (y < ymax)) {
            if (x < xrange[2*y+0]) xrange[2*y+0] = x;
            if (x > xrange[2*y+1]) xrange[2*y+1] = x;
        }

        k += n;
        if (k < m) {
            x += dx2;
            y += dy2;
        } else {
            k -= m;
            x += dx1;
            y += dy1;
        }
    }
}

static std::vector<int> g_xrange;
static std::unordered_map<int, uint8_t> g_character_lookup; // Maps texture position to character code

void drawTriangle(ImVec2 p0, ImVec2 p1, ImVec2 p2, unsigned char col, ImTui::TScreen * screen) {
    int ymin = std::min(std::min(std::min((float) screen->size(), p0.y), p1.y), p2.y);
    int ymax = std::max(std::max(std::max(0.0f, p0.y), p1.y), p2.y);

    int ydelta = ymax - ymin + 1;

    if ((int) g_xrange.size() < 2*ydelta) {
        g_xrange.resize(2*ydelta);
    }

    for (int y = 0; y < ydelta; y++) {
        g_xrange[2*y+0] = 999999;
        g_xrange[2*y+1] = -999999;
    }

    ScanLine(p0.x, p0.y - ymin, p1.x, p1.y - ymin, ydelta, g_xrange);
    ScanLine(p1.x, p1.y - ymin, p2.x, p2.y - ymin, ydelta, g_xrange);
    ScanLine(p2.x, p2.y - ymin, p0.x, p0.y - ymin, ydelta, g_xrange);

    for (int y = 0; y < ydelta; y++) {
        if (g_xrange[2*y+1] >= g_xrange[2*y+0]) {
            int x = g_xrange[2*y+0];
            int len = 1 + g_xrange[2*y+1] - g_xrange[2*y+0];

            while (len--) {
                if (x >= 0 && x < screen->nx && y + ymin >= 0 && y + ymin < screen->ny) {
                    auto & cell = screen->data[(y + ymin)*screen->nx + x];
                    cell &= 0x00FF0000;
                    cell |= ' ';
                    cell |= ((ImTui::TCell)(col) << 24);
                }
                ++x;
            }
        }
    }
}

inline ImTui::TColor rgbToAnsi256(ImU32 col, bool doAlpha) {
    if (!g_has_colors) {
        return 7;
    }

    if (!g_has_256_colors) {
        ImTui::TColor r = col & 0x000000FF;
        ImTui::TColor g = (col & 0x0000FF00) >> 8;
        ImTui::TColor b = (col & 0x00FF0000) >> 16;

        if (doAlpha) {
            ImTui::TColor a = (col & 0xFF000000) >> 24;
            float scale = float(a)/255.0f;
            r = std::round(r*scale);
            g = std::round(g*scale);
            b = std::round(b*scale);
        }

        int brightness = (r + g + b) / 3;
        if (brightness < 64) return 0;
        else if (brightness < 128) return 8;
        else if (brightness < 192) return 7;
        else return 15;
    }
    ImTui::TColor r = col & 0x000000FF;
    ImTui::TColor g = (col & 0x0000FF00) >> 8;
    ImTui::TColor b = (col & 0x00FF0000) >> 16;

    if (r == g && g == b) {
        if (doAlpha) {
            ImTui::TColor a = (col & 0xFF000000) >> 24;
            r = (float(r)*a)/255.0f;
        }
        if (r < 8) {
            return 16;
        }

        if (r > 248) {
            return 231;
        }

        return std::round((float(r - 8) / 247) * 24) + 232;
    }

    if (doAlpha) {
        ImTui::TColor a = (col & 0xFF000000) >> 24;
        float scale = float(a)/255.0f;
        r = std::round(r*scale);
        g = std::round(g*scale);
        b = std::round(b*scale);
    }

    ImTui::TColor res = 16
        + (36 * std::round((float(r) / 255.0f) * 5.0f))
        + (6 * std::round((float(g) / 255.0f) * 5.0f))
        + std::round((float(b) / 255.0f) * 5.0f);

    return res;
}

void ImTui_ImplText_RenderDrawData(ImDrawData * drawData, ImTui::TScreen * screen) {
    // Avoid rendering when minimized, scale coordinates for retina displays (screen coordinates != framebuffer coordinates)
    int fb_width = (int)(drawData->DisplaySize.x * drawData->FramebufferScale.x);
    int fb_height = (int)(drawData->DisplaySize.y * drawData->FramebufferScale.y);

    if (fb_width <= 0 || fb_height <= 0) {
        return;
    }

    screen->resize(ImGui::GetIO().DisplaySize.x, ImGui::GetIO().DisplaySize.y);
    screen->clear();

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

    // Render command lists
    for (int n = 0; n < drawData->CmdListsCount; n++)
    {
        const ImDrawList* cmd_list = drawData->CmdLists[n];

        for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.Size; cmd_i++)
        {
            const ImDrawCmd* pcmd = &cmd_list->CmdBuffer[cmd_i];
            {
                ImVec4 clip_rect;
                clip_rect.x = (pcmd->ClipRect.x - clip_off.x) * clip_scale.x;
                clip_rect.y = (pcmd->ClipRect.y - clip_off.y) * clip_scale.y;
                clip_rect.z = (pcmd->ClipRect.z - clip_off.x) * clip_scale.x;
                clip_rect.w = (pcmd->ClipRect.w - clip_off.y) * clip_scale.y;

                if (clip_rect.x < fb_width && clip_rect.y < fb_height && clip_rect.z >= 0.0f && clip_rect.w >= 0.0f)
                {
                    float lastCharX = -10000.0f;
                    float lastCharY = -10000.0f;

                    for (unsigned int i = 0; i < pcmd->ElemCount; i += 3) {
                        int vidx0 = cmd_list->IdxBuffer[pcmd->IdxOffset + i + 0];
                        int vidx1 = cmd_list->IdxBuffer[pcmd->IdxOffset + i + 1];
                        int vidx2 = cmd_list->IdxBuffer[pcmd->IdxOffset + i + 2];

                        auto pos0 = cmd_list->VtxBuffer[vidx0].pos;
                        auto pos1 = cmd_list->VtxBuffer[vidx1].pos;
                        auto pos2 = cmd_list->VtxBuffer[vidx2].pos;

                        pos0.x = std::max(std::min(float(clip_rect.z - 1), pos0.x), clip_rect.x);
                        pos1.x = std::max(std::min(float(clip_rect.z - 1), pos1.x), clip_rect.x);
                        pos2.x = std::max(std::min(float(clip_rect.z - 1), pos2.x), clip_rect.x);
                        pos0.y = std::max(std::min(float(clip_rect.w - 1), pos0.y), clip_rect.y);
                        pos1.y = std::max(std::min(float(clip_rect.w - 1), pos1.y), clip_rect.y);
                        pos2.y = std::max(std::min(float(clip_rect.w - 1), pos2.y), clip_rect.y);

                        auto uv0 = cmd_list->VtxBuffer[vidx0].uv;
                        auto uv1 = cmd_list->VtxBuffer[vidx1].uv;
                        auto uv2 = cmd_list->VtxBuffer[vidx2].uv;

                        auto col0 = cmd_list->VtxBuffer[vidx0].col;
                        //auto col1 = cmd_list->VtxBuffer[vidx1].col;
                        //auto col2 = cmd_list->VtxBuffer[vidx2].col;

                        if (uv0.x != uv1.x || uv0.x != uv2.x || uv1.x != uv2.x ||
                            uv0.y != uv1.y || uv0.y != uv2.y || uv1.y != uv2.y) {
                            int vvidx0 = cmd_list->IdxBuffer[pcmd->IdxOffset + i + 3];
                            int vvidx1 = cmd_list->IdxBuffer[pcmd->IdxOffset + i + 4];
                            int vvidx2 = cmd_list->IdxBuffer[pcmd->IdxOffset + i + 5];

                            auto ppos0 = cmd_list->VtxBuffer[vvidx0].pos;
                            auto ppos1 = cmd_list->VtxBuffer[vvidx1].pos;
                            auto ppos2 = cmd_list->VtxBuffer[vvidx2].pos;

                            float x = ((pos0.x + pos1.x + pos2.x + ppos0.x + ppos1.x + ppos2.x)/6.0f);
                            float y = ((pos0.y + pos1.y + pos2.y + ppos0.y + ppos1.y + ppos2.y)/6.0f) + 0.5f;

                            if (std::fabs(y - lastCharY) < 0.5f && std::fabs(x - lastCharX) < 0.5f) {
                                x = lastCharX + 1.0f;
                                y = lastCharY;
                            }

                            lastCharX = x;
                            lastCharY = y;

                            int xx = (x) + 1;
                            int yy = (y) + 0;
                            if (xx < clip_rect.x || xx >= clip_rect.z || yy < clip_rect.y || yy >= clip_rect.w) {
                            } else {
                                // Get character from texture coordinates
                                uint8_t char_code = ' '; // Default to space

                                // Get the font atlas for texture dimensions
                                ImFontAtlas* atlas = ImGui::GetIO().Fonts;
                                if (atlas != nullptr) {
                                    // UV coords are [0..1], convert to pixel coordinates
                                    int tex_x = static_cast<int>(uv0.x * atlas->TexWidth);
                                    int tex_y = static_cast<int>(uv0.y * atlas->TexHeight);

                                    // Look up character using texture position
                                    int tex_index = tex_x + tex_y * atlas->TexWidth;
                                    auto it = g_character_lookup.find(tex_index);
                                    if (it != g_character_lookup.end()) {
                                        char_code = it->second;
                                    }
                                }

                                auto & cell = screen->data[yy*screen->nx + xx];
                                cell &= 0xFF000000;
                                cell |= char_code;  // Use the looked-up character code
                                cell |= ((ImTui::TCell)(rgbToAnsi256(col0, false)) << 16);
                            }
                            i += 3;
                        } else {
                            drawTriangle(pos0, pos1, pos2, rgbToAnsi256(col0, true), screen);
                        }
                    }
                }
            }
        }
    }

}

bool ImTui_ImplText_Init() {
    ImGui::GetStyle().Alpha                   = 1.0f;
    ImGui::GetStyle().WindowPadding           = ImVec2(0.5f, 0.0f);
    ImGui::GetStyle().WindowRounding          = 0.0f;
    ImGui::GetStyle().WindowBorderSize        = 0.0f;
    ImGui::GetStyle().WindowMinSize           = ImVec2(4.0f, 2.0f);
    ImGui::GetStyle().WindowTitleAlign        = ImVec2(0.0f, 0.0f);
    ImGui::GetStyle().WindowMenuButtonPosition= ImGuiDir_Left;
    ImGui::GetStyle().ChildRounding           = 0.0f;
    ImGui::GetStyle().ChildBorderSize         = 0.0f;
    ImGui::GetStyle().PopupRounding           = 0.0f;
    ImGui::GetStyle().PopupBorderSize         = 0.0f;
    ImGui::GetStyle().FramePadding            = ImVec2(1.0f, 0.0f);
    ImGui::GetStyle().FrameRounding           = 0.0f;
    ImGui::GetStyle().FrameBorderSize         = 0.0f;
    ImGui::GetStyle().ItemSpacing             = ImVec2(1.0f, 0.0f);
    ImGui::GetStyle().ItemInnerSpacing        = ImVec2(1.0f, 0.0f);
    ImGui::GetStyle().TouchExtraPadding       = ImVec2(0.5f, 0.0f);
    ImGui::GetStyle().IndentSpacing           = 1.0f;
    ImGui::GetStyle().ColumnsMinSpacing       = 1.0f;
    ImGui::GetStyle().ScrollbarSize           = 0.5f;
    ImGui::GetStyle().ScrollbarRounding       = 0.0f;
    ImGui::GetStyle().GrabMinSize             = 0.1f;
    ImGui::GetStyle().GrabRounding            = 0.0f;
    ImGui::GetStyle().TabRounding             = 0.0f;
    ImGui::GetStyle().TabBorderSize           = 0.0f;
    ImGui::GetStyle().ColorButtonPosition     = ImGuiDir_Right;
    ImGui::GetStyle().ButtonTextAlign         = ImVec2(0.5f,0.0f);
    ImGui::GetStyle().SelectableTextAlign     = ImVec2(0.0f,0.0f);
    ImGui::GetStyle().DisplayWindowPadding    = ImVec2(0.0f,0.0f);
    ImGui::GetStyle().DisplaySafeAreaPadding  = ImVec2(0.0f,0.0f);
    ImGui::GetStyle().CellPadding             = ImVec2(1.0f,0.0f);
    ImGui::GetStyle().MouseCursorScale        = 1.0f;
    ImGui::GetStyle().AntiAliasedLines        = false;
    ImGui::GetStyle().AntiAliasedFill         = false;
    ImGui::GetStyle().CurveTessellationTol    = 1.25f;

    ImGui::GetStyle().Colors[ImGuiCol_WindowBg]         = ImVec4(0.15, 0.15, 0.15, 1.0f);
    ImGui::GetStyle().Colors[ImGuiCol_TitleBg]          = ImVec4(0.35, 0.35, 0.35, 1.0f);
    ImGui::GetStyle().Colors[ImGuiCol_TitleBgCollapsed] = ImVec4(0.15, 0.15, 0.15, 1.0f);
    ImGui::GetStyle().Colors[ImGuiCol_TextSelectedBg]   = ImVec4(0.75, 0.75, 0.75, 0.5f);
    ImGui::GetStyle().Colors[ImGuiCol_NavHighlight]     = ImVec4(0.00, 0.00, 0.00, 0.0f);
    ImGui::GetStyle().Colors[ImGuiCol_Text]     = ImVec4(1.00, 1.00, 1.00, 1.0f);

    ImFontConfig fontConfig;
    fontConfig.GlyphMinAdvanceX = 1.0f;
    fontConfig.SizePixels = 1.00;
    ImFont* font = ImGui::GetIO().Fonts->AddFontDefault(&fontConfig);

    // Clear the character lookup map
    g_character_lookup.clear();

    // Tell imgui we have lots of 1x1 custom character glyphs in the texture
    int ids[256]; // Store the returned IDs
    for (int i = 1; i < 256; i++) {
        ids[i] = ImGui::GetIO().Fonts->AddCustomRectFontGlyph(font, i, 1, 1, 1.0f);
    }

    // Build atlas
    unsigned char* tex_pixels = NULL;
    int tex_w, tex_h;
    ImGui::GetIO().Fonts->GetTexDataAsRGBA32(&tex_pixels, &tex_w, &tex_h);

    // Store the texture coordinates in a hashmap
    for (int i = 1; i < 256; i++) {
        // Lookup the ID we got, and get the texture coordinates (in integer pixel values)
        const auto rect = ImGui::GetIO().Fonts->GetCustomRectByIndex(ids[i]);
        if (rect != nullptr) {
            // Store the texture index with the character value
            g_character_lookup[rect->X + rect->Y * tex_w] = i;
        }
    }

    ImGui::GetIO().Fonts->Build();
    return true;
}

void ImTui_ImplText_Shutdown() {
}

void ImTui_ImplText_NewFrame() {
}