[Feat|Fix] (MG_State/EGLState|MG_Backend|MG_Impl/EGLImpl): Initial implemention of EGL API.

MobileGL/MG_Backend/BackendObject.cpp

@@ -9,7 +9,133 @@
 #include "BackendObject.h"
 
 namespace MobileGL::MG_Backend {
+    namespace {
+        Bool IsReleaseCurrentRequest(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx) {
+            return dpy == EGL_NO_DISPLAY && draw == EGL_NO_SURFACE && read == EGL_NO_SURFACE && ctx == EGL_NO_CONTEXT;
+        }
+
+        std::thread::id CurrentThreadKey() {
+            return std::this_thread::get_id();
+        }
+    } // namespace
+
+    Bool BackendObject::InitializeEGLDisplay(EGLDisplay dpy, EGLint* major, EGLint* minor) {
+        const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
+        if (dpy == EGL_NO_DISPLAY) {
+            MGLOG_E("InitializeEGLDisplay failed: invalid EGLDisplay");
+            return false;
+        }
+
+        if (m_eglDisplayInitialized && m_eglDisplay != dpy) {
+            MGLOG_E("InitializeEGLDisplay failed: backend already bound to a different EGLDisplay");
+            return false;
+        }
+
+        m_eglDisplay = dpy;
+        m_eglDisplayInitialized = true;
+        if (major) {
+            *major = 1;
+        }
+        if (minor) {
+            *minor = 5;
+        }
+        return true;
+    }
+
+    Bool BackendObject::CreateEGLWindowSurface(const WindowHandle& handle) {
+        const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
+        if (!m_eglDisplayInitialized) {
+            MGLOG_E("CreateEGLWindowSurface failed: EGL display is not initialized");
+            return false;
+        }
+        if (handle.Backend == WindowBackend::Unknown || !handle.Handle) {
+            MGLOG_E("CreateEGLWindowSurface failed: invalid native window handle");
+            return false;
+        }
+
+        if (m_eglWindowSurfaceInitialized && m_windowHandle.Backend == handle.Backend && m_windowHandle.Handle == handle.Handle) {
+            return true;
+        }
+
+        SetWindowHandle(handle);
+        if (!InitWindowSurface()) {
+            MGLOG_E("CreateEGLWindowSurface failed: backend InitWindowSurface failed");
+            return false;
+        }
+
+        m_eglWindowSurfaceInitialized = true;
+        m_eglCurrentThreads.clear();
+        m_backendCapabilitiesInitialized = false;
+        return true;
+    }
+
+    Bool BackendObject::MakeEGLCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx) {
+        const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
+        const auto threadKey = CurrentThreadKey();
+        if (IsReleaseCurrentRequest(dpy, draw, read, ctx)) {
+            m_eglCurrentThreads.erase(threadKey);
+            return true;
+        }
+
+        if (!m_eglDisplayInitialized || m_eglDisplay != dpy) {
+            MGLOG_E("MakeEGLCurrent failed: EGL display mismatch or not initialized");
+            return false;
+        }
+        if (!m_eglWindowSurfaceInitialized) {
+            MGLOG_E("MakeEGLCurrent failed: EGL window surface is not initialized");
+            return false;
+        }
+        if (draw == EGL_NO_SURFACE || read == EGL_NO_SURFACE || ctx == EGL_NO_CONTEXT) {
+            MGLOG_E("MakeEGLCurrent failed: draw/read/context is invalid");
+            return false;
+        }
+
+        if (!m_backendCapabilitiesInitialized) {
+            if (!InitCapabilities()) {
+                MGLOG_E("MakeEGLCurrent failed: InitCapabilities failed");
+                return false;
+            }
+            m_backendCapabilitiesInitialized = true;
+        }
+
+        m_eglCurrentThreads[threadKey] = true;
+        return true;
+    }
+
+    void BackendObject::ResetEGLRuntimeState() {
+        const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
+        m_eglWindowSurfaceInitialized = false;
+        m_backendCapabilitiesInitialized = false;
+        m_eglCurrentThreads.clear();
+    }
+
+    Bool BackendObject::SwapEGLBuffers(EGLDisplay dpy, EGLSurface draw) {
+        const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
+        if (!m_eglDisplayInitialized || m_eglDisplay != dpy) {
+            MGLOG_E("SwapEGLBuffers failed: EGL display mismatch or not initialized");
+            return false;
+        }
+        if (m_eglCurrentThreads.find(CurrentThreadKey()) == m_eglCurrentThreads.end()) {
+            MGLOG_E("SwapEGLBuffers failed: no current context attached");
+            return false;
+        }
+        if (!m_eglWindowSurfaceInitialized || draw == EGL_NO_SURFACE) {
+            MGLOG_E("SwapEGLBuffers failed: invalid draw surface");
+            return false;
+        }
+
+        const auto& backendFunctions = GetBackendFunctions();
+        if (!backendFunctions.Present) {
+            MGLOG_E("SwapEGLBuffers failed: backend Present function is null");
+            return false;
+        }
+
+        backendFunctions.Present();
+        return true;
+    }
+
     void BackendObject::SetWindowHandle(const WindowHandle& handle) {
+        const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
         m_windowHandle = handle;
     }
 } // namespace MobileGL::MG_Backend