open_gl.cpp

// open_gl.cpp - FINAL FIXED VERSION (context-loss proof + state safe)
// Created by mrjar on 12/1/2025.

#include "imgui/imgui.h"
#include "imgui/backends/imgui_impl_android.h"
#include "imgui/backends/imgui_impl_opengl3.h"

#include <EGL/egl.h>
#include <GLES3/gl3.h>
#include <dlfcn.h>
#include <stdio.h>

extern "C" {
#include "inlinehook.h"
#include "dynlib.h"
}

static int g_Width = 0, g_Height = 0;
static bool g_Setup = false;

static EGLDisplay g_LastDisplay = EGL_NO_DISPLAY;
static EGLSurface g_LastSurface = EGL_NO_SURFACE;

static EGLBoolean (*orig_eglSwapBuffers)(EGLDisplay, EGLSurface) = nullptr;

extern void render_ui();
extern void cleanup_ui();

struct SavedGLState {
    GLint viewport[4] = {0};
    GLint program = 0;
    GLint texture = 0;
    GLint array_buffer = 0;
    GLint vertex_array = 0;
    GLboolean blend = GL_FALSE;
    GLboolean depth = GL_FALSE;
    GLboolean cull = GL_FALSE;
    GLboolean scissor = GL_FALSE;
};

static void SaveGLState(SavedGLState& state) {


    glGetIntegerv(GL_VIEWPORT, state.viewport);
    glGetIntegerv(GL_CURRENT_PROGRAM, &state.program);
    glGetIntegerv(GL_TEXTURE_BINDING_2D, &state.texture);
    glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &state.array_buffer);
    glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &state.vertex_array);

    state.blend   = glIsEnabled(GL_BLEND);
    state.depth   = glIsEnabled(GL_DEPTH_TEST);
    state.cull    = glIsEnabled(GL_CULL_FACE);
    state.scissor = glIsEnabled(GL_SCISSOR_TEST);
}

static void RestoreGLState(const SavedGLState& state) {


    glViewport(state.viewport[0], state.viewport[1], state.viewport[2], state.viewport[3]);
    glUseProgram(state.program);
    glBindTexture(GL_TEXTURE_2D, state.texture);
    glBindBuffer(GL_ARRAY_BUFFER, state.array_buffer);
    glBindVertexArray(state.vertex_array);

    if (state.blend)   glEnable(GL_BLEND);   else glDisable(GL_BLEND);
    if (state.depth)   glEnable(GL_DEPTH_TEST); else glDisable(GL_DEPTH_TEST);
    if (state.cull)    glEnable(GL_CULL_FACE);  else glDisable(GL_CULL_FACE);
    if (state.scissor) glEnable(GL_SCISSOR_TEST); else glDisable(GL_SCISSOR_TEST);
}

static void InitializeImGui(EGLDisplay display, EGLSurface surface) {


    eglQuerySurface(display, surface, EGL_WIDTH, &g_Width);
    eglQuerySurface(display, surface, EGL_HEIGHT, &g_Height);



    if (g_Width <= 1 || g_Height <= 1) {
        return;
    }

    IMGUI_CHECKVERSION();
    ImGui::CreateContext();
    ImGui::GetIO().DisplaySize = ImVec2((float)g_Width, (float)g_Height);
    ImGui::GetIO().IniFilename = nullptr;

    ImGui_ImplAndroid_Init(nullptr);
    ImGui_ImplOpenGL3_Init("#version 300 es");

    ImGui::StyleColorsDark();
    ImGui::GetStyle().ScaleAllSizes(2.0f);

    ImFontConfig cfg{};
    cfg.SizePixels = 32.0f;
    ImGui::GetIO().Fonts->AddFontDefault(&cfg);
    ImGui::GetIO().Fonts->Build();

    g_Setup = true;
    g_LastDisplay = display;
    g_LastSurface = surface;


}

static EGLBoolean hook_eglSwapBuffers(EGLDisplay display, EGLSurface surface) {


    int width = 0, height = 0;
    eglQuerySurface(display, surface, EGL_WIDTH, &width);
    eglQuerySurface(display, surface, EGL_HEIGHT, &height);

    if (width <= 1 || height <= 1 ||
        display != g_LastDisplay ||
        surface != g_LastSurface) {

        if (g_Setup) {
            ImGui_ImplOpenGL3_Shutdown();
            ImGui_ImplAndroid_Shutdown();
            ImGui::DestroyContext();
            g_Setup = false;
        }
    }


    if (!g_Setup) {
        InitializeImGui(display, surface);

        if (!g_Setup) {
            return orig_eglSwapBuffers(display, surface);
        }
    }


    eglQuerySurface(display, surface, EGL_WIDTH, &g_Width);
    eglQuerySurface(display, surface, EGL_HEIGHT, &g_Height);
    ImGui::GetIO().DisplaySize = ImVec2((float)g_Width, (float)g_Height);


    SavedGLState saved;
    SaveGLState(saved);


    ImGui_ImplOpenGL3_NewFrame();
    ImGui_ImplAndroid_NewFrame(g_Width, g_Height);
    ImGui::NewFrame();

    render_ui();

    ImGui::Render();
    glViewport(0, 0, g_Width, g_Height);
    ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());


    RestoreGLState(saved);

    return orig_eglSwapBuffers(display, surface);
}

void setup_opengl_hooks() {
    printf("[HOOK] Setting up OpenGL hooks...\n");

    void* egl_handle = dlopen("libEGL.so", RTLD_LAZY | RTLD_GLOBAL);
    if (!egl_handle) {
        printf("[HOOK] ERROR: Failed to dlopen libEGL.so!\n");
        return;
    }

    void* swap_addr = gpwn_dlsym("libEGL.so", "eglSwapBuffers");
    if (swap_addr) {
        printf("[HOOK] Found eglSwapBuffers @ %p\n", swap_addr);

        hook_addr(swap_addr,
                  (void*)hook_eglSwapBuffers,
                  (void**)&orig_eglSwapBuffers,
                  GPWN_AARCH64_NANOHOOK);

        printf("[HOOK] eglSwapBuffers successfully hooked.\n");
    } else {
        printf("[HOOK] ERROR: Could not find eglSwapBuffers symbol.\n");
    }

    dlclose(egl_handle);
}