looper/backends/ui/imgui/RendererBackend.cpp

#include "RendererBackend.h"
#include <assets/assets.h>
#include <vector>
#include "IconsForkAwesome.h"
#include "config.h"
#include <SDL_image.h>
#include <string>
#include "theme.h"
#include "imgui_stdlib.h"
#include "imgui_impl_sdl2.h"
#include "imgui_impl_opengl3.h"
#include "base85.h"
#include <thread>
#include "translation.h"
#include <log.hpp>
using std::vector;
#ifdef __EMSCRIPTEN__
extern "C" {
    extern void get_size(int32_t *x, int32_t *y);
}
#endif
void RendererBackend::on_resize() {
#ifdef __EMSCRIPTEN__
    int32_t x, y;
    get_size(&x, &y);
    SDL_SetWindowSize(window, (int)x, (int)y);
#endif
}
static RendererBackend *renderer_backend;

void RendererBackend::resize_static() {
    renderer_backend->resize_needed = true;
}
void main_loop() {
    renderer_backend->LoopFunction();
#ifdef __EMSCRIPTEN__
    if (renderer_backend->done) {
        renderer_backend->BackendDeinit();
        emscripten_cancel_main_loop();
    }
#endif
}
void RendererBackend::BackendDeinit() {
    ImGuiIO& io = ImGui::GetIO(); (void)io;
    // Cleanup
    ImGui_ImplOpenGL3_Shutdown();
    ImGui_ImplSDL2_Shutdown();
    ImGui::DestroyContext();

    SDL_GL_DeleteContext(gl_context);
    SDL_DestroyWindow(window);
    IMG_Quit();
    SDL_Quit();
    free((void*)io.IniFilename);
    Deinit();
    renderer_backend = nullptr;
}
void RendererBackend::LoopFunction() {
    ImGuiIO& io = ImGui::GetIO(); (void)io;
    if (resize_needed) {
        on_resize();
    }
    auto next_frame = std::chrono::steady_clock::now() + std::chrono::milliseconds(1000 / framerate);
    // Poll and handle events (inputs, window resize, etc.)
    // You can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to tell if dear imgui wants to use your inputs.
    // - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application, or clear/overwrite your copy of the mouse data.
    // - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application, or clear/overwrite your copy of the keyboard data.
    // Generally you may always pass all inputs to dear imgui, and hide them from your application based on those two flags.
    SDL_Event event;
    while (SDL_PollEvent(&event))
    {
        ImGui_ImplSDL2_ProcessEvent(&event);
        if (event.type == SDL_QUIT)
            done = true;
        if (event.type == SDL_WINDOWEVENT) {
            if (event.window.event == SDL_WINDOWEVENT_RESIZED) {
                window_width = event.window.data1 / scale;
                window_height = event.window.data2 / scale;
                //SDL_GetWindowSize(window, &window_width, &window_height);
            }
            if (event.window.event == SDL_WINDOWEVENT_DISPLAY_CHANGED) {
                UpdateScale();
            }
            if (event.window.event == SDL_WINDOWEVENT_CLOSE && event.window.windowID == SDL_GetWindowID(window)) {
                done = true;
            }
        }
        if (event.type == SDL_DROPFILE) {
            if (event.drop.file != NULL) {
                Drop(std::string(event.drop.file));
                free(event.drop.file);
            }
        }
    }
    // Start the Dear ImGui frame
    ImGui_ImplOpenGL3_NewFrame();
    ImGui_ImplSDL2_NewFrame();
    ImGui::NewFrame();
    // Run the GUI
    GuiFunction();
    // Rendering
    ImGui::Render();
    // Update the window size.
    glViewport(0, 0, (int)io.DisplaySize.x, (int)io.DisplaySize.y);
    // Clear the screen.
    glClearColor(clear_color.x * clear_color.w, clear_color.y * clear_color.w, clear_color.z * clear_color.w, clear_color.w);
    glClear(GL_COLOR_BUFFER_BIT);
    // Tell ImGui to render.
    ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());

    // Update and Render additional Platform Windows
    // (Platform functions may change the current OpenGL context, so we save/restore it to make it easier to paste this code elsewhere.
    //  For this specific demo app we could also call SDL_GL_MakeCurrent(window, gl_context) directly)
    if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
    {
        SDL_Window* backup_current_window = SDL_GL_GetCurrentWindow();
        SDL_GLContext backup_current_context = SDL_GL_GetCurrentContext();
        ImGui::UpdatePlatformWindows();
        ImGui::RenderPlatformWindowsDefault();
        SDL_GL_MakeCurrent(backup_current_window, backup_current_context);
    }

    // Swap the buffers, and do VSync if enabled.
    SDL_GL_SwapWindow(window);
    // If not doing VSync, wait until the next frame needs to be rendered.
    if (!vsync) {
        std::this_thread::sleep_until(next_frame);
    }
}
struct FontData {
    const char* data;
    const ImWchar *ranges;
};

ImFont *add_font(vector<FontData> data_vec, int size = 13) {
    ImFont* font = nullptr;
    ImGuiIO& io = ImGui::GetIO();
    for (auto data : data_vec) {
        ImFontConfig font_cfg = ImFontConfig();
        font_cfg.SizePixels = size;
        font_cfg.OversampleH = font_cfg.OversampleV = 1;
        font_cfg.PixelSnapH = true;
        if (font_cfg.SizePixels <= 0.0f)
            font_cfg.SizePixels = 13.0f * 1.0f;
        if (font != nullptr) {
            font_cfg.DstFont = font;
            font_cfg.MergeMode = true;
        }
        //font_cfg.EllipsisChar = (ImWchar)0x0085;
        //font_cfg.GlyphOffset.y = 1.0f * IM_FLOOR(font_cfg.SizePixels / 13.0f);  // Add +1 offset per 13 units

        const char* ttf_compressed_base85 = data.data;
        const ImWchar* glyph_ranges = data.ranges;
        auto new_font = io.Fonts->AddFontFromMemoryCompressedBase85TTF(ttf_compressed_base85, font_cfg.SizePixels, &font_cfg, glyph_ranges);
        if (font == nullptr) font = new_font;
    }
    {
        ImFontConfig config;
        config.MergeMode = true;
        config.GlyphMinAdvanceX = size;
        config.SizePixels = size;
        config.DstFont = font;
        static const ImWchar icon_ranges[] = { ICON_MIN_FK, ICON_MAX_FK, 0 };
        io.Fonts->AddFontFromMemoryCompressedBase85TTF(forkawesome_compressed_data_base85, float(size), &config, icon_ranges);
    }
    return font;
}
RendererBackend::RendererBackend() {
}
RendererBackend::~RendererBackend() {

}
void RendererBackend::SetWindowTitle(const char *title) {
    SDL_SetWindowTitle(window, title);
}
void RendererBackend::GuiFunction() {
    // Do nothing by default.
}
void RendererBackend::UpdateScale() {
    double prevScale = scale;
    const double defaultDPI =
    #ifdef __APPLE__
        72.0;
    #else
        96.0;
    #endif
    float dpi = defaultDPI;
    if (SDL_GetDisplayDPI(SDL_GetWindowDisplayIndex(window), NULL, &dpi, NULL) == 0){
        scale = dpi / defaultDPI;
    } else {
        WARNING.writeln("DPI couldn't be determined!");
        scale = 1.0;
    }
    SDL_SetWindowSize(window, window_width * scale, window_height * scale);
    AddFonts();
}
void RendererBackend::SetWindowSize(int w, int h) {
    window_width = w;
    window_height = h;
    SDL_SetWindowSize(window, w * scale, h * scale);
}
void RendererBackend::GetWindowsize(int *w, int *h) {
    int ww, wh;
    SDL_GetWindowSize(window, &ww, &wh);
    ww /= scale;
    wh /= scale;
    if (w) *w = ww;
    if (h) *h = wh;
}
void RendererBackend::AddFonts() {
    ImGui_ImplOpenGL3_DestroyFontsTexture();
    auto& io = ImGui::GetIO(); (void)io;
    io.Fonts->Clear();
    add_font(vector<FontData>({FontData {notosans_regular_compressed_data_base85, io.Fonts->GetGlyphRangesDefault()}, FontData {notosansjp_regular_compressed_data_base85, io.Fonts->GetGlyphRangesJapanese()}}), 13 * scale);
    title = add_font(vector<FontData>({FontData {notosans_thin_compressed_data_base85, io.Fonts->GetGlyphRangesDefault()}, FontData {notosansjp_thin_compressed_data_base85, io.Fonts->GetGlyphRangesJapanese()}}), 48 * scale);
    ImGui_ImplOpenGL3_CreateFontsTexture();
}
#ifdef __EMSCRIPTEN__
static EM_BOOL resize_callback(int event_type, const EmscriptenUiEvent *event, void *userdata) {
    RendererBackend::resize_static();
}
#endif
int RendererBackend::Run() {
    setlocale(LC_ALL, "");
    bindtextdomain("neko_player", LOCALE_DIR);
    textdomain("neko_player");
    DEBUG.writefln("Loaded locale '%s' from '%s'...", CURRENT_LANGUAGE, LOCALE_DIR);
    DEBUG.writefln("Locale name: %s", _TR_CTX("Language name", "English (United States)"));
    bool enable_kms = std::getenv("LAP_KMS") != nullptr;
    SDL_SetHint(SDL_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR, "false");
    SDL_SetHint(SDL_HINT_APP_NAME, NAME);
    // Setup SDL
    if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER | SDL_INIT_GAMECONTROLLER) != 0)
    {
        ERROR.writefln("Error: %s", SDL_GetError());
        return -1;
    }
    if (std::string(SDL_GetCurrentVideoDriver()) == "KMSDRM") {
        enable_kms = true;
    }
    IMG_Init(IMG_INIT_PNG|IMG_INIT_WEBP);
    prefPath = SDL_GetPrefPath("Catmeow72", NAME);
    Theme::prefPath = prefPath;

    // Decide GL+GLSL versions
#if defined(IMGUI_IMPL_OPENGL_ES2)
    // GL ES 2.0 + GLSL 100
    const char* glsl_version = "#version 100";
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, 0);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
#elif defined(__APPLE__)
    // GL 3.2 Core + GLSL 150
    const char* glsl_version = "#version 150";
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG); // Always required on Mac
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
#else
    // GL 3.0 + GLSL 130
    const char* glsl_version = "#version 130";
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, 0);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
#endif

    // From 2.0.18: Enable native IME.
#ifdef SDL_HINT_IME_SHOW_UI
    SDL_SetHint(SDL_HINT_IME_SHOW_UI, "1");
#endif

    // Create window with graphics context
    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
    SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
    SDL_WindowFlags window_flags = (SDL_WindowFlags)(SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI | SDL_WINDOW_HIDDEN);
    window = SDL_CreateWindow(NAME, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, window_width, window_height, window_flags);
    SDL_SetWindowMinimumSize(window, window_width, window_height);
    if (enable_kms) {
        SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP);
    }
    SDL_EventState(SDL_DROPFILE, SDL_ENABLE);
    const vector<unsigned char> icon_data = DecodeBase85(icon_compressed_data_base85);
    SDL_Surface* icon = IMG_Load_RW(SDL_RWFromConstMem(icon_data.data(), icon_data.size()), 1);
    SDL_SetWindowIcon(window, icon);
    gl_context = SDL_GL_CreateContext(window);
    SDL_GL_MakeCurrent(window, gl_context);

    // Setup Dear ImGui context
    IMGUI_CHECKVERSION();
    ImGui::CreateContext();
    ImGuiIO& io = ImGui::GetIO(); (void)io;
    io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;     // Enable Keyboard Controls
    io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;      // Enable Gamepad Controls
    io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;
    //io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable;
    io.IniFilename = strdup((std::string(prefPath) + "imgui.ini").c_str());
    if (enable_kms) {
        io.MouseDrawCursor = true;
    }
    //io.ConfigViewportsNoAutoMerge = true;
    //io.ConfigViewportsNoTaskBarIcon = true;

    //ImGui::StyleColorsLight();

    // Setup Platform/Renderer backends
    ImGui_ImplSDL2_InitForOpenGL(window, gl_context);
    ImGui_ImplOpenGL3_Init(glsl_version);
    // Load Fonts
    // - If no fonts are loaded, dear imgui will use the default font. You can also load multiple fonts and use ImGui::PushFont()/PopFont() to select them.
    // - AddFontFromFileTTF() will return the ImFont* so you can store it if you need to select the font among multiple.
    // - If the file cannot be loaded, the function will return a nullptr. Please handle those errors in your application (e.g. use an assertion, or display an error and quit).
    // - The fonts will be rasterized at a given size (w/ oversampling) and stored into a texture when calling ImFontAtlas::Build()/GetTexDataAsXXXX(), which ImGui_ImplXXXX_NewFrame below will call.
    // - Use '#define IMGUI_ENABLE_FREETYPE' in your imconfig file to use Freetype for higher quality font rendering.
    // - Read 'docs/FONTS.md' for more instructions and details.
    // - Remember that in C/C++ if you want to include a backslash \ in a string literal you need to write a double backslash \\ !
    //io.Fonts->AddFontDefault();
    //io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\segoeui.ttf", 18.0f);
    //io.Fonts->AddFontFromFileTTF("../../misc/fonts/DroidSans.ttf", 16.0f);
    //io.Fonts->AddFontFromFileTTF("../../misc/fonts/Roboto-Medium.ttf", 16.0f);
    //io.Fonts->AddFontFromFileTTF("../../misc/fonts/Cousine-Regular.ttf", 15.0f);
    //ImFont* font = io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\ArialUni.ttf", 18.0f, nullptr, io.Fonts->GetGlyphRangesJapanese());
    //IM_ASSERT(font != nullptr);
    UpdateScale();

    
    theme = new Theme(false);
    userdir = std::getenv(
    #ifdef _WIN32
    "UserProfile"
    #else
    "HOME"
    #endif
    );
#ifndef __EMSCRIPTEN__
    SDL_GL_SetSwapInterval(vsync ? 1 : 0);
#endif
    theme->Apply(accent_color);
    Init();
    SDL_ShowWindow(window);
    renderer_backend = this;
#ifdef __EMSCRIPTEN__
    // For an Emscripten build we are disabling file-system access, so let's not attempt to do a fopen() of the imgui.ini file.
    // You may manually call LoadIniSettingsFromMemory() to load settings from your own storage.
    io.IniFilename = nullptr;
    emscripten_set_resize_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 0, resize_callback);
    emscripten_set_main_loop(&main_loop, 0, 1);
#else
    while (!done)
    {
        LoopFunction();
    }
    BackendDeinit();
#endif
    return 0;
}
void RendererBackend::Init() {
    // Do nothing by default.
}
void RendererBackend::Deinit() {
    // Do nothing by default.
}
void RendererBackend::Drop(std::string file) {
    // Do nothing by default.
}