Merge branch 'dev' into Feat/Backend-Direct-Vulkan

.clang-format

@@ -22,3 +22,6 @@ AlwaysBreakTemplateDeclarations: Yes
 NamespaceIndentation: All
 AllowShortFunctionsOnASingleLine: Inline
 SortIncludes: false
+FixNamespaceComments: true
+ShortNamespaceLines: 0
+CompactNamespaces: false

.clang-tidy

@@ -0,0 +1,144 @@
+#Generated from CLion Inspection settings
+---
+Checks: '-*,
+bugprone-argument-comment,
+bugprone-assert-side-effect,
+bugprone-bad-signal-to-kill-thread,
+bugprone-branch-clone,
+bugprone-copy-constructor-init,
+bugprone-dangling-handle,
+bugprone-dynamic-static-initializers,
+bugprone-fold-init-type,
+bugprone-forward-declaration-namespace,
+bugprone-forwarding-reference-overload,
+bugprone-inaccurate-erase,
+bugprone-incorrect-roundings,
+bugprone-integer-division,
+bugprone-lambda-function-name,
+bugprone-macro-parentheses,
+bugprone-macro-repeated-side-effects,
+bugprone-misplaced-operator-in-strlen-in-alloc,
+bugprone-misplaced-pointer-arithmetic-in-alloc,
+bugprone-misplaced-widening-cast,
+bugprone-move-forwarding-reference,
+bugprone-multiple-statement-macro,
+bugprone-no-escape,
+bugprone-parent-virtual-call,
+bugprone-posix-return,
+bugprone-reserved-identifier,
+bugprone-sizeof-container,
+bugprone-sizeof-expression,
+bugprone-spuriously-wake-up-functions,
+bugprone-string-constructor,
+bugprone-string-integer-assignment,
+bugprone-string-literal-with-embedded-nul,
+bugprone-suspicious-enum-usage,
+bugprone-suspicious-include,
+bugprone-suspicious-memset-usage,
+bugprone-suspicious-missing-comma,
+bugprone-suspicious-semicolon,
+bugprone-suspicious-string-compare,
+bugprone-suspicious-memory-comparison,
+bugprone-suspicious-realloc-usage,
+bugprone-swapped-arguments,
+bugprone-terminating-continue,
+bugprone-throw-keyword-missing,
+bugprone-too-small-loop-variable,
+bugprone-undefined-memory-manipulation,
+bugprone-undelegated-constructor,
+bugprone-unhandled-self-assignment,
+bugprone-unused-raii,
+bugprone-unused-return-value,
+bugprone-use-after-move,
+bugprone-virtual-near-miss,
+cert-dcl21-cpp,
+cert-dcl58-cpp,
+cert-err34-c,
+cert-err52-cpp,
+cert-err60-cpp,
+cert-flp30-c,
+cert-msc50-cpp,
+cert-msc51-cpp,
+cert-str34-c,
+cppcoreguidelines-interfaces-global-init,
+cppcoreguidelines-narrowing-conversions,
+cppcoreguidelines-pro-type-member-init,
+cppcoreguidelines-pro-type-static-cast-downcast,
+cppcoreguidelines-slicing,
+google-default-arguments,
+google-runtime-operator,
+hicpp-exception-baseclass,
+hicpp-multiway-paths-covered,
+misc-misplaced-const,
+misc-new-delete-overloads,
+misc-non-copyable-objects,
+misc-throw-by-value-catch-by-reference,
+misc-unconventional-assign-operator,
+misc-uniqueptr-reset-release,
+modernize-avoid-bind,
+modernize-concat-nested-namespaces,
+modernize-deprecated-headers,
+modernize-deprecated-ios-base-aliases,
+modernize-loop-convert,
+modernize-make-shared,
+modernize-make-unique,
+modernize-pass-by-value,
+modernize-raw-string-literal,
+modernize-redundant-void-arg,
+modernize-replace-auto-ptr,
+modernize-replace-disallow-copy-and-assign-macro,
+modernize-replace-random-shuffle,
+modernize-return-braced-init-list,
+modernize-shrink-to-fit,
+modernize-unary-static-assert,
+modernize-use-auto,
+modernize-use-bool-literals,
+modernize-use-emplace,
+modernize-use-equals-default,
+modernize-use-equals-delete,
+modernize-use-noexcept,
+modernize-use-nullptr,
+modernize-use-override,
+modernize-use-transparent-functors,
+modernize-use-uncaught-exceptions,
+mpi-buffer-deref,
+mpi-type-mismatch,
+openmp-use-default-none,
+performance-faster-string-find,
+performance-for-range-copy,
+performance-implicit-conversion-in-loop,
+performance-inefficient-algorithm,
+performance-inefficient-string-concatenation,
+performance-inefficient-vector-operation,
+performance-move-const-arg,
+performance-move-constructor-init,
+performance-no-automatic-move,
+performance-noexcept-move-constructor,
+performance-trivially-destructible,
+performance-type-promotion-in-math-fn,
+performance-unnecessary-copy-initialization,
+performance-unnecessary-value-param,
+portability-simd-intrinsics,
+readability-avoid-const-params-in-decls,
+readability-const-return-type,
+readability-container-size-empty,
+readability-convert-member-functions-to-static,
+readability-delete-null-pointer,
+readability-deleted-default,
+readability-inconsistent-declaration-parameter-name,
+readability-make-member-function-const,
+readability-misleading-indentation,
+readability-misplaced-array-index,
+readability-non-const-parameter,
+readability-redundant-control-flow,
+readability-redundant-declaration,
+readability-redundant-function-ptr-dereference,
+readability-redundant-smartptr-get,
+readability-redundant-string-cstr,
+readability-redundant-string-init,
+readability-simplify-subscript-expr,
+readability-static-accessed-through-instance,
+readability-static-definition-in-anonymous-namespace,
+readability-string-compare,
+readability-uniqueptr-delete-release,
+readability-use-anyofallof'

CMakeLists.txt

@@ -127,6 +127,7 @@ endif ()
 
 set(SOURCE_FILES
     MobileGL/Init.cpp
+    MobileGL/GlobalObjects.cpp
 
     MobileGL/MG_Util/Debug/Log.cpp
 
@@ -168,6 +169,7 @@ set(SOURCE_FILES
     MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/EliminateFloatEqualsZeroPass.cpp
 
     MobileGL/MG_Util/BackendLoaders/OpenGL/Loader.cpp
+    MobileGL/MG_Util/BackendLoaders/Vulkan/Loader.cpp
 
     MobileGL/MG_Util/Texture/PixelStoreProcessor.cpp
     MobileGL/MG_Util/Texture/TextureFormatProcessor.cpp
@@ -176,9 +178,7 @@ set(SOURCE_FILES
     MobileGL/MG_Impl/GLXImpl/LookUp/LookUp.cpp
 
     MobileGL/MG_Impl/EGLImpl/Exporting/Definitions.cpp
-    MobileGL/MG_Impl/EGLImpl/Temporary/TemporaryEGLImpl.cpp
+    MobileGL/MG_Impl/EGLImpl/EGLImpl.cpp
-    MobileGL/MG_Impl/EGLImpl/EGLWrapper/EGLWrapper.cpp
-    MobileGL/MG_Impl/EGLImpl/EGLForVulkan/EGLForVulkan.cpp
     
     # @INSERTION_POINT:SOURCE_FILE_GLIMPL@ #
     MobileGL/MG_Impl/GLImpl/Sampler/Validators.cpp
@@ -203,12 +203,15 @@ set(SOURCE_FILES
     MobileGL/MG_Impl/GetProcAddress.cpp
 
     MobileGL/MG_Backend/Init.cpp
+    MobileGL/MG_Backend/BackendObject.cpp
 
     MobileGL/MG_Backend/DirectGLES/DirectGLES.cpp
+    MobileGL/MG_Backend/DirectGLES/BackendObject_DirectGLES.cpp
     MobileGL/MG_Backend/DirectGLES/Utils.cpp
     MobileGL/MG_Backend/DirectGLES/Managers.cpp
 
     MobileGL/MG_Backend/DirectVulkan/DirectVulkan.cpp
+    MobileGL/MG_Backend/DirectVulkan/BackendObject_DirectVulkan.cpp
     MobileGL/MG_Backend/DirectVulkan/VmaImpl.cpp
     MobileGL/MG_Backend/DirectVulkan/Renderer/VulkanRenderer.cpp
     MobileGL/MG_Backend/DirectVulkan/Renderer/SwapchainObject.cpp

MobileGL/Config.h

@@ -8,25 +8,15 @@
 
 #pragma once
 #include <Includes.h>
-#include <MG_Backend/Backends.h>
+#include <MG_Backend/BackendObjects.h>
 
-namespace MobileGL {
+namespace MobileGL::MG_Config {
-    namespace MG_Config {
     inline const String ProjectName = "MobileGL";
     inline const String CoreName = "MobileGL Core";
     inline const String CoreVendor = "MobileGL-Dev (BZLZHH, Swung0x48, Tungsten)";
     inline const Version CoreVersion = {26, 2, 0, "-dev", VersionType::Development};
-        inline const Uint64 CacheVersion = 0;
     inline const VersionStringFormatAttrib DefaultVersionStringFormatAttrib = {2, 2, 0, true, true};
-        extern UniquePtr<RendererInfo> RendererInfoPtr;
+    inline const Uint64 CacheVersion = 0;
 
-        namespace Backend {
+    extern BackendType ActiveBackendType;
-#define MOBILEGL_BACKEND MOBILEGL_BACKEND_TYPE_DIRECT_VULKAN
+} // namespace MobileGL::MG_Config
-
-            namespace Diligent {
-                inline const MG_Backend::Diligent::SpecificBackendType SpecificBackend =
-                    MG_Backend::Diligent::SpecificBackendType::Vulkan;
-            }
-        } // namespace Backend
-    } // namespace MG_Config
-} // namespace MobileGL

MobileGL/Defines.h

@@ -33,12 +33,6 @@
 #define MOBILEGL_GL_API MOBILEGL_API
 #define MOBILEGL_EGL_API MOBILEGL_API
 
-#define MOBILEGL_BACKEND_TYPE_UNKNOWN 0
-#define MOBILEGL_BACKEND_TYPE_DILIGENT 1
-#define MOBILEGL_BACKEND_TYPE_MRHI 2
-#define MOBILEGL_BACKEND_TYPE_DIRECT_GLES 3
-#define MOBILEGL_BACKEND_TYPE_DIRECT_VULKAN 4
-
 // ====================== MobileGL configurations ======================= //
 #define MOBILEGL_LOG_ACTIVE_LEVEL MOBILEGL_LOG_LEVEL_DEBUG
 

MobileGL/GlobalObjects.cpp

@@ -0,0 +1,20 @@
+// MobileGL - MobileGL/GlobalObjects.cpp
+// Copyright (c) 2025-2026 MobileGL-Dev
+// Licensed under the GNU Lesser General Public License v3.0:
+//   https://www.gnu.org/licenses/gpl-3.0.txt
+//   https://www.gnu.org/licenses/lgpl-3.0.txt
+// SPDX-License-Identifier: LGPL-3.0-only
+// End of Source File Header
+
+#include "Config.h"
+
+namespace MobileGL {
+    namespace MG_Config {
+        BackendType ActiveBackendType = BackendType::DirectVulkan;
+    } // namespace MG_Config
+
+    namespace MG_Backend {
+        UniquePtr<BackendObject> pActiveBackendObject;
+        GlobalBackendFunctionsTable gBackendFunctionsTable;
+    } // namespace MG_Backend
+} // namespace MobileGL

MobileGL/Init.cpp

@@ -9,7 +9,7 @@
 #include "Init.h"
 #include "Config.h"
 #include <MG_Impl/Init.h>
-#include <MG_Backend/Backends.h>
+#include <MG_Backend/BackendObjects.h>
 #include <MG_State/GLState/Core.h>
 #include <MG_Impl/GLImpl/Texture/ProxyTexture.h>
 #include <MG_Impl/GLImpl/Framebuffer/GL_Framebuffer.h>
@@ -33,7 +33,6 @@ namespace MobileGL {
         MGLOG_I("MobileGL closing...");
         glslang::FinalizeProcess();
         delete MG_State::pGLContext;
-        MG_Config::RendererInfoPtr.reset();
         delete MG_Impl::GLImpl::TextureImpl::pProxyTextureManager;
         delete MG_Impl::GLImpl::FramebufferImpl::pDefaultFramebufferInfo;
         MG_Util::Debug::Close();

MobileGL/MG_Backend/BackendObject.cpp

@@ -1,4 +1,4 @@
-// MobileGL - MobileGL/MG_Impl/EGLImpl/EGLWrapper/EGLWrapper.h
+// MobileGL - MobileGL/MG_Backend/BackendObject.cpp
 // Copyright (c) 2025-2026 MobileGL-Dev
 // Licensed under the GNU Lesser General Public License v3.0:
 //   https://www.gnu.org/licenses/gpl-3.0.txt
@@ -6,5 +6,10 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 // End of Source File Header
 
-#pragma once
+#include "BackendObject.h"
-#include <Includes.h>
+
+namespace MobileGL::MG_Backend {
+    void BackendObject::SetWindowHandle(const WindowHandle& handle) {
+        m_windowHandle = handle;
+    }
+} // namespace MobileGL::MG_Backend

MobileGL/MG_Backend/BackendObject.h

@@ -0,0 +1,109 @@
+// MobileGL - MobileGL/MG_Backend/BackendObject.h
+// Copyright (c) 2025-2026 MobileGL-Dev
+// Licensed under the GNU Lesser General Public License v3.0:
+//   https://www.gnu.org/licenses/gpl-3.0.txt
+//   https://www.gnu.org/licenses/lgpl-3.0.txt
+// SPDX-License-Identifier: LGPL-3.0-only
+// End of Source File Header
+
+#pragma once
+#include <Includes.h>
+
+namespace MobileGL {
+    enum class BackendType {
+        DirectGLES,
+        DirectVulkan,
+        BackendTypeCount,
+        Unknown = -1
+    };
+
+    namespace MG_Backend {
+        struct GLFunctionsTable {
+            void (*DrawArrays)(GLenum mode, GLint first, GLsizei count);
+            void (*DrawElements)(GLenum mode, GLsizei count, GLenum type, const void* indices);
+            void (*DrawElementsBaseVertex)(GLenum mode, GLsizei count, GLenum type, const void* indices,
+                                           GLint basevertex);
+            void (*MultiDrawElements)(GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices,
+                                      GLsizei drawcount);
+            void (*MultiDrawElementsBaseVertex)(GLenum mode, const GLsizei* count, GLenum type,
+                                                const GLvoid* const* indices, GLsizei drawcount,
+                                                const GLint* basevertex);
+            void (*MultiDrawElementsIndirect)(GLenum mode, GLenum type, const void* indirect, GLsizei drawcount,
+                                              GLsizei stride);
+            void (*MultiDrawArraysIndirect)(GLenum mode, const void* indirect, GLsizei drawcount, GLsizei stride);
+            void (*DrawRangeElementsBaseVertex)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type,
+                                                const void* indices, GLint basevertex);
+            void (*DrawRangeElements)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type,
+                                      const void* indices);
+            void (*DrawElementsInstancedBaseVertexBaseInstance)(GLenum mode, GLsizei count, GLenum type,
+                                                                const void* indices, GLsizei instancecount,
+                                                                GLint basevertex, GLuint baseinstance);
+            void (*DrawElementsInstancedBaseVertex)(GLenum mode, GLsizei count, GLenum type, const void* indices,
+                                                    GLsizei instancecount, GLint basevertex);
+            void (*DrawElementsInstancedBaseInstance)(GLenum mode, GLsizei count, GLenum type, const void* indices,
+                                                      GLsizei instancecount, GLuint baseinstance);
+            void (*DrawElementsInstanced)(GLenum mode, GLsizei count, GLenum type, const void* indices,
+                                          GLsizei instancecount);
+            void (*DrawArraysInstancedBaseInstance)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount,
+                                                    GLuint baseinstance);
+            void (*DrawArraysInstanced)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);
+            void (*DrawElementsIndirect)(GLenum mode, GLenum type, const void* indirect);
+            void (*DrawArraysIndirect)(GLenum mode, const void* indirect);
+            void (*Clear)(GLbitfield mask);
+            void (*ClearBufferfi)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
+            void (*ClearBufferfv)(GLenum buffer, GLint drawbuffer, const GLfloat* value);
+            void (*ClearBufferuiv)(GLenum buffer, GLint drawbuffer, const GLuint* value);
+            void (*ClearBufferiv)(GLenum buffer, GLint drawbuffer, const GLint* value);
+            void (*BlitFramebuffer)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0,
+                                    GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+            void (*CopyTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width,
+                                   GLsizei height, GLint border);
+            void (*CopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y,
+                                      GLsizei width, GLsizei height);
+            void (*GenerateMipmap)(GLenum target);
+            void (*ReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type,
+                               void* pixels);
+            void (*GetTexImage)(GLenum target, GLint level, GLenum format, GLenum type, GLvoid* pixels);
+        };
+        struct GlobalBackendFunctionsTable {
+            GLFunctionsTable GL;
+            void (*Present)();
+        };
+
+        struct DynamicBackendParameters {
+            SizeT UniformBufferOffsetAlignment = 256;
+        };
+
+        enum class WindowBackend {
+            Android,
+            // TODO: X11, Wayland, Windows, macOS, etc.
+            WindowBackendCount,
+            Unknown = -1
+        };
+
+        struct WindowHandle {
+            WindowBackend Backend = WindowBackend::Unknown;
+            void* Handle = nullptr;
+        };
+
+        class BackendObject {
+        public:
+            virtual ~BackendObject() = default;
+
+            virtual void Initialize() = 0;
+            virtual void InitCapabilities() = 0;
+            virtual void InitWindowSurface() = 0;
+
+            void SetWindowHandle(const WindowHandle& handle);
+
+            virtual const RendererInfo& GetRendererInfo() const = 0;
+            virtual String GetBackendAPIVersionString() const = 0;
+            virtual const GlobalBackendFunctionsTable& GetBackendFunctions() const = 0;
+            virtual const DynamicBackendParameters& GetDynamicParameters() const = 0;
+            virtual BackendType GetBackendType() const = 0;
+
+        protected:
+            WindowHandle m_windowHandle;
+        };
+    } // namespace MG_Backend
+} // namespace MobileGL

MobileGL/MG_Backend/BackendObjects.h

@@ -0,0 +1,20 @@
+// MobileGL - MobileGL/MG_Backend/BackendObjects.h
+// Copyright (c) 2025-2026 MobileGL-Dev
+// Licensed under the GNU Lesser General Public License v3.0:
+//   https://www.gnu.org/licenses/gpl-3.0.txt
+//   https://www.gnu.org/licenses/lgpl-3.0.txt
+// SPDX-License-Identifier: LGPL-3.0-only
+// End of Source File Header
+
+#pragma once
+#include <Includes.h>
+#include "BackendObject.h"
+#include "DirectGLES/BackendObject_DirectGLES.h"
+#include "DirectVulkan/BackendObject_DirectVulkan.h"
+
+namespace MobileGL::MG_Backend {
+    extern UniquePtr<BackendObject> pActiveBackendObject;
+    extern GlobalBackendFunctionsTable gBackendFunctionsTable;
+
+    void Init();
+} // namespace MobileGL::MG_Backend

MobileGL/MG_Backend/Backends.h

@@ -1,109 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/Backends.h
-// Copyright (c) 2025-2026 MobileGL-Dev
-// Licensed under the GNU Lesser General Public License v3.0:
-//   https://www.gnu.org/licenses/gpl-3.0.txt
-//   https://www.gnu.org/licenses/lgpl-3.0.txt
-// SPDX-License-Identifier: LGPL-3.0-only
-// End of Source File Header
-
-#pragma once
-#include <Includes.h>
-#include <MG_Util/GLExtensions.h>
-
-namespace MobileGL {
-    namespace MG_Backend {
-        namespace Unknown {
-            inline RendererInfo RendererInfoUnknown = {
-                .RendererName = "<unknown renderer of MobileGL>", // Renderer Name
-                .BackendName = "<unknown backend>",               // Backend Name
-                .ExtraVendor = ", <unknown>",                     // Extra vendor
-                .RendererGLInfo =
-                    {
-                        // OpenGL Info
-                        .TargetGLVersion = {3, 3, 0},   //   Target OpenGL Version
-                        .TargetGLSLVersion = {4, 6, 0}, //   Target Shading Language Version
-                        .Extensions = {},               //   OpenGL Extensions
-                        .IsCompatibilityProfile = false //   Is Compatibility Profile
-                    },
-                .BackendCapability = {.AllowVSOnlyPrograms = false} // Backend Capability
-            };
-        }
-
-        namespace Diligent {
-            enum class SpecificBackendType {
-                Vulkan,
-                Metal
-            };
-
-            inline RendererInfo RendererInfoVulkan = {
-                .RendererName = "Unknown",                 // Renderer Name
-                .BackendName = "Diligent Engine (Vulkan)", // Backend Name
-                .ExtraVendor = Nullopt,                    // Extra vendor
-                .RendererGLInfo =
-                    {
-                        // OpenGL Info
-                        .TargetGLVersion = {3, 3, 0},                      //   Target OpenGL Version
-                        .TargetGLSLVersion = {4, 6, 0},                    //   Target Shading Language Version
-                        .Extensions = {V_OpenGL30, V_OpenGL31, V_OpenGL32, //   OpenGL Extensions
-                                       V_OpenGL33},
-                        .IsCompatibilityProfile = false //   Is Compatibility Profile
-                    },
-                .BackendCapability = {.AllowVSOnlyPrograms = false} // Backend Capability
-            };
-
-            inline RendererInfo RendererInfoMetal = {
-                .RendererName = "Unknown",                // Renderer Name
-                .BackendName = "Diligent Engine (Metal)", // Backend Name
-                .ExtraVendor = Nullopt,                   // Extra vendor
-                .RendererGLInfo =
-                    {
-                        // OpenGL Info
-                        .TargetGLVersion = {3, 3, 0},                      //   Target OpenGL Version
-                        .TargetGLSLVersion = {4, 6, 0},                    //   Target Shading Language Version
-                        .Extensions = {V_OpenGL30, V_OpenGL31, V_OpenGL32, //   OpenGL Extensions
-                                       V_OpenGL33},
-                        .IsCompatibilityProfile = false //   Is Compatibility Profile
-                    },
-                .BackendCapability = {.AllowVSOnlyPrograms = false} // Backend Capability
-            };
-        } // namespace Diligent
-
-        namespace DirectGLES {
-            inline RendererInfo RendererInfo = {
-                .RendererName = "Espryt",            // Renderer Name
-                .BackendName = "Direct (OpenGL ES)", // Backend Name
-                .ExtraVendor = Nullopt,              // Extra vendor
-                .RendererGLInfo =
-                    {
-                        // OpenGL Info
-                        .TargetGLVersion = {3, 3, 0},                      //   Target OpenGL Version
-                        .TargetGLSLVersion = {4, 6, 0},                    //   Target Shading Language Version
-                        .Extensions = {V_OpenGL30, V_OpenGL31, V_OpenGL32, //   OpenGL Extensions
-                                       V_OpenGL33, E_GL_ARB_draw_buffers_blend},
-                        .IsCompatibilityProfile = false //   Is Compatibility Profile
-                    },
-                .BackendCapability = {.AllowVSOnlyPrograms = false} // Backend Capability
-            };
-        } // namespace DirectGLES
-
-        namespace DirectVulkan {
-            inline RendererInfo RendererInfo = {
-                .RendererName = "Magma",          // Renderer Name
-                .BackendName = "Direct (Vulkan)", // Backend Name
-                .ExtraVendor = Nullopt,           // Extra vendor
-                .RendererGLInfo =
-                    {
-                        // OpenGL Info
-                        .TargetGLVersion = {3, 3, 0},                      //   Target OpenGL Version
-                        .TargetGLSLVersion = {4, 6, 0},                    //   Target Shading Language Version
-                        .Extensions = {V_OpenGL30, V_OpenGL31, V_OpenGL32, //   OpenGL Extensions
-                                       V_OpenGL33},
-                        .IsCompatibilityProfile = false //   Is Compatibility Profile
-                    },
-                .BackendCapability = {.AllowVSOnlyPrograms = false} // Backend Capability
-            };
-        } // namespace DirectVulkan
-
-        void Init();
-    } // namespace MG_Backend
-} // namespace MobileGL

MobileGL/MG_Backend/DirectGLES/BackendObject_DirectGLES.cpp

@@ -0,0 +1,143 @@
+// MobileGL - MobileGL/MG_Backend/DirectGLES/BackendObject_DirectGLES.cpp
+// Copyright (c) 2025-2026 MobileGL-Dev
+// Licensed under the GNU Lesser General Public License v3.0:
+//   https://www.gnu.org/licenses/gpl-3.0.txt
+//   https://www.gnu.org/licenses/lgpl-3.0.txt
+// SPDX-License-Identifier: LGPL-3.0-only
+// End of Source File Header
+
+#include "BackendObject_DirectGLES.h"
+#include "MG_Backend/BackendObject.h"
+#include <MG_Backend/DirectGLES/DirectGLES.h>
+#include <MG_Util/BackendLoaders/OpenGL/Loader.h>
+#include <format>
+
+namespace MobileGL::MG_Backend::DirectGLES {
+    BackendObject_DirectGLES::~BackendObject_DirectGLES() {
+        DestroyEGLContext();
+    }
+
+    void BackendObject_DirectGLES::InitWindowSurface() {
+        // Only use EGL for now
+        auto nativeWindow = reinterpret_cast<NativeWindowType>(m_windowHandle.Handle);
+        if (!DirectGLES::InitWindowSurface(nativeWindow)) {
+            MGLOG_E("Failed to initialize window surface for DirectGLES backend");
+        }
+    }
+
+    void BackendObject_DirectGLES::Initialize() {
+        if (!MG_Util::BackendLoader::AcquireEGLFunctions(m_EGLFunctions)) {
+            MGLOG_E("Failed to acquire EGL functions for DirectGLES backend");
+            return;
+        }
+        if (!MG_Util::BackendLoader::AcquireGLESFunctions(m_GLESFunctions, m_EGLFunctions.eglGetProcAddress)) {
+            MGLOG_E("Failed to acquire GLES functions for DirectGLES backend");
+            return;
+        }
+        m_initialized = true;
+
+        DirectGLES::SetEGLFuncsTable(m_EGLFunctions);
+        DirectGLES::SetGLESFuncsTable(m_GLESFunctions);
+    }
+
+    void BackendObject_DirectGLES::InitCapabilities() {
+        if (!m_initialized) {
+            MGLOG_E("DirectGLES backend not initialized");
+            return;
+        }
+
+        if (!MG_Util::BackendLoader::FillInGLESCapabilities(m_GLESCapabilities, m_GLESFunctions)) {
+            MGLOG_E("Failed to fill in GLES capabilities for DirectGLES backend");
+            return;
+        }
+        DirectGLES::SetGLESCapabilities(m_GLESCapabilities);
+        UpdateDynamicBackendParameters();
+    }
+
+    const RendererInfo& BackendObject_DirectGLES::GetRendererInfo() const {
+        static RendererInfo RendererInfo = {
+            .RendererName = "Espryt",            // Renderer Name
+            .BackendName = "Direct (OpenGL ES)", // Backend Name
+            .ExtraVendor = Nullopt,              // Extra vendor
+            .RendererGLInfo =
+                {
+                    .TargetGLVersion = {3, 3, 0},                      // Target OpenGL Version
+                    .TargetGLSLVersion = {4, 6, 0},                    // Target Shading Language Version
+                    .Extensions = {V_OpenGL30, V_OpenGL31, V_OpenGL32, // OpenGL Extensions
+                                   V_OpenGL33, E_GL_ARB_draw_buffers_blend},
+                    .IsCompatibilityProfile = false // Is Compatibility Profile
+                },
+            .StaticBackendCapability = {.AllowVSOnlyPrograms = false} // Backend Capability
+        };
+        return RendererInfo;
+    }
+
+    String BackendObject_DirectGLES::GetBackendAPIVersionString() const {
+        if (!m_initialized) {
+            return "<uninitialized DirectGLES backend>";
+        }
+        // Format:
+        // <OpenGL ES Renderer>, OpenGL ES <OpenGL ES Version>
+        String versionString = std::format("{}, OpenGL ES {}.{}", m_GLESCapabilities.GLESRendererString,
+                                           m_GLESCapabilities.GLESVersion.Major, m_GLESCapabilities.GLESVersion.Minor);
+        return versionString;
+    }
+
+    BackendType BackendObject_DirectGLES::GetBackendType() const {
+        return BackendType::DirectGLES;
+    }
+
+    const GlobalBackendFunctionsTable& BackendObject_DirectGLES::GetBackendFunctions() const {
+        static GlobalBackendFunctionsTable funcsTable;
+        static Bool funcsTableInitialized = false;
+        if (!funcsTableInitialized) {
+            funcsTable.Present = DirectGLES::Present;
+            funcsTable.GL.DrawArrays = DrawArrays;
+            funcsTable.GL.DrawElements = DrawElements;
+            funcsTable.GL.DrawElementsBaseVertex = DrawElementsBaseVertex;
+            funcsTable.GL.MultiDrawElements = MultiDrawElements;
+            funcsTable.GL.MultiDrawElementsBaseVertex = MultiDrawElementsBaseVertex;
+            funcsTable.GL.MultiDrawElementsIndirect = MultiDrawElementsIndirect;
+            funcsTable.GL.MultiDrawArraysIndirect = MultiDrawArraysIndirect;
+            funcsTable.GL.DrawRangeElementsBaseVertex = DrawRangeElementsBaseVertex;
+            funcsTable.GL.DrawRangeElements = DrawRangeElements;
+            funcsTable.GL.DrawElementsInstancedBaseVertexBaseInstance = DrawElementsInstancedBaseVertexBaseInstance;
+            funcsTable.GL.DrawElementsInstancedBaseVertex = DrawElementsInstancedBaseVertex;
+            funcsTable.GL.DrawElementsInstancedBaseInstance = DrawElementsInstancedBaseInstance;
+            funcsTable.GL.DrawElementsInstanced = DrawElementsInstanced;
+            funcsTable.GL.DrawArraysInstancedBaseInstance = DrawArraysInstancedBaseInstance;
+            funcsTable.GL.DrawArraysInstanced = DrawArraysInstanced;
+            funcsTable.GL.DrawElementsIndirect = DrawElementsIndirect;
+            funcsTable.GL.DrawArraysIndirect = DrawArraysIndirect;
+            funcsTable.GL.Clear = Clear;
+            funcsTable.GL.ClearBufferfi = ClearBufferfi;
+            funcsTable.GL.ClearBufferfv = ClearBufferfv;
+            funcsTable.GL.ClearBufferuiv = ClearBufferuiv;
+            funcsTable.GL.ClearBufferiv = ClearBufferiv;
+            funcsTable.GL.BlitFramebuffer = BlitFramebuffer;
+            funcsTable.GL.CopyTexImage2D = CopyTexImage2D;
+            funcsTable.GL.CopyTexSubImage2D = CopyTexSubImage2D;
+            funcsTable.GL.GenerateMipmap = GenerateMipmap;
+            funcsTable.GL.ReadPixels = ReadPixels;
+            funcsTable.GL.GetTexImage = GetTexImage;
+            funcsTableInitialized = true;
+        }
+        return funcsTable;
+    }
+
+    const DynamicBackendParameters& BackendObject_DirectGLES::GetDynamicParameters() const {
+        return m_dynamicParameters;
+    }
+
+    void BackendObject_DirectGLES::UpdateDynamicBackendParameters() {
+        m_dynamicParameters.UniformBufferOffsetAlignment = m_GLESCapabilities.UniformBufferOffsetAlignment;
+    }
+
+    const MG_External::GLESFunctionsTable& BackendObject_DirectGLES::GetGLESFunctions() const {
+        return m_GLESFunctions;
+    }
+
+    const MG_External::EGLFunctionsTable& BackendObject_DirectGLES::GetEGLFunctions() const {
+        return m_EGLFunctions;
+    }
+} // namespace MobileGL::MG_Backend::DirectGLES

MobileGL/MG_Backend/DirectGLES/BackendObject_DirectGLES.h

@@ -0,0 +1,41 @@
+// MobileGL - MobileGL/MG_Backend/DirectGLES/BackendObject_DirectGLES.h
+// Copyright (c) 2025-2026 MobileGL-Dev
+// Licensed under the GNU Lesser General Public License v3.0:
+//   https://www.gnu.org/licenses/gpl-3.0.txt
+//   https://www.gnu.org/licenses/lgpl-3.0.txt
+// SPDX-License-Identifier: LGPL-3.0-only
+// End of Source File Header
+
+#pragma once
+#include <Includes.h>
+#include "../BackendObject.h"
+#include <MG_Util/BackendLoaders/OpenGL/Loader.h>
+
+namespace MobileGL::MG_Backend::DirectGLES {
+    class BackendObject_DirectGLES : public BackendObject {
+    public:
+        ~BackendObject_DirectGLES() override;
+
+        void Initialize() override;
+        void InitCapabilities() override;
+        void InitWindowSurface() override;
+
+        const RendererInfo& GetRendererInfo() const override;
+        String GetBackendAPIVersionString() const override;
+        const GlobalBackendFunctionsTable& GetBackendFunctions() const override;
+        const DynamicBackendParameters& GetDynamicParameters() const override;
+        BackendType GetBackendType() const override;
+
+        const MG_External::GLESFunctionsTable& GetGLESFunctions() const;
+        const MG_External::EGLFunctionsTable& GetEGLFunctions() const;
+
+    private:
+        void UpdateDynamicBackendParameters();
+
+        Bool m_initialized = false;
+        MG_External::EGLFunctionsTable m_EGLFunctions;
+        MG_External::GLESFunctionsTable m_GLESFunctions;
+        MG_External::GLESCapabilities m_GLESCapabilities;
+        DynamicBackendParameters m_dynamicParameters;
+    };
+} // namespace MobileGL::MG_Backend::DirectGLES

MobileGL/MG_Backend/DirectGLES/DirectGLES.cpp

@@ -7,12 +7,7 @@
 // End of Source File Header
 
 #include "DirectGLES.h"
-#include "GLES3/gl32.h"
+#include "EGL/egl.h"
-#include "MG_State/GLState/ErrorState/Error.h"
-#include "MG_State/GLState/RenderState/RenderState.h"
-#include "MG_State/GLState/SamplerState/SamplerObject.h"
-#include "MG_Util/Debug/Log.h"
-#include "MG_Util/Types.h"
 #include "Utils.h"
 #include "Managers.h"
 #include <MG_Util/Converters/GLToMG/TextureEnumConverter.h>
@@ -25,8 +20,13 @@
 #include <MG_Util/Converters/MGToGL/TextureEnumConverter.h>
 #include <MG_Util/Converters/MGToStr/TextureEnumConverter.h>
 #include <MG_Util/Converters/MGToGL/RenderStateEnumConverter.h>
+#include <MG_Util/Texture/PixelStoreProcessor.h>
 
 namespace MobileGL::MG_Backend::DirectGLES {
+    MG_External::EGLFunctionsTable g_EGLFuncs;
+    MG_External::GLESFunctionsTable g_GLESFuncs;
+    MG_External::GLESCapabilities g_GLESCapabilities;
+
     enum class DrawSyncBit : Uint32 {
         None = 0,
         IndexBuffer = 1 << 0,
@@ -46,18 +46,18 @@ namespace MobileGL::MG_Backend::DirectGLES {
     namespace DebugImpl {
 #if MOBILEGL_LOG_ACTIVE_LEVEL <= MOBILEGL_LOG_LEVEL_DEBUG
         void ErrorLopper::Loop(std::function<void(GLenum)> func) {
-            GLenum err = MG_External::GLES::glGetError();
+            GLenum err = g_GLESFuncs.glGetError();
             while (err != GL_NO_ERROR) {
                 func(err);
-                err = MG_External::GLES::glGetError();
+                err = g_GLESFuncs.glGetError();
             }
         }
 
         void ErrorLopper::Clear() {
-            GLenum err = MG_External::GLES::glGetError();
+            GLenum err = g_GLESFuncs.glGetError();
             while (err != GL_NO_ERROR) {
                 MGLOG_D("Stray GL Error cleared: %s", MG_Util::ConvertGLEnumToString(err).c_str());
-                err = MG_External::GLES::glGetError();
+                err = g_GLESFuncs.glGetError();
             }
         }
 
@@ -76,11 +76,11 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
 #if MOBILEGL_LOG_ACTIVE_LEVEL <= MOBILEGL_LOG_LEVEL_DEBUG
         OpenGLScopeMarker::OpenGLScopeMarker(String scopeName) {
-            MG_External::GLES::glPushDebugGroup(GL_DEBUG_SOURCE_APPLICATION, 0, -1, scopeName.c_str());
+            g_GLESFuncs.glPushDebugGroup(GL_DEBUG_SOURCE_APPLICATION, 0, -1, scopeName.c_str());
         }
 
         OpenGLScopeMarker::~OpenGLScopeMarker() {
-            MG_External::GLES::glPopDebugGroup();
+            g_GLESFuncs.glPopDebugGroup();
         }
 #else
         OpenGLScopeMarker::OpenGLScopeMarker(String scopeName) {}
@@ -296,16 +296,16 @@ namespace MobileGL::MG_Backend::DirectGLES {
             const auto& parameters = MG_State::pGLContext->GetRenderStateParameters();
 
             if (parameters.Viewport != g_syncedRenderStateParameters.Viewport) {
-                MG_External::GLES::glViewport(parameters.Viewport.x(), parameters.Viewport.y(), parameters.Viewport.z(),
+                g_GLESFuncs.glViewport(parameters.Viewport.x(), parameters.Viewport.y(), parameters.Viewport.z(),
                                        parameters.Viewport.w());
             }
 
 #define SYNC_CAPABILITY(cap_mg, cap_gl)                                                                                \
     if (parameters.cap_mg##Enabled != g_syncedRenderStateParameters.cap_mg##Enabled) {                                 \
         if (parameters.cap_mg##Enabled) {                                                                              \
-            MG_External::GLES::glEnable(cap_gl);                                                                       \
+            g_GLESFuncs.glEnable(cap_gl);                                                                              \
         } else {                                                                                                       \
-            MG_External::GLES::glDisable(cap_gl);                                                                      \
+            g_GLESFuncs.glDisable(cap_gl);                                                                             \
         }                                                                                                              \
     }
             SYNC_CAPABILITY(DepthTest, GL_DEPTH_TEST);
@@ -339,19 +339,19 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
                 if (anyCapDirty) {
                     if (allEnabled) {
-                        MG_External::GLES::glEnable(GL_BLEND);
+                        g_GLESFuncs.glEnable(GL_BLEND);
                         for (auto& s : syncedStates)
                             s.Enabled = true;
                     } else if (allDisabled) {
-                        MG_External::GLES::glDisable(GL_BLEND);
+                        g_GLESFuncs.glDisable(GL_BLEND);
                         for (auto& s : syncedStates)
                             s.Enabled = false;
                     } else {
                         for (Uint i = 0; i < FBO::MAX_DRAW_BUFFERS; ++i) {
                             if (targetStates[i].Enabled != syncedStates[i].Enabled) {
                                 syncedStates[i].Enabled = targetStates[i].Enabled;
-                                syncedStates[i].Enabled ? MG_External::GLES::glEnablei(GL_BLEND, i)
+                                syncedStates[i].Enabled ? g_GLESFuncs.glEnablei(GL_BLEND, i)
-                                                        : MG_External::GLES::glDisablei(GL_BLEND, i);
+                                                        : g_GLESFuncs.glDisablei(GL_BLEND, i);
                             }
                         }
                     }
@@ -381,8 +381,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
                 if (anyFuncDirty) {
                     if (allFuncsSame) {
-                        MG_External::GLES::glBlendFuncSeparate(
+                        g_GLESFuncs.glBlendFuncSeparate(MG_Util::ConvertBlendFactorToGLEnum(first.SrcFactorRGB),
-                            MG_Util::ConvertBlendFactorToGLEnum(first.SrcFactorRGB),
                                                         MG_Util::ConvertBlendFactorToGLEnum(first.DstFactorRGB),
                                                         MG_Util::ConvertBlendFactorToGLEnum(first.SrcFactorAlpha),
                                                         MG_Util::ConvertBlendFactorToGLEnum(first.DstFactorAlpha));
@@ -405,7 +404,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
                                 syn.SrcFactorAlpha = cur.SrcFactorAlpha;
                                 syn.DstFactorAlpha = cur.DstFactorAlpha;
 
-                                MG_External::GLES::glBlendFuncSeparatei(
+                                g_GLESFuncs.glBlendFuncSeparatei(
                                     i, MG_Util::ConvertBlendFactorToGLEnum(cur.SrcFactorRGB),
                                     MG_Util::ConvertBlendFactorToGLEnum(cur.DstFactorRGB),
                                     MG_Util::ConvertBlendFactorToGLEnum(cur.SrcFactorAlpha),
@@ -418,17 +417,17 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
             { // Depth state
                 if (parameters.DepthFunc != g_syncedRenderStateParameters.DepthFunc) {
-                    MG_External::GLES::glDepthFunc(MG_Util::ConvertDepthTestFuncToGLEnum(parameters.DepthFunc));
+                    g_GLESFuncs.glDepthFunc(MG_Util::ConvertDepthTestFuncToGLEnum(parameters.DepthFunc));
                 }
                 if (parameters.DepthMask != g_syncedRenderStateParameters.DepthMask) {
-                    MG_External::GLES::glDepthMask(parameters.DepthMask ? GL_TRUE : GL_FALSE);
+                    g_GLESFuncs.glDepthMask(parameters.DepthMask ? GL_TRUE : GL_FALSE);
                 }
             }
 
             { // Color mask
                 if (parameters.ColorMask != g_syncedRenderStateParameters.ColorMask) {
                     const BoolVec4& colorMask = parameters.ColorMask;
-                    MG_External::GLES::glColorMask(ToGLBoolean(colorMask.x()), ToGLBoolean(colorMask.y()),
+                    g_GLESFuncs.glColorMask(ToGLBoolean(colorMask.x()), ToGLBoolean(colorMask.y()),
                                             ToGLBoolean(colorMask.z()), ToGLBoolean(colorMask.w()));
                 }
             }
@@ -436,24 +435,24 @@ namespace MobileGL::MG_Backend::DirectGLES {
             { // Clear values
                 if (parameters.ClearColor != g_syncedRenderStateParameters.ClearColor) {
                     const FloatVec4& clearCol = parameters.ClearColor;
-                    MG_External::GLES::glClearColor(clearCol.x(), clearCol.y(), clearCol.z(), clearCol.w());
+                    g_GLESFuncs.glClearColor(clearCol.x(), clearCol.y(), clearCol.z(), clearCol.w());
                 }
                 if (parameters.ClearDepth != g_syncedRenderStateParameters.ClearDepth) {
-                    MG_External::GLES::glClearDepthf(parameters.ClearDepth);
+                    g_GLESFuncs.glClearDepthf(parameters.ClearDepth);
                 }
             }
 
             { // Cull face mode
                 if (parameters.CullFaceModeSetting != g_syncedRenderStateParameters.CullFaceModeSetting) {
                     const CullFaceMode& cfm = parameters.CullFaceModeSetting;
-                    MG_External::GLES::glCullFace(MG_Util::ConvertCullFaceModeToGLEnum(cfm));
+                    g_GLESFuncs.glCullFace(MG_Util::ConvertCullFaceModeToGLEnum(cfm));
                 }
             }
 
             { // Scissor box
                 if (parameters.ScissorBox != g_syncedRenderStateParameters.ScissorBox) {
                     const IntVec4& scissorBox = parameters.ScissorBox;
-                    MG_External::GLES::glScissor(scissorBox.x(), scissorBox.y(), scissorBox.z(), scissorBox.w());
+                    g_GLESFuncs.glScissor(scissorBox.x(), scissorBox.y(), scissorBox.z(), scissorBox.w());
                 }
             }
 
@@ -469,7 +468,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
 #endif
             auto currentProgram = MG_State::pGLContext->GetCurrentProgram();
             if (!currentProgram || !currentProgram->GetLinkStatus()) {
-                MG_External::GLES::glUseProgram(0);
+                g_GLESFuncs.glUseProgram(0);
                 return;
             }
             const auto& backendProgramIt = g_backendProgramObjects.find(currentProgram);
@@ -505,8 +504,8 @@ namespace MobileGL::MG_Backend::DirectGLES {
             }
         } else {
             MGLOG_D("Binding default framebuffer as %s FBO", (target == FramebufferTarget::Read ? "READ" : "DRAW"));
-            MG_External::GLES::glBindFramebuffer(
+            g_GLESFuncs.glBindFramebuffer(target == FramebufferTarget::Draw ? GL_DRAW_FRAMEBUFFER : GL_READ_FRAMEBUFFER,
-                target == FramebufferTarget::Draw ? GL_DRAW_FRAMEBUFFER : GL_READ_FRAMEBUFFER, 0);
+                                          0);
         }
     }
 
@@ -534,7 +533,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
                     backendVAOIt->second->Bind();
                 }
             } else {
-                MG_External::GLES::glBindVertexArray(0);
+                g_GLESFuncs.glBindVertexArray(0);
             }
         }
 
@@ -591,18 +590,17 @@ namespace MobileGL::MG_Backend::DirectGLES {
 #ifdef TRACY_ENABLE
                     ZoneScopedNC("UpdateGlobalUBO", TRACY_ZONECOLOR_BACKEND);
 #endif
-                    MG_External::GLES::glBindBuffer(GL_UNIFORM_BUFFER,
+                    g_GLESFuncs.glBindBuffer(GL_UNIFORM_BUFFER, backendProgramIt->second->GetBackendGlobalUBOId());
-                                                    backendProgramIt->second->GetBackendGlobalUBOId());
+                    g_GLESFuncs.glBufferSubData(GL_UNIFORM_BUFFER, 0, currentProgram->GetUBOSize(),
-                    MG_External::GLES::glBufferSubData(GL_UNIFORM_BUFFER, 0, currentProgram->GetUBOSize(),
                                                 currentProgram->MapUBO());
-                    MG_External::GLES::glBindBuffer(GL_UNIFORM_BUFFER, 0);
+                    g_GLESFuncs.glBindBuffer(GL_UNIFORM_BUFFER, 0);
 
-                    Uint blockIndex = MG_External::GLES::glGetUniformBlockIndex(
+                    Uint blockIndex = g_GLESFuncs.glGetUniformBlockIndex(backendProgramId,
-                        backendProgramId, MG_Util::ShaderTranspiler::GLOBAL_UBO_NAME);
+                                                                         MG_Util::ShaderTranspiler::GLOBAL_UBO_NAME);
 
-                    MG_External::GLES::glUniformBlockBinding(backendProgramId, blockIndex, 0);
+                    g_GLESFuncs.glUniformBlockBinding(backendProgramId, blockIndex, 0);
 
-                    MG_External::GLES::glBindBufferBase(GL_UNIFORM_BUFFER, 0,
+                    g_GLESFuncs.glBindBufferBase(GL_UNIFORM_BUFFER, 0,
                                                  backendProgramIt->second->GetBackendGlobalUBOId());
                 }
 
@@ -620,9 +618,8 @@ namespace MobileGL::MG_Backend::DirectGLES {
                         // Connect program ubo index to backend binding point
                         auto binding = currentProgram->GetUniformBlockBinding(i);
                         auto& name = currentProgram->GetUniformBlockName(i);
-                        GLuint backendBlkIdx =
+                        GLuint backendBlkIdx = g_GLESFuncs.glGetUniformBlockIndex(backendProgramId, name.c_str());
-                            MG_External::GLES::glGetUniformBlockIndex(backendProgramId, name.c_str());
+                        g_GLESFuncs.glUniformBlockBinding(backendProgramId, backendBlkIdx, lastUBOBinding);
-                        MG_External::GLES::glUniformBlockBinding(backendProgramId, backendBlkIdx, lastUBOBinding);
 
                         // Connect buffer to backend binding point
                         auto& point = MG_State::pGLContext->GetBufferBindingPoint(BufferTarget::Uniform, binding);
@@ -635,10 +632,10 @@ namespace MobileGL::MG_Backend::DirectGLES {
                                 const auto& backendBufferObject = backendBufferIt->second;
                                 backendBufferObject->Bind(GL_UNIFORM_BUFFER);
                                 if (range.end == 0) {
-                                    MG_External::GLES::glBindBufferBase(GL_UNIFORM_BUFFER, lastUBOBinding,
+                                    g_GLESFuncs.glBindBufferBase(GL_UNIFORM_BUFFER, lastUBOBinding,
                                                                  backendBufferObject->GetBackendBufferId());
                                 } else {
-                                    MG_External::GLES::glBindBufferRange(GL_UNIFORM_BUFFER, lastUBOBinding,
+                                    g_GLESFuncs.glBindBufferRange(GL_UNIFORM_BUFFER, lastUBOBinding,
                                                                   backendBufferObject->GetBackendBufferId(),
                                                                   range.start, range.end - range.start);
                                 }
@@ -659,9 +656,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
                         auto unit = currentProgram->GetUniformSamplerOrImageUnitIndex(loc);
                         if (unit == -1) continue;
                         auto& name = currentProgram->GetUniformName(loc);
-                        auto locAtBackend = MG_External::GLES::glGetUniformLocation(
+                        auto locAtBackend = g_GLESFuncs.glGetUniformLocation(
                             backendProgramIt->second->GetBackendProgramId(), name.c_str());
-                        MG_External::GLES::glUniform1i(locAtBackend, unit);
+                        g_GLESFuncs.glUniform1i(locAtBackend, unit);
 
                         auto samplerObject = MG_State::pGLContext->GetTextureUnitObject(unit).GetSamplerObject();
 
@@ -681,7 +678,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
                     }
                 }
             } else {
-                MG_External::GLES::glUseProgram(0);
+                g_GLESFuncs.glUseProgram(0);
                 MGLOG_E("No backend program found (maybe not synced) for current program, cannot use program.");
             }
         }
@@ -697,7 +694,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
         BindCurrentFBO(FramebufferTarget::Draw);
 
-        MG_External::GLES::glClear(mask);
+        g_GLESFuncs.glClear(mask);
     }
 
     void DrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices) {
@@ -706,7 +703,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
 #endif
         DrawSyncBit syncBit = DrawSyncBit::IndexBuffer;
         PrepareForDraw(syncBit);
-        MG_External::GLES::glDrawElements(mode, count, type, indices);
+        g_GLESFuncs.glDrawElements(mode, count, type, indices);
     }
 
     void DrawArrays(GLenum mode, GLint first, GLsizei count) {
@@ -715,7 +712,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
 #endif
         DrawSyncBit syncBit = DrawSyncBit::None;
         PrepareForDraw(syncBit);
-        MG_External::GLES::glDrawArrays(mode, first, count);
+        g_GLESFuncs.glDrawArrays(mode, first, count);
     }
 
     void DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLint basevertex) {
@@ -724,7 +721,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
 #endif
         DrawSyncBit syncBit = DrawSyncBit::IndexBuffer;
         PrepareForDraw(syncBit);
-        MG_External::GLES::glDrawElementsBaseVertex(mode, count, type, indices, basevertex);
+        g_GLESFuncs.glDrawElementsBaseVertex(mode, count, type, indices, basevertex);
     }
 
     void MultiDrawElements(GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices,
@@ -736,7 +733,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
         PrepareForDraw(syncBit);
 
         for (GLsizei i = 0; i < drawcount; ++i) {
-            MG_External::GLES::glDrawElements(mode, count[i], type, indices[i]);
+            g_GLESFuncs.glDrawElements(mode, count[i], type, indices[i]);
         }
     }
 
@@ -749,7 +746,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
         PrepareForDraw(syncBit);
 
         for (GLsizei i = 0; i < drawcount; ++i) {
-            MG_External::GLES::glDrawElementsBaseVertex(mode, count[i], type, indices[i], basevertex[i]);
+            g_GLESFuncs.glDrawElementsBaseVertex(mode, count[i], type, indices[i], basevertex[i]);
         }
     }
 
@@ -763,7 +760,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
         for (GLsizei i = 0; i < drawcount; ++i) {
             const GLvoid* cmd = reinterpret_cast<const GLvoid*>(reinterpret_cast<const uint8_t*>(indirect) +
                                                                 i * (stride ? stride : sizeof(GLsizei) * 4));
-            MG_External::GLES::glDrawElementsIndirect(mode, type, cmd);
+            g_GLESFuncs.glDrawElementsIndirect(mode, type, cmd);
         }
     }
 
@@ -777,7 +774,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
         for (GLsizei i = 0; i < drawcount; ++i) {
             const GLvoid* cmd = reinterpret_cast<const GLvoid*>(reinterpret_cast<const uint8_t*>(indirect) +
                                                                 i * (stride ? stride : sizeof(GLsizei) * 4));
-            MG_External::GLES::glDrawArraysIndirect(mode, cmd);
+            g_GLESFuncs.glDrawArraysIndirect(mode, cmd);
         }
     }
 
@@ -785,13 +782,13 @@ namespace MobileGL::MG_Backend::DirectGLES {
                                      const void* indices, GLint basevertex) {
         DrawSyncBit syncBit = DrawSyncBit::IndexBuffer;
         PrepareForDraw(syncBit);
-        MG_External::GLES::glDrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
+        g_GLESFuncs.glDrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
     }
 
     void DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void* indices) {
         DrawSyncBit syncBit = DrawSyncBit::IndexBuffer;
         PrepareForDraw(syncBit);
-        MG_External::GLES::glDrawRangeElements(mode, start, end, count, type, indices);
+        g_GLESFuncs.glDrawRangeElements(mode, start, end, count, type, indices);
     }
 
     void DrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void* indices,
@@ -804,7 +801,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
                                          GLsizei instancecount, GLint basevertex) {
         DrawSyncBit syncBit = DrawSyncBit::IndexBuffer | DrawSyncBit::Instancing;
         PrepareForDraw(syncBit);
-        MG_External::GLES::glDrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
+        g_GLESFuncs.glDrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
     }
 
     void DrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const void* indices,
@@ -816,13 +813,13 @@ namespace MobileGL::MG_Backend::DirectGLES {
     void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei instancecount) {
         DrawSyncBit syncBit = DrawSyncBit::IndexBuffer | DrawSyncBit::Instancing;
         PrepareForDraw(syncBit);
-        MG_External::GLES::glDrawElementsInstanced(mode, count, type, indices, instancecount);
+        g_GLESFuncs.glDrawElementsInstanced(mode, count, type, indices, instancecount);
     }
 
     void DrawElementsIndirect(GLenum mode, GLenum type, const void* indirect) {
         DrawSyncBit syncBit = DrawSyncBit::IndexBuffer | DrawSyncBit::IndirectBuffer;
         PrepareForDraw(syncBit);
-        MG_External::GLES::glDrawElementsIndirect(mode, type, indirect);
+        g_GLESFuncs.glDrawElementsIndirect(mode, type, indirect);
     }
 
     void DrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount,
@@ -834,13 +831,13 @@ namespace MobileGL::MG_Backend::DirectGLES {
     void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount) {
         DrawSyncBit syncBit = DrawSyncBit::Instancing;
         PrepareForDraw(syncBit);
-        MG_External::GLES::glDrawArraysInstanced(mode, first, count, instancecount);
+        g_GLESFuncs.glDrawArraysInstanced(mode, first, count, instancecount);
     }
 
     void DrawArraysIndirect(GLenum mode, const void* indirect) {
         DrawSyncBit syncBit = DrawSyncBit::IndirectBuffer;
         PrepareForDraw(syncBit);
-        MG_External::GLES::glDrawArraysIndirect(mode, indirect);
+        g_GLESFuncs.glDrawArraysIndirect(mode, indirect);
     }
 
     void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1,
@@ -870,7 +867,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
         });
         MGLOG_D("ES %s(%d, %d, %d, %d, %d, %d, %d, %d, 0x%x, %s)", __func__, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0,
                 dstX1, dstY1, mask, MG_Util::ConvertGLEnumToString(filter).c_str());
-        MG_External::GLES::glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+        g_GLESFuncs.glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
         errorLopper.Loop([file = __FILE__, line = __LINE__](auto err) {
             MGLOG_D("ES error (%s:%d): %s", file, line, MG_Util::ConvertGLEnumToString(err).c_str());
         });
@@ -919,23 +916,23 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 __func__, s_prevDrawFBO, s_prevReadFBO);
         static GLuint tempFBO = 0;
         if (!tempFBO) {
-            MG_External::GLES::glGenFramebuffers(1, &tempFBO);
+            g_GLESFuncs.glGenFramebuffers(1, &tempFBO);
         }
         if (isRead) {
-            MG_External::GLES::glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, (GLint*)&s_prevReadFBO);
+            g_GLESFuncs.glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, (GLint*)&s_prevReadFBO);
-            MG_External::GLES::glBindFramebuffer(GL_READ_FRAMEBUFFER, tempFBO);
+            g_GLESFuncs.glBindFramebuffer(GL_READ_FRAMEBUFFER, tempFBO);
         } else {
-            MG_External::GLES::glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, (GLint*)&s_prevDrawFBO);
+            g_GLESFuncs.glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, (GLint*)&s_prevDrawFBO);
-            MG_External::GLES::glBindFramebuffer(GL_DRAW_FRAMEBUFFER, tempFBO);
+            g_GLESFuncs.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, tempFBO);
         }
     }
     void RestoreFBOFromTemp(Bool isRead) {
         if (isRead) {
             MGLOG_D("%s: Restoring previous read FBO=%u", __func__, s_prevReadFBO);
-            MG_External::GLES::glBindFramebuffer(GL_READ_FRAMEBUFFER, s_prevReadFBO);
+            g_GLESFuncs.glBindFramebuffer(GL_READ_FRAMEBUFFER, s_prevReadFBO);
         } else {
             MGLOG_D("%s: Restoring previous draw FBO=%u", __func__, s_prevDrawFBO);
-            MG_External::GLES::glBindFramebuffer(GL_DRAW_FRAMEBUFFER, s_prevDrawFBO);
+            g_GLESFuncs.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, s_prevDrawFBO);
         }
     }
 
@@ -1000,13 +997,13 @@ namespace MobileGL::MG_Backend::DirectGLES {
             MG_Util::IsStencilFormatInternalFormat(MG_Util::ConvertGLEnumToTextureInternalFormat(internalformat));
 
         if (!isDepthFormat) {
-            MG_External::GLES::glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+            g_GLESFuncs.glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
             errorLopper.Loop([file = __FILE__, line = __LINE__](auto err) {
                 MGLOG_D("ES error (%s:%d): %s", file, line, MG_Util::ConvertGLEnumToString(err).c_str());
             });
         } else {
             MGLOG_D("%s: Backend depth", __func__);
-            MG_External::GLES::glTexImage2D(target, level, (GLint)internalformat, width, height, border, format, type,
+            g_GLESFuncs.glTexImage2D(target, level, (GLint)internalformat, width, height, border, format, type,
                                      nullptr);
             errorLopper.Loop([file = __FILE__, line = __LINE__](auto err) {
                 MGLOG_D("ES error (%s:%d): %s", file, line, MG_Util::ConvertGLEnumToString(err).c_str());
@@ -1019,14 +1016,14 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
             GLenum attachment = isStencilFormat ? GL_DEPTH_STENCIL_ATTACHMENT : GL_DEPTH_ATTACHMENT;
             TempFBOBinder tempFBOBinder(false);
-            MG_External::GLES::glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, attachment, target, currentTex, level);
+            g_GLESFuncs.glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, attachment, target, currentTex, level);
 
-            if (MG_External::GLES::glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
+            if (g_GLESFuncs.glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
                 MGLOG_E("ES glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE");
                 return;
             }
 
-            MG_External::GLES::glBlitFramebuffer(x, y, x + width, y + height, 0, 0, width, height,
+            g_GLESFuncs.glBlitFramebuffer(x, y, x + width, y + height, 0, 0, width, height,
                                           GL_DEPTH_BUFFER_BIT | (isStencilFormat ? GL_STENCIL_BUFFER_BIT : 0),
                                           GL_NEAREST);
             errorLopper.Loop([file = __FILE__, line = __LINE__](auto err) {
@@ -1076,7 +1073,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
             MGLOG_D("ES error (%s:%d): %s", file, line, MG_Util::ConvertGLEnumToString(err).c_str());
         });
         GLenum internalFormat;
-        MG_External::GLES::glGetTexLevelParameteriv(target, level, GL_TEXTURE_INTERNAL_FORMAT, (GLint*)&internalFormat);
+        g_GLESFuncs.glGetTexLevelParameteriv(target, level, GL_TEXTURE_INTERNAL_FORMAT, (GLint*)&internalFormat);
         errorLopper.Loop([file = __FILE__, line = __LINE__](auto err) {
             MGLOG_D("ES error (%s:%d): %s", file, line, MG_Util::ConvertGLEnumToString(err).c_str());
         });
@@ -1086,7 +1083,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
         Bool isStencilFormat = MG_Util::IsStencilFormatInternalFormat(mgInternalFormat);
 
         if (!isDepthFormat) {
-            MG_External::GLES::glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+            g_GLESFuncs.glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
             errorLopper.Loop([file = __FILE__, line = __LINE__](auto err) {
                 MGLOG_D("ES error (%s:%d): %s", file, line, MG_Util::ConvertGLEnumToString(err).c_str());
             });
@@ -1098,16 +1095,16 @@ namespace MobileGL::MG_Backend::DirectGLES {
             });
             GLenum attachment = isStencilFormat ? GL_DEPTH_STENCIL_ATTACHMENT : GL_DEPTH_ATTACHMENT;
             TempFBOBinder tempFBOBinder(false);
-            MG_External::GLES::glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, attachment, target, currentTex, level);
+            g_GLESFuncs.glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, attachment, target, currentTex, level);
             errorLopper.Loop([file = __FILE__, line = __LINE__](auto err) {
                 MGLOG_D("ES error (%s:%d): %s", file, line, MG_Util::ConvertGLEnumToString(err).c_str());
             });
-            if (MG_External::GLES::glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
+            if (g_GLESFuncs.glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
                 MGLOG_E("ES glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE");
                 return;
             }
 
-            MG_External::GLES::glBlitFramebuffer(
+            g_GLESFuncs.glBlitFramebuffer(
                 x, y, x + width, y + height, xoffset, yoffset, xoffset + width, yoffset + height,
                 GL_DEPTH_BUFFER_BIT | (isStencilFormat ? GL_STENCIL_BUFFER_BIT : 0), GL_NEAREST);
             errorLopper.Loop([file = __FILE__, line = __LINE__](auto err) {
@@ -1127,11 +1124,11 @@ namespace MobileGL::MG_Backend::DirectGLES {
         auto backendTexture = TextureImpl::SyncTextureObjectToBackend(texture);
 
         backendTexture->Bind(target, unitIndex);
-        MG_External::GLES::glGenerateMipmap(target);
+        g_GLESFuncs.glGenerateMipmap(target);
     }
 
     const GLubyte* GetString(GLenum name) {
-        return MG_External::GLES::glGetString(name);
+        return g_GLESFuncs.glGetString(name);
     }
 
     void ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) {
@@ -1141,7 +1138,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
         BindCurrentFBO(FramebufferTarget::Draw);
 
-        MG_External::GLES::glClearBufferfi(buffer, drawbuffer, depth, stencil);
+        g_GLESFuncs.glClearBufferfi(buffer, drawbuffer, depth, stencil);
     }
 
     void ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value) {
@@ -1151,7 +1148,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
         BindCurrentFBO(FramebufferTarget::Draw);
 
-        MG_External::GLES::glClearBufferfv(buffer, drawbuffer, value);
+        g_GLESFuncs.glClearBufferfv(buffer, drawbuffer, value);
     }
 
     void ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value) {
@@ -1159,7 +1156,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
         FramebufferImpl::SyncCurrentFBO();
         RenderStateImpl::SyncRenderState();
 
-        MG_External::GLES::glClearBufferiv(buffer, drawbuffer, value);
+        g_GLESFuncs.glClearBufferiv(buffer, drawbuffer, value);
     }
 
     void ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value) {
@@ -1169,7 +1166,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
         BindCurrentFBO(FramebufferTarget::Draw);
 
-        MG_External::GLES::glClearBufferuiv(buffer, drawbuffer, value);
+        g_GLESFuncs.glClearBufferuiv(buffer, drawbuffer, value);
     }
 
     class TempPixelStoreParameterSync {
@@ -1190,28 +1187,28 @@ namespace MobileGL::MG_Backend::DirectGLES {
         PixelStoreParameters QueryCurrentGLPixelStoreParams(Bool isUnpack) {
             PixelStoreParameters p;
             if (!isUnpack) {
-                MG_External::GLES::glGetIntegerv(GL_PACK_ALIGNMENT, (GLint*)&p.Alignment);
+                g_GLESFuncs.glGetIntegerv(GL_PACK_ALIGNMENT, (GLint*)&p.Alignment);
-                MG_External::GLES::glGetIntegerv(GL_PACK_ROW_LENGTH, (GLint*)&p.RowLength);
+                g_GLESFuncs.glGetIntegerv(GL_PACK_ROW_LENGTH, (GLint*)&p.RowLength);
-                MG_External::GLES::glGetIntegerv(GL_PACK_SKIP_ROWS, (GLint*)&p.SkipRows);
+                g_GLESFuncs.glGetIntegerv(GL_PACK_SKIP_ROWS, (GLint*)&p.SkipRows);
-                MG_External::GLES::glGetIntegerv(GL_PACK_SKIP_PIXELS, (GLint*)&p.SkipPixels);
+                g_GLESFuncs.glGetIntegerv(GL_PACK_SKIP_PIXELS, (GLint*)&p.SkipPixels);
-                // MG_External::GLES::glGetIntegerv(GL_PACK_IMAGE_HEIGHT, (GLint*)&p.ImageHeight);
+                // g_GLESFuncs.glGetIntegerv(GL_PACK_IMAGE_HEIGHT, (GLint*)&p.ImageHeight);
-                // MG_External::GLES::glGetIntegerv(GL_PACK_SKIP_IMAGES, (GLint*)&p.SkipImages);
+                // g_GLESFuncs.glGetIntegerv(GL_PACK_SKIP_IMAGES, (GLint*)&p.SkipImages);
                 // GLint tmp;
-                // MG_External::GLES::glGetIntegerv(GL_PACK_SWAP_BYTES, &tmp);
+                // g_GLESFuncs.glGetIntegerv(GL_PACK_SWAP_BYTES, &tmp);
                 // p.SwapBytes = tmp ? true : false;
-                // MG_External::GLES::glGetIntegerv(GL_PACK_LSB_FIRST, &tmp);
+                // g_GLESFuncs.glGetIntegerv(GL_PACK_LSB_FIRST, &tmp);
                 // p.LSBFirst = tmp ? true : false;
             } else {
-                MG_External::GLES::glGetIntegerv(GL_UNPACK_ALIGNMENT, (GLint*)&p.Alignment);
+                g_GLESFuncs.glGetIntegerv(GL_UNPACK_ALIGNMENT, (GLint*)&p.Alignment);
-                MG_External::GLES::glGetIntegerv(GL_UNPACK_ROW_LENGTH, (GLint*)&p.RowLength);
+                g_GLESFuncs.glGetIntegerv(GL_UNPACK_ROW_LENGTH, (GLint*)&p.RowLength);
-                MG_External::GLES::glGetIntegerv(GL_UNPACK_SKIP_ROWS, (GLint*)&p.SkipRows);
+                g_GLESFuncs.glGetIntegerv(GL_UNPACK_SKIP_ROWS, (GLint*)&p.SkipRows);
-                MG_External::GLES::glGetIntegerv(GL_UNPACK_SKIP_PIXELS, (GLint*)&p.SkipPixels);
+                g_GLESFuncs.glGetIntegerv(GL_UNPACK_SKIP_PIXELS, (GLint*)&p.SkipPixels);
-                MG_External::GLES::glGetIntegerv(GL_UNPACK_IMAGE_HEIGHT, (GLint*)&p.ImageHeight);
+                g_GLESFuncs.glGetIntegerv(GL_UNPACK_IMAGE_HEIGHT, (GLint*)&p.ImageHeight);
-                MG_External::GLES::glGetIntegerv(GL_UNPACK_SKIP_IMAGES, (GLint*)&p.SkipImages);
+                g_GLESFuncs.glGetIntegerv(GL_UNPACK_SKIP_IMAGES, (GLint*)&p.SkipImages);
                 // GLint tmp;
-                // MG_External::GLES::glGetIntegerv(GL_UNPACK_SWAP_BYTES, &tmp);
+                // g_GLESFuncs.glGetIntegerv(GL_UNPACK_SWAP_BYTES, &tmp);
                 // p.SwapBytes = tmp ? true : false;
-                // MG_External::GLES::glGetIntegerv(GL_UNPACK_LSB_FIRST, &tmp);
+                // g_GLESFuncs.glGetIntegerv(GL_UNPACK_LSB_FIRST, &tmp);
                 // p.LSBFirst = tmp ? true : false;
             }
             return p;
@@ -1219,23 +1216,23 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
         void Sync(Bool isUnpack, const PixelStoreParameters& params) {
             if (!isUnpack) {
-                MG_External::GLES::glPixelStorei(GL_PACK_ALIGNMENT, params.Alignment);
+                g_GLESFuncs.glPixelStorei(GL_PACK_ALIGNMENT, params.Alignment);
-                MG_External::GLES::glPixelStorei(GL_PACK_ROW_LENGTH, params.RowLength);
+                g_GLESFuncs.glPixelStorei(GL_PACK_ROW_LENGTH, params.RowLength);
-                MG_External::GLES::glPixelStorei(GL_PACK_SKIP_ROWS, params.SkipRows);
+                g_GLESFuncs.glPixelStorei(GL_PACK_SKIP_ROWS, params.SkipRows);
-                MG_External::GLES::glPixelStorei(GL_PACK_SKIP_PIXELS, params.SkipPixels);
+                g_GLESFuncs.glPixelStorei(GL_PACK_SKIP_PIXELS, params.SkipPixels);
-                // MG_External::GLES::glPixelStorei(GL_PACK_IMAGE_HEIGHT, params.ImageHeight);
+                // g_GLESFuncs.glPixelStorei(GL_PACK_IMAGE_HEIGHT, params.ImageHeight);
-                // MG_External::GLES::glPixelStorei(GL_PACK_SKIP_IMAGES, params.SkipImages);
+                // g_GLESFuncs.glPixelStorei(GL_PACK_SKIP_IMAGES, params.SkipImages);
-                // MG_External::GLES::glPixelStorei(GL_PACK_SWAP_BYTES, params.SwapBytes ? GL_TRUE : GL_FALSE);
+                // g_GLESFuncs.glPixelStorei(GL_PACK_SWAP_BYTES, params.SwapBytes ? GL_TRUE : GL_FALSE);
-                // MG_External::GLES::glPixelStorei(GL_PACK_LSB_FIRST, params.LSBFirst ? GL_TRUE : GL_FALSE);
+                // g_GLESFuncs.glPixelStorei(GL_PACK_LSB_FIRST, params.LSBFirst ? GL_TRUE : GL_FALSE);
             } else {
-                MG_External::GLES::glPixelStorei(GL_UNPACK_ALIGNMENT, params.Alignment);
+                g_GLESFuncs.glPixelStorei(GL_UNPACK_ALIGNMENT, params.Alignment);
-                MG_External::GLES::glPixelStorei(GL_UNPACK_ROW_LENGTH, params.RowLength);
+                g_GLESFuncs.glPixelStorei(GL_UNPACK_ROW_LENGTH, params.RowLength);
-                MG_External::GLES::glPixelStorei(GL_UNPACK_SKIP_ROWS, params.SkipRows);
+                g_GLESFuncs.glPixelStorei(GL_UNPACK_SKIP_ROWS, params.SkipRows);
-                MG_External::GLES::glPixelStorei(GL_UNPACK_SKIP_PIXELS, params.SkipPixels);
+                g_GLESFuncs.glPixelStorei(GL_UNPACK_SKIP_PIXELS, params.SkipPixels);
-                MG_External::GLES::glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, params.ImageHeight);
+                g_GLESFuncs.glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, params.ImageHeight);
-                MG_External::GLES::glPixelStorei(GL_UNPACK_SKIP_IMAGES, params.SkipImages);
+                g_GLESFuncs.glPixelStorei(GL_UNPACK_SKIP_IMAGES, params.SkipImages);
-                // MG_External::GLES::glPixelStorei(GL_UNPACK_SWAP_BYTES, params.SwapBytes ? GL_TRUE : GL_FALSE);
+                // g_GLESFuncs.glPixelStorei(GL_UNPACK_SWAP_BYTES, params.SwapBytes ? GL_TRUE : GL_FALSE);
-                // MG_External::GLES::glPixelStorei(GL_UNPACK_LSB_FIRST, params.LSBFirst ? GL_TRUE : GL_FALSE);
+                // g_GLESFuncs.glPixelStorei(GL_UNPACK_LSB_FIRST, params.LSBFirst ? GL_TRUE : GL_FALSE);
             }
         }
     };
@@ -1265,7 +1262,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
         MGLOG_D("ReadPixels: Applying TempPixelStoreParameterSync (PACK)");
         TempPixelStoreParameterSync tempPackParamsSync(false);
 
-        GLenum fbStatus = MG_External::GLES::glCheckFramebufferStatus(GL_READ_FRAMEBUFFER);
+        GLenum fbStatus = g_GLESFuncs.glCheckFramebufferStatus(GL_READ_FRAMEBUFFER);
         MGLOG_D("ReadPixels: GL_READ_FRAMEBUFFER status = %s", MG_Util::ConvertGLEnumToString(fbStatus).c_str());
 
         if (fbStatus != GL_FRAMEBUFFER_COMPLETE) {
@@ -1291,50 +1288,57 @@ namespace MobileGL::MG_Backend::DirectGLES {
             }
             const auto& backendBufferObject = backendBufferIt->second;
             backendBufferObject->Bind(GL_PIXEL_PACK_BUFFER);
-            MG_External::GLES::glGetIntegerv(GL_PIXEL_PACK_BUFFER_BINDING, (GLint*)&prevPixelPackBuffer);
+            g_GLESFuncs.glGetIntegerv(GL_PIXEL_PACK_BUFFER_BINDING, (GLint*)&prevPixelPackBuffer);
         } else {
             usePBO = false;
             MGLOG_D("ReadPixels: Not using PBO");
         }
 
         MGLOG_D("ReadPixels: glReadPixels()");
-        MG_External::GLES::glReadPixels(x, y, width, height, format, type, pixels);
+        g_GLESFuncs.glReadPixels(x, y, width, height, format, type, pixels);
         if (usePBO) {
             // pull back to client memory if PBO is used
             MGLOG_D("ReadPixels: PBO used, mapping buffer to client memory");
-            GLvoid* pboMappedPtr = MG_External::GLES::glMapBufferRange(
+            GLvoid* pboMappedPtr = g_GLESFuncs.glMapBufferRange(GL_PIXEL_PACK_BUFFER, 0,
-                GL_PIXEL_PACK_BUFFER, 0, pixelPackBufferObject->GetSize(), GL_MAP_READ_BIT);
+                                                                pixelPackBufferObject->GetSize(), GL_MAP_READ_BIT);
             if (pboMappedPtr) {
                 MGLOG_D("ReadPixels: Copying data from PBO to client memory");
                 SizeT size = pixelPackBufferObject->GetSize();
                 pixelPackBufferObject->UploadSubData({pboMappedPtr, size}, 0);
                 pixelPackBufferObject->ClearDirty();
                 MGLOG_D("ReadPixels: Unmapping PBO");
-                MG_External::GLES::glUnmapBuffer(GL_PIXEL_PACK_BUFFER);
+                g_GLESFuncs.glUnmapBuffer(GL_PIXEL_PACK_BUFFER);
             } else {
                 MGLOG_E("ReadPixels: glMapBufferRange returned nullptr");
                 MGLOG_E("ReadPixels: glMapBufferRange returned nullptr");
             }
             MGLOG_D("ReadPixels: Restoring previous pixel pack buffer binding %u", prevPixelPackBuffer);
-            MG_External::GLES::glBindBuffer(GL_PIXEL_PACK_BUFFER, prevPixelPackBuffer);
+            g_GLESFuncs.glBindBuffer(GL_PIXEL_PACK_BUFFER, prevPixelPackBuffer);
         }
         MGLOG_D("ReadPixels: finished");
     }
 
     void GetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void* pixels) {
+        DebugImpl::ErrorLopper errorLopper;
         MGLOG_D("GetTexImage: target=%s level=%d format=%s type=%s pixels=%p",
                 MG_Util::ConvertGLEnumToString(target).c_str(), level, MG_Util::ConvertGLEnumToString(format).c_str(),
                 MG_Util::ConvertGLEnumToString(type).c_str(), pixels);
 
-        MOBILEGL_ASSERT(format == GL_RGBA || format == GL_RGBA_INTEGER,
+        MOBILEGL_ASSERT(format == GL_RGBA || format == GL_RGBA_INTEGER || format == GL_BGRA,
-                        "Only GL_RGBA and GL_RGBA_INTEGER are supported currently, while requested %s.",
+                        "Only GL_RGBA, GL_RGBA_INTEGER and GL_BGRA are supported currently, while requested %s.",
                         MG_Util::ConvertGLEnumToString(format).c_str());
         MOBILEGL_ASSERT(type == GL_UNSIGNED_BYTE || type == GL_UNSIGNED_INT || type == GL_UNSIGNED_INT_2_10_10_10_REV ||
-                            type == GL_INT || type == GL_FLOAT,
+                            type == GL_INT || type == GL_FLOAT || type == GL_UNSIGNED_INT_8_8_8_8 ||
+                            type == GL_UNSIGNED_INT_8_8_8_8_REV,
                         "Only GL_UNSIGNED_BYTE, GL_UNSIGNED_INT, GL_UNSIGNED_INT_2_10_10_10_REV, "
-                        "GL_INT and GL_FLOAT are supported currently, while requested %s.",
+                        "GL_INT, GL_FLOAT, GL_UNSIGNED_INT_8_8_8_8 and GL_UNSIGNED_INT_8_8_8_8_REV "
+                        "are supported currently, while requested %s.",
                         MG_Util::ConvertGLEnumToString(type).c_str());
 
+        GLenum esFormat = format, esType = type;
+        if (esFormat == GL_BGRA) esFormat = GL_RGBA;
+        if (esType == GL_UNSIGNED_INT_8_8_8_8 || esType == GL_UNSIGNED_INT_8_8_8_8_REV) esType = GL_UNSIGNED_BYTE;
+
         MGLOG_D("GetTexImage: SyncNeccessaryTextures()");
         TextureImpl::SyncNeccessaryTextures();
 
@@ -1366,12 +1370,11 @@ namespace MobileGL::MG_Backend::DirectGLES {
         TempFBOBinder tempFBOBinder(true);
 
         MGLOG_D("GetTexImage: glFramebufferTexture2D(level=%d)", level);
-        MG_External::GLES::glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target, backendTexId,
+        g_GLESFuncs.glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target, backendTexId, level);
-                                                  level);
         MGLOG_D("GetTexImage: glReadBuffer(GL_COLOR_ATTACHMENT0)");
-        MG_External::GLES::glReadBuffer(GL_COLOR_ATTACHMENT0);
+        g_GLESFuncs.glReadBuffer(GL_COLOR_ATTACHMENT0);
 
-        GLenum fbStatus = MG_External::GLES::glCheckFramebufferStatus(GL_READ_FRAMEBUFFER);
+        GLenum fbStatus = g_GLESFuncs.glCheckFramebufferStatus(GL_READ_FRAMEBUFFER);
         MGLOG_D("GetTexImage: GL_READ_FRAMEBUFFER status = %s", MG_Util::ConvertGLEnumToString(fbStatus).c_str());
 
         if (fbStatus != GL_FRAMEBUFFER_COMPLETE) {
@@ -1380,14 +1383,21 @@ namespace MobileGL::MG_Backend::DirectGLES {
             return;
         }
 
+        errorLopper.Loop([file = __FILE__, line = __LINE__](auto err) {
+            MGLOG_D("ES error (%s:%d): %s", file, line, MG_Util::ConvertGLEnumToString(err).c_str());
+        });
+
         MGLOG_D("GetTexImage: Applying TempPixelStoreParameterSync (PACK)");
         TempPixelStoreParameterSync tempPackParamsSync(false);
 
+        errorLopper.Loop([file = __FILE__, line = __LINE__](auto err) {
+            MGLOG_D("ES error (%s:%d): %s", file, line, MG_Util::ConvertGLEnumToString(err).c_str());
+        });
+
         const auto& storageType = textureObject->GetStorageType();
         MGLOG_D("GetTexImage: texture storage type = %d", (int)storageType);
 
         if (storageType == TextureStorageType::Buffer) {
-            MGLOG_E("GetTexImage: Texture storage type Buffer is not supported.");
             MGLOG_E("GetTexImage: Texture storage type Buffer is not supported.");
             return;
         }
@@ -1427,34 +1437,137 @@ namespace MobileGL::MG_Backend::DirectGLES {
             }
             const auto& backendBufferObject = backendBufferIt->second;
             backendBufferObject->Bind(GL_PIXEL_PACK_BUFFER);
-            MG_External::GLES::glGetIntegerv(GL_PIXEL_PACK_BUFFER_BINDING, (GLint*)&prevPixelPackBuffer);
+            g_GLESFuncs.glGetIntegerv(GL_PIXEL_PACK_BUFFER_BINDING, (GLint*)&prevPixelPackBuffer);
         } else {
             usePBO = false;
             MGLOG_D("GetTexImage: Not using PBO");
         }
-        MGLOG_D("GetTexImage: glReadPixels()");
+
-        MG_External::GLES::glReadPixels(0, 0, size.x(), size.y(), format, type, pixels);
+        errorLopper.Loop([file = __FILE__, line = __LINE__](auto err) {
+            MGLOG_D("ES error (%s:%d): %s", file, line, MG_Util::ConvertGLEnumToString(err).c_str());
+        });
+        MGLOG_D("GetTexImage: glReadPixels(0, 0, %d, %d, %s, %s, %p)", size.x(), size.y(),
+                MG_Util::ConvertGLEnumToString(esFormat).c_str(), MG_Util::ConvertGLEnumToString(esType).c_str(),
+                pixels);
+        g_GLESFuncs.glReadPixels(0, 0, size.x(), size.y(), esFormat, esType, pixels);
+
+        errorLopper.Loop([file = __FILE__, line = __LINE__](auto err) {
+            MGLOG_D("ES error (%s:%d): %s", file, line, MG_Util::ConvertGLEnumToString(err).c_str());
+        });
         if (usePBO) {
             // pull back to client memory if PBO is used
             MGLOG_D("ReadPixels: PBO used, mapping buffer to client memory");
-            GLvoid* pboMappedPtr = MG_External::GLES::glMapBufferRange(
+            GLvoid* pboMappedPtr = g_GLESFuncs.glMapBufferRange(GL_PIXEL_PACK_BUFFER, 0,
-                GL_PIXEL_PACK_BUFFER, 0, pixelPackBufferObject->GetSize(), GL_MAP_READ_BIT);
+                                                                pixelPackBufferObject->GetSize(), GL_MAP_READ_BIT);
             if (pboMappedPtr) {
                 MGLOG_D("ReadPixels: Copying data from PBO to client memory");
                 SizeT size = pixelPackBufferObject->GetSize();
                 pixelPackBufferObject->UploadSubData({pboMappedPtr, size}, 0);
                 pixelPackBufferObject->ClearDirty();
                 MGLOG_D("ReadPixels: Unmapping PBO");
-                MG_External::GLES::glUnmapBuffer(GL_PIXEL_PACK_BUFFER);
+                g_GLESFuncs.glUnmapBuffer(GL_PIXEL_PACK_BUFFER);
             } else {
                 MGLOG_E("ReadPixels: glMapBufferRange returned nullptr");
-                MGLOG_E("ReadPixels: glMapBufferRange returned nullptr");
             }
             MGLOG_D("ReadPixels: Restoring previous pixel pack buffer binding %u", prevPixelPackBuffer);
 
-            MG_External::GLES::glBindBuffer(GL_PIXEL_PACK_BUFFER, prevPixelPackBuffer);
+            g_GLESFuncs.glBindBuffer(GL_PIXEL_PACK_BUFFER, prevPixelPackBuffer);
+        } else {
+            if (esFormat == GL_RGBA && format == GL_BGRA && esType == GL_UNSIGNED_BYTE &&
+                type == GL_UNSIGNED_INT_8_8_8_8_REV) {
+                MGLOG_D("ReadPixels: ProcessColorSwizzle BGRA (not implemented)");
             }
+        }
+
+        errorLopper.Loop([file = __FILE__, line = __LINE__](auto err) {
+            MGLOG_D("ES error (%s:%d): %s", file, line, MG_Util::ConvertGLEnumToString(err).c_str());
+        });
         MGLOG_D("GetTexImage: finished");
     }
 
+    void SetEGLFuncsTable(const MG_External::EGLFunctionsTable& eglFuncs) {
+        g_EGLFuncs = eglFuncs;
+    }
+
+    void SetGLESFuncsTable(const MG_External::GLESFunctionsTable& glesFuncs) {
+        g_GLESFuncs = glesFuncs;
+    }
+
+    void SetGLESCapabilities(const MG_External::GLESCapabilities& capabilities) {
+        g_GLESCapabilities = capabilities;
+    }
+
+    static EGLDisplay g_Display = EGL_NO_DISPLAY;
+    static EGLContext g_Context = EGL_NO_CONTEXT;
+    static EGLSurface g_Surface = EGL_NO_SURFACE;
+    static EGLConfig g_Config = nullptr;
+    Bool InitWindowSurface(NativeWindowType window) {
+        // TODO: handle custom EGL paramters
+        if (!window) return false;
+
+        g_Display = g_EGLFuncs.eglGetDisplay(EGL_DEFAULT_DISPLAY);
+        if (g_Display == EGL_NO_DISPLAY) return false;
+
+        if (!g_EGLFuncs.eglInitialize(g_Display, nullptr, nullptr)) return false;
+        g_EGLFuncs.eglBindAPI(EGL_OPENGL_ES_API);
+
+        const EGLint configAttribs[] = {EGL_SURFACE_TYPE,
+                                        EGL_WINDOW_BIT,
+                                        EGL_RENDERABLE_TYPE,
+                                        EGL_OPENGL_ES3_BIT,
+                                        EGL_RED_SIZE,
+                                        8,
+                                        EGL_GREEN_SIZE,
+                                        8,
+                                        EGL_BLUE_SIZE,
+                                        8,
+                                        EGL_ALPHA_SIZE,
+                                        8,
+                                        EGL_DEPTH_SIZE,
+                                        24,
+                                        EGL_STENCIL_SIZE,
+                                        8,
+                                        EGL_NONE};
+
+        EGLint numConfigs = 0;
+        if (!g_EGLFuncs.eglChooseConfig(g_Display, configAttribs, &g_Config, 1, &numConfigs) || numConfigs == 0)
+            return false;
+
+        const EGLint contextAttribs[] = {EGL_CONTEXT_CLIENT_VERSION, 3, EGL_NONE};
+
+        g_Context = g_EGLFuncs.eglCreateContext(g_Display, g_Config, EGL_NO_CONTEXT, contextAttribs);
+        if (g_Context == EGL_NO_CONTEXT) return false;
+
+        g_Surface = g_EGLFuncs.eglCreateWindowSurface(g_Display, g_Config, window, nullptr);
+        if (g_Surface == EGL_NO_SURFACE) return false;
+
+        if (!g_EGLFuncs.eglMakeCurrent(g_Display, g_Surface, g_Surface, g_Context)) return false;
+
+        MGLOG_D("EGL context created successfully: display=%p, surface=%p, context=%p. window=%p", g_Display, g_Surface,
+                g_Context, window);
+        return true;
+    }
+
+    void Present() {
+        if (g_Display != EGL_NO_DISPLAY && g_Surface != EGL_NO_SURFACE) {
+            g_EGLFuncs.eglSwapBuffers(g_Display, g_Surface);
+        }
+    }
+
+    void DestroyEGLContext() {
+        if (g_Display != EGL_NO_DISPLAY) {
+            g_EGLFuncs.eglMakeCurrent(g_Display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+            if (g_Context != EGL_NO_CONTEXT) {
+                g_EGLFuncs.eglDestroyContext(g_Display, g_Context);
+                g_Context = EGL_NO_CONTEXT;
+            }
+            if (g_Surface != EGL_NO_SURFACE) {
+                g_EGLFuncs.eglDestroySurface(g_Display, g_Surface);
+                g_Surface = EGL_NO_SURFACE;
+            }
+            g_EGLFuncs.eglTerminate(g_Display);
+            g_Display = EGL_NO_DISPLAY;
+        }
+    }
+
 } // namespace MobileGL::MG_Backend::DirectGLES

MobileGL/MG_Backend/DirectGLES/DirectGLES.h

@@ -10,6 +10,7 @@
 #include <Includes.h>
 #include <MG_State/GLState/TextureState/TextureState.h>
 #include <MG_State/GLState/SamplerState/SamplerObject.h>
+#include <MG_Util/BackendLoaders/OpenGL/Loader.h>
 
 #define CallAndCheck(operation)                                                                                        \
     MGLOG_D("Call GLES func: %s", #operation);                                                                         \
@@ -55,5 +56,14 @@ namespace MobileGL::MG_Backend::DirectGLES {
     const GLubyte* GetString(GLenum name);
     void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels);
     void GetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid* pixels);
+    Bool InitWindowSurface(NativeWindowType window);
+    void Present();
+    void SetEGLFuncsTable(const MG_External::EGLFunctionsTable& eglFuncs);
+    void SetGLESFuncsTable(const MG_External::GLESFunctionsTable& glesFuncs);
+    void SetGLESCapabilities(const MG_External::GLESCapabilities& capabilities);
+    void DestroyEGLContext();
 
+    extern MG_External::EGLFunctionsTable g_EGLFuncs;
+    extern MG_External::GLESFunctionsTable g_GLESFuncs;
+    extern MG_External::GLESCapabilities g_GLESCapabilities;
 } // namespace MobileGL::MG_Backend::DirectGLES

MobileGL/MG_Backend/DirectGLES/Managers.cpp

@@ -35,10 +35,10 @@ namespace MobileGL::MG_Backend::DirectGLES {
 #ifdef TRACY_ENABLE
             ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
 #endif
-            MG_External::GLES::glGenBuffers(1, &m_backendBufferId);
+            g_GLESFuncs.glGenBuffers(1, &m_backendBufferId);
             if (m_backendBufferId == 0) {
                 MGLOG_E("Failed to generate buffer object.");
-                MGLOG_E("ES glGetError(): %s", MG_Util::ConvertGLEnumToString(MG_External::GLES::glGetError()).c_str());
+                MGLOG_E("ES glGetError(): %s", MG_Util::ConvertGLEnumToString(g_GLESFuncs.glGetError()).c_str());
             } else {
                 MGLOG_D("Generated buffer object with ID: %u.", m_backendBufferId);
             }
@@ -117,7 +117,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
             GLenum usage = MG_Util::ConvertBufferUsageToGLEnum(stateBufferObject->GetUsage());
 
             Bind();
-            MG_External::GLES::glBufferData(TempBufferTarget, size, data, usage);
+            g_GLESFuncs.glBufferData(TempBufferTarget, size, data, usage);
         }
 
         void BackendBufferObject::SyncToBackend_glBufferSubData(
@@ -138,7 +138,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
             for (const auto& range : ranges) {
                 Bind();
-                MG_External::GLES::glBufferSubData(TempBufferTarget, range.start, range.end - range.start,
+                g_GLESFuncs.glBufferSubData(TempBufferTarget, range.start, range.end - range.start,
                                             reinterpret_cast<const char*>(data) + range.start);
             }
         }
@@ -159,9 +159,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
             SizeT minStart = ranges.GetOverallMinStart();
             SizeT maxEnd = ranges.GetOverallMaxEnd();
             Bind();
-            void* mappedData = MG_External::GLES::glMapBufferRange(
+            void* mappedData = g_GLESFuncs.glMapBufferRange(TempBufferTarget, minStart, maxEnd - minStart,
-                TempBufferTarget, minStart, maxEnd - minStart,
+                                                            (invalidate ? GL_MAP_INVALIDATE_RANGE_BIT : 0) |
-                (invalidate ? GL_MAP_INVALIDATE_RANGE_BIT : 0) | (unsynchronized ? GL_MAP_UNSYNCHRONIZED_BIT : 0) |
+                                                                (unsynchronized ? GL_MAP_UNSYNCHRONIZED_BIT : 0) |
                                                                 GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT);
             const void* data = stateBufferObject->GetDataReadOnly()->data();
             if (mappedData) {
@@ -169,10 +169,10 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 Memcpy(mappedData, reinterpret_cast<const char*>(data) + minStart, maxEnd - minStart);
                 // Explicitly flush the dirty ranges
                 for (const auto& range : ranges) {
-                    MG_External::GLES::glFlushMappedBufferRange(TempBufferTarget, range.start - minStart,
+                    g_GLESFuncs.glFlushMappedBufferRange(TempBufferTarget, range.start - minStart,
                                                          range.end - range.start);
                 }
-                MG_External::GLES::glUnmapBuffer(TempBufferTarget);
+                g_GLESFuncs.glUnmapBuffer(TempBufferTarget);
             } else {
                 MGLOG_E("Failed to map buffer with ID: %u", m_backendBufferId);
             }
@@ -188,7 +188,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 }
                 g_boundVertexBufferObject = this;
             }
-            MG_External::GLES::glBindBuffer(target, m_backendBufferId);
+            g_GLESFuncs.glBindBuffer(target, m_backendBufferId);
         }
 
         UnorderedMap<SharedPtr<MG_State::GLState::BufferObject>, SharedPtr<BackendBufferObject>> g_backendBufferObjects;
@@ -200,10 +200,10 @@ namespace MobileGL::MG_Backend::DirectGLES {
 #ifdef TRACY_ENABLE
             ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
 #endif
-            MG_External::GLES::glGenVertexArrays(1, &m_backendVAOId);
+            g_GLESFuncs.glGenVertexArrays(1, &m_backendVAOId);
             if (m_backendVAOId == 0) {
                 MGLOG_E("Failed to generate vertex array object.");
-                MGLOG_E("ES glGetError(): %s", MG_Util::ConvertGLEnumToString(MG_External::GLES::glGetError()).c_str());
+                MGLOG_E("ES glGetError(): %s", MG_Util::ConvertGLEnumToString(g_GLESFuncs.glGetError()).c_str());
             } else {
                 MGLOG_D("Generated vertex array object with ID: %u.", m_backendVAOId);
             }
@@ -213,7 +213,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
 #ifdef TRACY_ENABLE
             ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
 #endif
-            MG_External::GLES::glBindVertexArray(m_backendVAOId);
+            g_GLESFuncs.glBindVertexArray(m_backendVAOId);
         }
 
         void BackendVertexArrayObject::BindAttributeBuffer(Uint index,
@@ -256,9 +256,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
                                        m_syncedAttributeVersions[attribIndex].SwitchVersion;
                 if (needsSyncSwitch) {
                     if (attrib.Enabled) {
-                        MG_External::GLES::glEnableVertexAttribArray(attribIndex);
+                        g_GLESFuncs.glEnableVertexAttribArray(attribIndex);
                     } else {
-                        MG_External::GLES::glDisableVertexAttribArray(attribIndex);
+                        g_GLESFuncs.glDisableVertexAttribArray(attribIndex);
                     }
                 }
 
@@ -271,17 +271,17 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 BindAttributeBuffer(attribIndex, attrib);
 
                 if (!attrib.IsInteger) {
-                    MG_External::GLES::glVertexAttribPointer(
+                    g_GLESFuncs.glVertexAttribPointer(
                         attribIndex, attrib.Size, MG_Util::ConvertDataTypeToGLEnum(attrib.Type),
                         attrib.Normalized ? GL_TRUE : GL_FALSE, attrib.Stride, (const void*)attrib.Offset);
                 } else {
-                    MG_External::GLES::glVertexAttribIPointer(attribIndex, attrib.Size,
+                    g_GLESFuncs.glVertexAttribIPointer(attribIndex, attrib.Size,
-                                                              MG_Util::ConvertDataTypeToGLEnum(attrib.Type),
+                                                       MG_Util::ConvertDataTypeToGLEnum(attrib.Type), attrib.Stride,
-                                                              attrib.Stride, (const void*)attrib.Offset);
+                                                       (const void*)attrib.Offset);
                 }
 
                 if (needsSyncFormat) {
-                    MG_External::GLES::glVertexAttribDivisor(attribIndex, attrib.Divisor);
+                    g_GLESFuncs.glVertexAttribDivisor(attribIndex, attrib.Divisor);
                 }
             }
 
@@ -312,10 +312,10 @@ namespace MobileGL::MG_Backend::DirectGLES {
 #ifdef TRACY_ENABLE
             ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
 #endif
-            MG_External::GLES::glGenTextures(1, &m_backendTextureId);
+            g_GLESFuncs.glGenTextures(1, &m_backendTextureId);
             if (m_backendTextureId == 0) {
                 MGLOG_E("Failed to generate texture object.");
-                MGLOG_E("ES glGetError(): %s", MG_Util::ConvertGLEnumToString(MG_External::GLES::glGetError()).c_str());
+                MGLOG_E("ES glGetError(): %s", MG_Util::ConvertGLEnumToString(g_GLESFuncs.glGetError()).c_str());
             } else {
                 MGLOG_D("Generated texture object with ID: %u.", m_backendTextureId);
             }
@@ -332,7 +332,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
             auto targetN = static_cast<SizeT>(MG_Util::ConvertGLEnumToTextureTarget(target));
             if (this == g_boundTexturesCache[unit][targetN]) return;
 
-            MG_External::GLES::glBindTexture(target, m_backendTextureId);
+            g_GLESFuncs.glBindTexture(target, m_backendTextureId);
             g_boundTexturesCache[unit][targetN] = this;
         }
 
@@ -430,20 +430,20 @@ namespace MobileGL::MG_Backend::DirectGLES {
                                 levelDirty ? "true" : "false");
 
                             errorLopper.Clear();
-                            MG_External::GLES::glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
+                            g_GLESFuncs.glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
                             auto textureTarget = stateTextureObject->GetTarget();
                             // TODO: handle more texture types
                             switch (textureTarget) {
                             case TextureTarget::Texture2D:
                             case TextureTarget::TextureCubeMap: {
-                                MG_External::GLES::glTexImage2D(
+                                g_GLESFuncs.glTexImage2D(glUploadTarget, static_cast<GLint>(level), glInternalFormat,
-                                    glUploadTarget, static_cast<GLint>(level), glInternalFormat,
+                                                         static_cast<GLsizei>(levelTexelSize.x()),
-                                    static_cast<GLsizei>(levelTexelSize.x()), static_cast<GLsizei>(levelTexelSize.y()),
+                                                         static_cast<GLsizei>(levelTexelSize.y()), 0, glFormat, glType,
-                                    0, glFormat, glType, pData);
+                                                         pData);
                                 break;
                             }
                             case TextureTarget::Texture3D: {
-                                MG_External::GLES::glTexImage3D(
+                                g_GLESFuncs.glTexImage3D(
                                     glUploadTarget, static_cast<GLint>(level), glInternalFormat,
                                     static_cast<GLsizei>(levelTexelSize.x()), static_cast<GLsizei>(levelTexelSize.y()),
                                     static_cast<GLsizei>(levelTexelSize.z()), 0, glFormat, glType, pData);
@@ -498,13 +498,13 @@ namespace MobileGL::MG_Backend::DirectGLES {
                                         textureMipmapObject->GetMipmapTexelSize(uploadTarget, level).y(), byteSize);
 
                             auto glUploadTarget = MG_Util::ConvertTextureUploadTargetToGLEnum(uploadTarget);
-                            MG_External::GLES::glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
+                            g_GLESFuncs.glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
                             errorLopper.Loop([file = __FILE__, line = __LINE__, func = __func__](GLenum err) {
                                 MGLOG_D("%s(%s:%d) ES error: %s", func, file, line,
                                         MG_Util::ConvertGLEnumToString(err).c_str());
                             });
                             auto texelSize = textureMipmapObject->GetMipmapTexelSize(uploadTarget, level);
-                            MG_External::GLES::glTexSubImage2D(glUploadTarget, static_cast<GLint>(level), 0, 0,
+                            g_GLESFuncs.glTexSubImage2D(glUploadTarget, static_cast<GLint>(level), 0, 0,
                                                         static_cast<GLsizei>(texelSize.x()),
                                                         static_cast<GLsizei>(texelSize.y()), glFormat, glType,
                                                         textureMipmapObject->MapMipmapData(uploadTarget, level));
@@ -546,7 +546,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 TextureImpl::GenerateTextureFormatInfo(textureBufferObject->GetFormat(), &glInternalFormat, &glFormat,
                                                        &glType);
 
-                MG_External::GLES::glTexBuffer(GL_TEXTURE_BUFFER, glInternalFormat, backendId);
+                g_GLESFuncs.glTexBuffer(GL_TEXTURE_BUFFER, glInternalFormat, backendId);
                 break;
             }
             default:
@@ -604,7 +604,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
 #define SYNC_TEX_SAMPLER_PARAM_IF_CHANGED(internalName, glName, type)                                                  \
     if (m_cacheSamplerParameters.internalName != samplerParams.internalName) {                                         \
-        MG_External::GLES::glTexParameteri(target, glName,                                                             \
+        g_GLESFuncs.glTexParameteri(target, glName,                                                                    \
                                     MG_Util::ConvertSampler##type##ToGLEnum(samplerParams.internalName));              \
         m_cacheSamplerParameters.internalName = samplerParams.internalName;                                            \
         errorLopper.Loop([file = __FILE__, line = __LINE__, func = __func__,                                           \
@@ -616,14 +616,14 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
             if (m_cacheSamplerParameters.minFilter != samplerParams.minFilter ||
                 m_cacheSamplerParameters.mipmapMode != samplerParams.mipmapMode) {
-                MG_External::GLES::glTexParameteri(
+                g_GLESFuncs.glTexParameteri(
                     target, GL_TEXTURE_MIN_FILTER,
                     MG_Util::ConvertSamplerFilterModeToGLEnum(samplerParams.minFilter, samplerParams.mipmapMode));
                 m_cacheSamplerParameters.minFilter = samplerParams.minFilter;
                 m_cacheSamplerParameters.mipmapMode = samplerParams.mipmapMode;
             }
             if (m_cacheSamplerParameters.magFilter != samplerParams.magFilter) {
-                MG_External::GLES::glTexParameteri(
+                g_GLESFuncs.glTexParameteri(
                     target, GL_TEXTURE_MAG_FILTER,
                     MG_Util::ConvertSamplerFilterModeToGLEnum(samplerParams.magFilter, SamplerMipmapMode::None));
                 m_cacheSamplerParameters.magFilter = samplerParams.magFilter;
@@ -638,11 +638,11 @@ namespace MobileGL::MG_Backend::DirectGLES {
             SYNC_TEX_SAMPLER_PARAM_IF_CHANGED(compareFunc, GL_TEXTURE_COMPARE_FUNC, CompareFunc)
             SYNC_TEX_SAMPLER_PARAM_IF_CHANGED(compareMode, GL_TEXTURE_COMPARE_MODE, CompareMode)
             if (m_cacheSamplerParameters.minLod != samplerParams.minLod) {
-                MG_External::GLES::glTexParameterf(target, GL_TEXTURE_MIN_LOD, samplerParams.minLod);
+                g_GLESFuncs.glTexParameterf(target, GL_TEXTURE_MIN_LOD, samplerParams.minLod);
                 m_cacheSamplerParameters.minLod = samplerParams.minLod;
             }
             if (m_cacheSamplerParameters.maxLod != samplerParams.maxLod) {
-                MG_External::GLES::glTexParameterf(target, GL_TEXTURE_MAX_LOD, samplerParams.maxLod);
+                g_GLESFuncs.glTexParameterf(target, GL_TEXTURE_MAX_LOD, samplerParams.maxLod);
                 m_cacheSamplerParameters.maxLod = samplerParams.maxLod;
             }
             errorLopper.Loop([file = __FILE__, line = __LINE__, func = __func__](GLenum err) {
@@ -693,14 +693,14 @@ namespace MobileGL::MG_Backend::DirectGLES {
             const auto& levelRange = stateTextureObject->GetLevelRange();
 
             if (m_cacheLodRange.x() != levelRange.x()) {
-                MG_External::GLES::glTexParameteri(target, GL_TEXTURE_BASE_LEVEL, static_cast<GLint>(levelRange.x()));
+                g_GLESFuncs.glTexParameteri(target, GL_TEXTURE_BASE_LEVEL, static_cast<GLint>(levelRange.x()));
                 m_cacheLodRange.x() = levelRange.x();
             }
             errorLopper.Loop([file = __FILE__, line = __LINE__, func = __func__](GLenum err) {
                 MGLOG_D("%s(%s:%d) ES error %s", func, file, line, MG_Util::ConvertGLEnumToString(err).c_str());
             });
             if (m_cacheLodRange.y() != levelRange.y()) {
-                MG_External::GLES::glTexParameteri(target, GL_TEXTURE_MAX_LEVEL, static_cast<GLint>(levelRange.y()));
+                g_GLESFuncs.glTexParameteri(target, GL_TEXTURE_MAX_LEVEL, static_cast<GLint>(levelRange.y()));
                 m_cacheLodRange.y() = levelRange.y();
             }
             errorLopper.Loop([file = __FILE__, line = __LINE__, func = __func__](GLenum err) {
@@ -711,8 +711,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
             if (swizzleParams != m_cacheSwizzleParams) {
 #define SYNC_TEX_SWIZZLE_PARAM_IF_CHANGED(func, glEnum)                                                                \
     if (m_cacheSwizzleParams.func != swizzleParams.func) {                                                             \
-        MG_External::GLES::glTexParameteri(target, glEnum,                                                             \
+        g_GLESFuncs.glTexParameteri(target, glEnum, MG_Util::ConvertTextureSwizzleParamToGLEnum(swizzleParams.func));  \
-                                           MG_Util::ConvertTextureSwizzleParamToGLEnum(swizzleParams.func));           \
         m_cacheSwizzleParams.func = swizzleParams.func;                                                                \
     }
                 SYNC_TEX_SWIZZLE_PARAM_IF_CHANGED(r(), GL_TEXTURE_SWIZZLE_R);
@@ -729,7 +728,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
             if (m_cacheBorderColor != stateTextureObject->GetBorderColor()) {
                 const auto& borderColor = stateTextureObject->GetBorderColor();
                 GLfloat borderColorArray[4] = {borderColor.x(), borderColor.y(), borderColor.z(), borderColor.w()};
-                MG_External::GLES::glTexParameterfv(target, GL_TEXTURE_BORDER_COLOR, borderColorArray);
+                g_GLESFuncs.glTexParameterfv(target, GL_TEXTURE_BORDER_COLOR, borderColorArray);
                 m_cacheBorderColor = borderColor;
                 errorLopper.Loop([file = __FILE__, line = __LINE__, func = __func__](GLenum err) {
                     MGLOG_D("%s(%s:%d) ES error %s", func, file, line, MG_Util::ConvertGLEnumToString(err).c_str());
@@ -741,7 +740,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
             if (unit == g_activeTextureUnit) {
                 return;
             }
-            MG_External::GLES::glActiveTexture(GL_TEXTURE0 + unit);
+            g_GLESFuncs.glActiveTexture(GL_TEXTURE0 + unit);
             g_activeTextureUnit = unit;
         }
 
@@ -753,7 +752,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
             auto targetN = static_cast<SizeT>(MG_Util::ConvertGLEnumToTextureTarget(target));
             if (g_boundTexturesCache[unit][targetN] == nullptr) return;
 
-            MG_External::GLES::glBindTexture(target, 0);
+            g_GLESFuncs.glBindTexture(target, 0);
             g_boundTexturesCache[unit][targetN] = nullptr;
         }
 
@@ -770,10 +769,10 @@ namespace MobileGL::MG_Backend::DirectGLES {
 #ifdef TRACY_ENABLE
             ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
 #endif
-            MG_External::GLES::glGenFramebuffers(1, &m_backendFBOId);
+            g_GLESFuncs.glGenFramebuffers(1, &m_backendFBOId);
             if (m_backendFBOId == 0) {
                 MGLOG_E("Failed to generate framebuffer object.");
-                MGLOG_E("ES glGetError(): %s", MG_Util::ConvertGLEnumToString(MG_External::GLES::glGetError()).c_str());
+                MGLOG_E("ES glGetError(): %s", MG_Util::ConvertGLEnumToString(g_GLESFuncs.glGetError()).c_str());
             } else {
                 MGLOG_D("Generated framebuffer object with ID: %u.", m_backendFBOId);
             }
@@ -784,9 +783,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
             ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
 #endif
             if (target == FramebufferTarget::Read)
-                MG_External::GLES::glBindFramebuffer(GL_READ_FRAMEBUFFER, m_backendFBOId);
+                g_GLESFuncs.glBindFramebuffer(GL_READ_FRAMEBUFFER, m_backendFBOId);
             else
-                MG_External::GLES::glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_backendFBOId);
+                g_GLESFuncs.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_backendFBOId);
         }
 
         Bool BackendFramebufferObject::SyncAttachmentObject(
@@ -802,7 +801,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 const auto& backendTextureObject = backendTextureIt->second;
                 auto glTextureTarget = MG_Util::ConvertTextureTargetToGLEnum(textureObject->GetTarget());
                 backendTextureObject->Bind(glTextureTarget);
-                MG_External::GLES::glFramebufferTexture2D(glFBOTarget, glBackendAttachment, glTextureTarget,
+                g_GLESFuncs.glFramebufferTexture2D(glFBOTarget, glBackendAttachment, glTextureTarget,
                                                    backendTextureObject->GetBackendTextureId(),
                                                    static_cast<GLint>(attachmentObject.GetTextureLevel()));
             } else if (attachmentObject.IsRenderbuffer()) {
@@ -819,7 +818,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
                 backendRenderbufferObject->SyncToBackend(renderbufferObject);
                 backendRenderbufferObject->Bind();
-                MG_External::GLES::glFramebufferRenderbuffer(glFBOTarget, glBackendAttachment, GL_RENDERBUFFER,
+                g_GLESFuncs.glFramebufferRenderbuffer(glFBOTarget, glBackendAttachment, GL_RENDERBUFFER,
                                                       backendRenderbufferObject->GetBackendRenderbufferId());
             }
             return true;
@@ -872,7 +871,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
                     }
                     nEffectiveBuffers = i + 1;
                 }
-                MG_External::GLES::glDrawBuffers(nEffectiveBuffers, m_backendDrawBuffers);
+                g_GLESFuncs.glDrawBuffers(nEffectiveBuffers, m_backendDrawBuffers);
             }
 
             // 2. Remap read buffer
@@ -884,7 +883,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
                 if (m_backendReadBuffer != glBackendReadBuffer) {
                     m_backendReadBuffer = glBackendReadBuffer;
-                    MG_External::GLES::glReadBuffer(glBackendReadBuffer);
+                    g_GLESFuncs.glReadBuffer(glBackendReadBuffer);
                 }
             }
 
@@ -917,14 +916,14 @@ namespace MobileGL::MG_Backend::DirectGLES {
                             MG_Util::ConvertGLEnumToString(glBackendAttachment).c_str(),
                             m_syncedFrontendAttachmentVersions[i]);
                     GLint objectType = GL_NONE;
-                    MG_External::GLES::glGetFramebufferAttachmentParameteriv(
+                    g_GLESFuncs.glGetFramebufferAttachmentParameteriv(
                         glFBOTarget, glBackendAttachment, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, &objectType);
                     MOBILEGL_ASSERT((objectType == GL_NONE) ||
                                         (attachmentObject.IsTexture() && objectType == GL_TEXTURE) ||
                                         (attachmentObject.IsRenderbuffer() && objectType == GL_RENDERBUFFER),
                                     "Attachment type not match!");
                     GLint objectName = 0;
-                    MG_External::GLES::glGetFramebufferAttachmentParameteriv(
+                    g_GLESFuncs.glGetFramebufferAttachmentParameteriv(
                         glFBOTarget, glBackendAttachment, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &objectName);
                     // Verify that the backend object's name and parameters match the frontend attachment state
                     if (attachmentObject.IsTexture()) {
@@ -939,7 +938,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
                                         objectName, backendTexId, textureObject->GetExternalIndex());
 
                         GLint texLevel = 0;
-                        MG_External::GLES::glGetFramebufferAttachmentParameteriv(
+                        g_GLESFuncs.glGetFramebufferAttachmentParameteriv(
                             glFBOTarget, glBackendAttachment, GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL, &texLevel);
                         MOBILEGL_ASSERT(texLevel == static_cast<GLint>(attachmentObject.GetTextureLevel()),
                                         "Attachment texture level mismatch between GLES and state object.");
@@ -989,10 +988,10 @@ namespace MobileGL::MG_Backend::DirectGLES {
 #ifdef TRACY_ENABLE
             ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
 #endif
-            m_backendProgramId = MG_External::GLES::glCreateProgram();
+            m_backendProgramId = g_GLESFuncs.glCreateProgram();
             if (m_backendProgramId == 0) {
                 MGLOG_E("Failed to create program object in backend.");
-                MGLOG_E("ES glGetError(): %s", MG_Util::ConvertGLEnumToString(MG_External::GLES::glGetError()).c_str());
+                MGLOG_E("ES glGetError(): %s", MG_Util::ConvertGLEnumToString(g_GLESFuncs.glGetError()).c_str());
 
             } else {
                 MGLOG_D("Created backend program object with ID: %u", m_backendProgramId);
@@ -1005,7 +1004,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
 #endif
             if (m_backendProgramId != 0) {
                 MGLOG_D("Deleting backend program object with ID: %u", m_backendProgramId);
-                MG_External::GLES::glDeleteProgram(m_backendProgramId);
+                g_GLESFuncs.glDeleteProgram(m_backendProgramId);
             }
         }
 
@@ -1029,19 +1028,19 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
             // Detach all existing shaders
             GLint attachedCount = 0;
-            MG_External::GLES::glGetProgramiv(m_backendProgramId, GL_ATTACHED_SHADERS, &attachedCount);
+            g_GLESFuncs.glGetProgramiv(m_backendProgramId, GL_ATTACHED_SHADERS, &attachedCount);
             MGLOG_D("Currently attached shaders count: %d", attachedCount);
 
             if (attachedCount > 0) {
                 Vector<GLuint> attachedShaders(attachedCount);
                 GLsizei actualCount;
-                MG_External::GLES::glGetAttachedShaders(m_backendProgramId, attachedCount, &actualCount,
+                g_GLESFuncs.glGetAttachedShaders(m_backendProgramId, attachedCount, &actualCount,
                                                  attachedShaders.data());
                 MGLOG_D("Detaching %d existing shaders from program %u", actualCount, m_backendProgramId);
 
                 for (GLsizei i = 0; i < actualCount; ++i) {
                     MGLOG_D("Detaching shader ID: %u from program %u", attachedShaders[i], m_backendProgramId);
-                    MG_External::GLES::glDetachShader(m_backendProgramId, attachedShaders[i]);
+                    g_GLESFuncs.glDetachShader(m_backendProgramId, attachedShaders[i]);
                 }
             }
 
@@ -1060,7 +1059,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
             for (int index = 0; index < attachedShaders.size(); ++index) {
                 auto& shader = attachedShaders[index];
                 GLenum glShaderType = MG_Util::ConvertShaderStageToGLEnum(shader->GetShaderStage());
-                GLuint backendShaderId = MG_External::GLES::glCreateShader(glShaderType);
+                GLuint backendShaderId = g_GLESFuncs.glCreateShader(glShaderType);
 
                 if (backendShaderId == 0) {
                     MGLOG_E("Failed to create backend shader for attachment.");
@@ -1111,37 +1110,37 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
                 const char* sourceCStr = source.c_str();
                 MGLOG_D("Setting shader source for backend shader ID: %u\nsrc:\n%s", backendShaderId, sourceCStr);
-                MG_External::GLES::glShaderSource(backendShaderId, 1, &sourceCStr, nullptr);
+                g_GLESFuncs.glShaderSource(backendShaderId, 1, &sourceCStr, nullptr);
-                MG_External::GLES::glCompileShader(backendShaderId);
+                g_GLESFuncs.glCompileShader(backendShaderId);
 
                 GLint compileStatus;
-                MG_External::GLES::glGetShaderiv(backendShaderId, GL_COMPILE_STATUS, &compileStatus);
+                g_GLESFuncs.glGetShaderiv(backendShaderId, GL_COMPILE_STATUS, &compileStatus);
                 if (compileStatus == GL_FALSE) {
                     GLint logLength;
-                    MG_External::GLES::glGetShaderiv(backendShaderId, GL_INFO_LOG_LENGTH, &logLength);
+                    g_GLESFuncs.glGetShaderiv(backendShaderId, GL_INFO_LOG_LENGTH, &logLength);
                     Vector<GLchar> log(logLength);
-                    MG_External::GLES::glGetShaderInfoLog(backendShaderId, logLength, nullptr, log.data());
+                    g_GLESFuncs.glGetShaderInfoLog(backendShaderId, logLength, nullptr, log.data());
                     MGLOG_E("Shader compilation failed for backend ID %u: %s", backendShaderId, log.data());
                     continue;
                 }
 
                 MGLOG_D("Attaching shader ID: %u to program %u", backendShaderId, m_backendProgramId);
-                MG_External::GLES::glAttachShader(m_backendProgramId, backendShaderId);
+                g_GLESFuncs.glAttachShader(m_backendProgramId, backendShaderId);
 
                 MGLOG_D("Processed shader source length: %zu", source.length());
             }
 
             // Link program
             MGLOG_D("Linking program %u", m_backendProgramId);
-            MG_External::GLES::glLinkProgram(m_backendProgramId);
+            g_GLESFuncs.glLinkProgram(m_backendProgramId);
 
             GLint linkStatus;
-            MG_External::GLES::glGetProgramiv(m_backendProgramId, GL_LINK_STATUS, &linkStatus);
+            g_GLESFuncs.glGetProgramiv(m_backendProgramId, GL_LINK_STATUS, &linkStatus);
             if (linkStatus != GL_TRUE) {
                 GLint logLength;
-                MG_External::GLES::glGetProgramiv(m_backendProgramId, GL_INFO_LOG_LENGTH, &logLength);
+                g_GLESFuncs.glGetProgramiv(m_backendProgramId, GL_INFO_LOG_LENGTH, &logLength);
                 Vector<GLchar> log(logLength);
-                MG_External::GLES::glGetProgramInfoLog(m_backendProgramId, logLength, nullptr, log.data());
+                g_GLESFuncs.glGetProgramInfoLog(m_backendProgramId, logLength, nullptr, log.data());
                 MGLOG_E("Program %u linking failed for %u: %s", stateProgramObject->GetExternalIndex(),
                         m_backendProgramId, log.data());
             } else {
@@ -1150,11 +1149,10 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
             // Create global UBO
             if (stateProgramObject->GetUBOSize() > 0) {
-                MG_External::GLES::glGenBuffers(1, &m_backendGlobalUBOId);
+                g_GLESFuncs.glGenBuffers(1, &m_backendGlobalUBOId);
-                MG_External::GLES::glBindBuffer(GL_UNIFORM_BUFFER, m_backendGlobalUBOId);
+                g_GLESFuncs.glBindBuffer(GL_UNIFORM_BUFFER, m_backendGlobalUBOId);
-                MG_External::GLES::glBufferData(GL_UNIFORM_BUFFER, stateProgramObject->GetUBOSize(), nullptr,
+                g_GLESFuncs.glBufferData(GL_UNIFORM_BUFFER, stateProgramObject->GetUBOSize(), nullptr, GL_STREAM_DRAW);
-                                                GL_STREAM_DRAW);
+                g_GLESFuncs.glBindBuffer(GL_UNIFORM_BUFFER, 0);
-                MG_External::GLES::glBindBuffer(GL_UNIFORM_BUFFER, 0);
             } else {
                 m_backendGlobalUBOId = 0;
             }
@@ -1168,7 +1166,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
             ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
 #endif
             MGLOG_D("Using program %u", m_backendProgramId);
-            MG_External::GLES::glUseProgram(m_backendProgramId);
+            g_GLESFuncs.glUseProgram(m_backendProgramId);
         }
     } // namespace PrgramImpl
 
@@ -1177,10 +1175,10 @@ namespace MobileGL::MG_Backend::DirectGLES {
 #ifdef TRACY_ENABLE
             ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
 #endif
-            MG_External::GLES::glGenSamplers(1, &m_backendSamplerId);
+            g_GLESFuncs.glGenSamplers(1, &m_backendSamplerId);
             if (m_backendSamplerId == 0) {
                 MGLOG_E("Failed to generate sampler object.");
-                MGLOG_E("ES glGetError(): %s", MG_Util::ConvertGLEnumToString(MG_External::GLES::glGetError()).c_str());
+                MGLOG_E("ES glGetError(): %s", MG_Util::ConvertGLEnumToString(g_GLESFuncs.glGetError()).c_str());
             } else {
                 MGLOG_D("Generated sampler object with ID: %u.", m_backendSamplerId);
             }
@@ -1211,21 +1209,21 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
 #define SYNC_SAMPLER_PARAM_IF_CHANGED(internalName, glName, type)                                                      \
     if (m_cacheSamplerParameters.internalName != samplerParams.internalName) {                                         \
-        MG_External::GLES::glSamplerParameteri(m_backendSamplerId, glName,                                             \
+        g_GLESFuncs.glSamplerParameteri(m_backendSamplerId, glName,                                                    \
                                         MG_Util::ConvertSampler##type##ToGLEnum(samplerParams.internalName));          \
         m_cacheSamplerParameters.internalName = samplerParams.internalName;                                            \
     }
 
             if (m_cacheSamplerParameters.minFilter != samplerParams.minFilter ||
                 m_cacheSamplerParameters.mipmapMode != samplerParams.mipmapMode) {
-                MG_External::GLES::glSamplerParameteri(
+                g_GLESFuncs.glSamplerParameteri(
                     m_backendSamplerId, GL_TEXTURE_MIN_FILTER,
                     MG_Util::ConvertSamplerFilterModeToGLEnum(samplerParams.minFilter, samplerParams.mipmapMode));
                 m_cacheSamplerParameters.minFilter = samplerParams.minFilter;
                 m_cacheSamplerParameters.mipmapMode = samplerParams.mipmapMode;
             }
             if (m_cacheSamplerParameters.magFilter != samplerParams.magFilter) {
-                MG_External::GLES::glSamplerParameteri(
+                g_GLESFuncs.glSamplerParameteri(
                     m_backendSamplerId, GL_TEXTURE_MAG_FILTER,
                     MG_Util::ConvertSamplerFilterModeToGLEnum(samplerParams.magFilter, SamplerMipmapMode::None));
                 m_cacheSamplerParameters.magFilter = samplerParams.magFilter;
@@ -1237,11 +1235,11 @@ namespace MobileGL::MG_Backend::DirectGLES {
             SYNC_SAMPLER_PARAM_IF_CHANGED(compareFunc, GL_TEXTURE_COMPARE_FUNC, CompareFunc)
             SYNC_SAMPLER_PARAM_IF_CHANGED(compareMode, GL_TEXTURE_COMPARE_MODE, CompareMode)
             if (m_cacheSamplerParameters.minLod != samplerParams.minLod) {
-                MG_External::GLES::glSamplerParameterf(m_backendSamplerId, GL_TEXTURE_MIN_LOD, samplerParams.minLod);
+                g_GLESFuncs.glSamplerParameterf(m_backendSamplerId, GL_TEXTURE_MIN_LOD, samplerParams.minLod);
                 m_cacheSamplerParameters.minLod = samplerParams.minLod;
             }
             if (m_cacheSamplerParameters.maxLod != samplerParams.maxLod) {
-                MG_External::GLES::glSamplerParameterf(m_backendSamplerId, GL_TEXTURE_MAX_LOD, samplerParams.maxLod);
+                g_GLESFuncs.glSamplerParameterf(m_backendSamplerId, GL_TEXTURE_MAX_LOD, samplerParams.maxLod);
                 m_cacheSamplerParameters.maxLod = samplerParams.maxLod;
             }
 #undef SYNC_SAMPLER_PARAM_IF_CHANGED
@@ -1254,7 +1252,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
 #endif
             if (g_boundSamplersCache[unit] == this) return;
 
-            MG_External::GLES::glBindSampler(static_cast<GLenum>(unit), m_backendSamplerId);
+            g_GLESFuncs.glBindSampler(static_cast<GLenum>(unit), m_backendSamplerId);
             g_boundSamplersCache[unit] = this;
         }
 
@@ -1268,7 +1266,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
         void UnbindSampler(Uint unit) {
             if (g_boundSamplersCache[unit] == nullptr) return;
 
-            MG_External::GLES::glBindSampler(static_cast<GLenum>(unit), 0);
+            g_GLESFuncs.glBindSampler(static_cast<GLenum>(unit), 0);
             g_boundSamplersCache[unit] = nullptr;
         }
 
@@ -1282,10 +1280,10 @@ namespace MobileGL::MG_Backend::DirectGLES {
 #ifdef TRACY_ENABLE
             ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
 #endif
-            MG_External::GLES::glGenRenderbuffers(1, &m_backendRBOId);
+            g_GLESFuncs.glGenRenderbuffers(1, &m_backendRBOId);
             if (m_backendRBOId == 0) {
                 MGLOG_E("Failed to generate renderbuffer object.");
-                MGLOG_E("ES glGetError(): %s", MG_Util::ConvertGLEnumToString(MG_External::GLES::glGetError()).c_str());
+                MGLOG_E("ES glGetError(): %s", MG_Util::ConvertGLEnumToString(g_GLESFuncs.glGetError()).c_str());
             }
         }
 
@@ -1293,7 +1291,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
 #ifdef TRACY_ENABLE
             ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
 #endif
-            MG_External::GLES::glBindRenderbuffer(GL_RENDERBUFFER, m_backendRBOId);
+            g_GLESFuncs.glBindRenderbuffer(GL_RENDERBUFFER, m_backendRBOId);
         }
 
         void BackendRenderbufferObject::SyncToBackend(
@@ -1325,7 +1323,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
             GLenum glInternalFormat, glType, glFormat;
             TextureImpl::GenerateTextureFormatInfo(internalFormat, &glInternalFormat, &glFormat, &glType);
 
-            MG_External::GLES::glRenderbufferStorage(GL_RENDERBUFFER, glInternalFormat, static_cast<GLsizei>(width),
+            g_GLESFuncs.glRenderbufferStorage(GL_RENDERBUFFER, glInternalFormat, static_cast<GLsizei>(width),
                                               static_cast<GLsizei>(height));
 
             m_cacheInternalFormat = internalFormat;

MobileGL/MG_Backend/DirectGLES/Utils.cpp

@@ -30,7 +30,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
             ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
 #endif
             using namespace MobileGL::MG_Util::TextureFormatProcessor;
-            auto options = (MG_External::GLES::g_glesCaps.hasNorm16Texture) ? PixelFormatNormalizeOptionBit::None
+            auto options = (g_GLESCapabilities.SupportsNorm16Texture) ? PixelFormatNormalizeOptionBit::None
                                                                       : PixelFormatNormalizeOptionBit::NoNorm16;
             NormalizePixelFormat(MG_Util::ConvertTextureInternalFormatToGLEnum(internalFormat), options,
                                  outInternalFormat, outFormat, outType);
@@ -125,7 +125,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
 #ifdef TRACY_ENABLE
             ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
 #endif
-            while (GLenum err = MG_External::GLES::glGetError() != GL_NO_ERROR) {
+            while (GLenum err = g_GLESFuncs.glGetError() != GL_NO_ERROR) {
                 MGLOG_E("-> GLES Error: %s", MG_Util::ConvertGLEnumToString(err).c_str());
             }
         }

MobileGL/MG_Backend/DirectVulkan/BackendObject_DirectVulkan.cpp

@@ -0,0 +1,115 @@
+// MobileGL - MobileGL/MG_Backend/DirectVulkan/BackendObject_DirectVulkan.cpp
+// Copyright (c) 2025-2026 MobileGL-Dev
+// Licensed under the GNU Lesser General Public License v3.0:
+//   https://www.gnu.org/licenses/gpl-3.0.txt
+//   https://www.gnu.org/licenses/lgpl-3.0.txt
+// SPDX-License-Identifier: LGPL-3.0-only
+// End of Source File Header
+
+#include "BackendObject_DirectVulkan.h"
+#include "MG_Backend/BackendObject.h"
+#include "DirectVulkan.h"
+
+namespace MobileGL::MG_Backend::DirectVulkan {
+    BackendObject_DirectVulkan::~BackendObject_DirectVulkan() = default;
+
+    void BackendObject_DirectVulkan::InitWindowSurface() {
+        auto nativeWindow = reinterpret_cast<NativeWindowType>(m_windowHandle.Handle);
+
+        pVulkanRenderer = MakeUnique<MG_Backend::DirectVulkan::VulkanRenderer>(nativeWindow);
+        pVulkanRenderer->Initialize();
+    }
+
+    void BackendObject_DirectVulkan::Initialize() {
+        m_initialized = true;
+    }
+
+    void BackendObject_DirectVulkan::InitCapabilities() {
+        if (!m_initialized) {
+            MGLOG_E("Cannot initialize capabilities before backend is initialized");
+            return;
+        }
+
+        MG_Util::BackendLoader::FillInVulkanCapabilities(m_vulkanCaps, pVulkanRenderer->GetPhysicalDevice().properties);
+        UpdateDynamicBackendParameters();
+    }
+
+    const RendererInfo& BackendObject_DirectVulkan::GetRendererInfo() const {
+        static RendererInfo RendererInfo = {
+            .RendererName = "Magma",          // Renderer Name
+            .BackendName = "Direct (Vulkan)", // Backend Name
+            .ExtraVendor = Nullopt,           // Extra vendor
+            .RendererGLInfo =
+                {
+                    .TargetGLVersion = {3, 3, 0},                      // Target OpenGL Version
+                    .TargetGLSLVersion = {4, 6, 0},                    // Target Shading Language Version
+                    .Extensions = {V_OpenGL30, V_OpenGL31, V_OpenGL32, // OpenGL Extensions
+                                   V_OpenGL33},
+                    .IsCompatibilityProfile = false // Is Compatibility Profile
+                },
+            .StaticBackendCapability = {.AllowVSOnlyPrograms = false} // Backend Capability
+        };
+        return RendererInfo;
+    }
+
+    String BackendObject_DirectVulkan::GetBackendAPIVersionString() const {
+        if (!m_initialized) {
+            return "<uninitialized DirectVulkan backend>";
+        }
+        // Format:
+        // <GPU Name>, Vulkan <Vulkan Version>, Driver <Driver Version>
+        String str = m_vulkanCaps.DeviceName + ", Vulkan " + m_vulkanCaps.VulkanAPIVersion.toString() + ", Driver " +
+                     m_vulkanCaps.DriverVersionString;
+        return str;
+    }
+
+    BackendType BackendObject_DirectVulkan::GetBackendType() const {
+        return BackendType::DirectVulkan;
+    }
+
+    const GlobalBackendFunctionsTable& BackendObject_DirectVulkan::GetBackendFunctions() const {
+        static GlobalBackendFunctionsTable funcsTable;
+        static Bool funcsTableInitialized = false;
+        if (!funcsTableInitialized) {
+            funcsTable.Present = Present;
+            funcsTable.GL.DrawArrays = DrawArrays;
+            funcsTable.GL.DrawElements = DrawElements;
+            funcsTable.GL.DrawElementsBaseVertex = DrawElementsBaseVertex;
+            funcsTable.GL.MultiDrawElements = MultiDrawElements;
+            funcsTable.GL.MultiDrawElementsBaseVertex = MultiDrawElementsBaseVertex;
+            funcsTable.GL.MultiDrawElementsIndirect = MultiDrawElementsIndirect;
+            funcsTable.GL.MultiDrawArraysIndirect = MultiDrawArraysIndirect;
+            funcsTable.GL.DrawRangeElementsBaseVertex = DrawRangeElementsBaseVertex;
+            funcsTable.GL.DrawRangeElements = DrawRangeElements;
+            funcsTable.GL.DrawElementsInstancedBaseVertexBaseInstance = DrawElementsInstancedBaseVertexBaseInstance;
+            funcsTable.GL.DrawElementsInstancedBaseVertex = DrawElementsInstancedBaseVertex;
+            funcsTable.GL.DrawElementsInstancedBaseInstance = DrawElementsInstancedBaseInstance;
+            funcsTable.GL.DrawElementsInstanced = DrawElementsInstanced;
+            funcsTable.GL.DrawArraysInstancedBaseInstance = DrawArraysInstancedBaseInstance;
+            funcsTable.GL.DrawArraysInstanced = DrawArraysInstanced;
+            funcsTable.GL.DrawElementsIndirect = DrawElementsIndirect;
+            funcsTable.GL.DrawArraysIndirect = DrawArraysIndirect;
+            funcsTable.GL.Clear = Clear;
+            funcsTable.GL.ClearBufferfi = ClearBufferfi;
+            funcsTable.GL.ClearBufferfv = ClearBufferfv;
+            funcsTable.GL.ClearBufferuiv = ClearBufferuiv;
+            funcsTable.GL.ClearBufferiv = ClearBufferiv;
+            funcsTable.GL.BlitFramebuffer = BlitFramebuffer;
+            funcsTable.GL.CopyTexImage2D = CopyTexImage2D;
+            funcsTable.GL.CopyTexSubImage2D = CopyTexSubImage2D;
+            funcsTable.GL.GenerateMipmap = GenerateMipmap;
+            funcsTable.GL.ReadPixels = ReadPixels;
+            funcsTable.GL.GetTexImage = GetTexImage;
+            funcsTableInitialized = true;
+        }
+        return funcsTable;
+    }
+
+    const DynamicBackendParameters& BackendObject_DirectVulkan::GetDynamicParameters() const {
+        return m_dynamicParameters;
+    }
+
+    void BackendObject_DirectVulkan::UpdateDynamicBackendParameters() {
+        m_dynamicParameters.UniformBufferOffsetAlignment = m_vulkanCaps.UniformBufferOffsetAlignment;
+    }
+} // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/BackendObject_DirectVulkan.h

@@ -0,0 +1,36 @@
+// MobileGL - MobileGL/MG_Backend/DirectVulkan/BackendObject_DirectVulkan.h
+// Copyright (c) 2025-2026 MobileGL-Dev
+// Licensed under the GNU Lesser General Public License v3.0:
+//   https://www.gnu.org/licenses/gpl-3.0.txt
+//   https://www.gnu.org/licenses/lgpl-3.0.txt
+// SPDX-License-Identifier: LGPL-3.0-only
+// End of Source File Header
+
+#pragma once
+#include <Includes.h>
+#include "../BackendObject.h"
+#include <MG_Util/BackendLoaders/Vulkan/Loader.h>
+
+namespace MobileGL::MG_Backend::DirectVulkan {
+    class BackendObject_DirectVulkan : public BackendObject {
+    public:
+        ~BackendObject_DirectVulkan() override;
+
+        void Initialize() override;
+        void InitWindowSurface() override;
+        void InitCapabilities() override;
+
+        const RendererInfo& GetRendererInfo() const override;
+        String GetBackendAPIVersionString() const override;
+        const GlobalBackendFunctionsTable& GetBackendFunctions() const override;
+        const DynamicBackendParameters& GetDynamicParameters() const override;
+        BackendType GetBackendType() const override;
+
+    private:
+        void UpdateDynamicBackendParameters();
+
+        Bool m_initialized = false;
+        DynamicBackendParameters m_dynamicParameters;
+        MG_External::VulkanCapabilities m_vulkanCaps;
+    };
+} // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/DirectVulkan.cpp

@@ -13,6 +13,40 @@
 namespace MobileGL::MG_Backend::DirectVulkan {
     UniquePtr<VulkanRenderer> pVulkanRenderer = nullptr;
 
+    void ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) {}
+    void ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value) {}
+    void ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value) {}
+    void ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value) {}
+    void DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLint basevertex) {}
+    void MultiDrawElements(GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices,
+                           GLsizei drawcount) {}
+    void MultiDrawElementsBaseVertex(GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices,
+                                     GLsizei drawcount, const GLint* basevertex) {}
+    void MultiDrawElementsIndirect(GLenum mode, GLenum type, const void* indirect, GLsizei drawcount, GLsizei stride) {}
+    void MultiDrawArraysIndirect(GLenum mode, const void* indirect, GLsizei drawcount, GLsizei stride) {}
+    void DrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type,
+                                     const void* indices, GLint basevertex) {}
+    void DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void* indices) {}
+    void DrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void* indices,
+                                                     GLsizei instancecount, GLint basevertex, GLuint baseinstance) {}
+    void DrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const void* indices,
+                                         GLsizei instancecount, GLint basevertex) {}
+    void DrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const void* indices,
+                                           GLsizei instancecount, GLuint baseinstance) {}
+    void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei instancecount) {}
+    void DrawElementsIndirect(GLenum mode, GLenum type, const void* indirect) {}
+    void DrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount,
+                                         GLuint baseinstance) {}
+    void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount) {}
+    void DrawArraysIndirect(GLenum mode, const void* indirect) {}
+    void CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width,
+                        GLsizei height, GLint border) {}
+    void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width,
+                           GLsizei height) {}
+    void GenerateMipmap(GLenum target) {}
+    void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels) {}
+    void GetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid* pixels) {}
+
     void Clear(GLbitfield mask) {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::Clear called with null VulkanRenderer");
         MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::Clear called with null GL context");
@@ -85,11 +119,11 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             return;
         }
 
-        const SizeT byteOffset = reinterpret_cast<SizeT>(indices);
+        const auto byteOffset = reinterpret_cast<SizeT>(indices);
         const SizeT requiredBytes = static_cast<SizeT>(count) * indexSize;
         if (byteOffset + requiredBytes > indexBuffer->GetSize()) {
-            MGLOG_W("DrawElements skipped: index range out of bounds (offset=%zu, size=%zu, buffer=%zu)",
+            MGLOG_W("DrawElements skipped: index range out of bounds (offset=%zu, size=%zu, buffer=%zu)", byteOffset,
-                    byteOffset, requiredBytes, indexBuffer->GetSize());
+                    requiredBytes, indexBuffer->GetSize());
             return;
         }
 
@@ -170,5 +204,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         pVulkanRenderer->BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter,
                                          readFboExternalIndex, drawFboExternalIndex, readIsDefault, drawIsDefault);
     }
-} // namespace MobileGL::MG_Backend::DirectVulkan
 
+    void Present() {
+        MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::Present called with null VulkanRenderer");
+        pVulkanRenderer->Present();
+    }
+} // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/DirectVulkan.h

@@ -49,5 +49,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width,
                            GLsizei height);
     void GenerateMipmap(GLenum target);
-    const GLubyte* GetString(GLenum name);
+    void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels);
+    void GetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid* pixels);
+    void Present();
 } // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/VulkanRenderer.cpp

@@ -61,12 +61,13 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         Shutdown();
     }
 
-    VkPipeline VulkanRenderer::GetOrCreatePipeline(
+    VkPipeline VulkanRenderer::GetOrCreatePipeline(const MG_State::GLState::ProgramObject& program,
-        const MG_State::GLState::ProgramObject& program, VkPipelineLayout pipelineLayout, Uint64 vertexInputHash,
+                                                   VkPipelineLayout pipelineLayout, Uint64 vertexInputHash,
                                                    const VkPipelineVertexInputStateCreateInfo& vertexInputState) {
         MOBILEGL_ASSERT(m_pipelineFactory != nullptr, "PipelineFactory is not initialized");
         MOBILEGL_ASSERT(m_programFactory != nullptr, "ProgramFactory is not initialized");
-        auto& stages = m_programFactory->GetOrCreatePipelineShaderStages(program, ProgramFactory::CompileOptionBit::None);
+        auto& stages =
+            m_programFactory->GetOrCreatePipelineShaderStages(program, ProgramFactory::CompileOptionBit::None);
         if (stages.empty()) {
             MGLOG_D("GetOrCreatePipeline skipped: program has no shader stages");
             return VK_NULL_HANDLE;
@@ -74,34 +75,58 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         const Uint64 programHash = m_programFactory->ComputeHash(program, ProgramFactory::CompileOptionBit::None);
         auto toVkCompareOp = [](DepthTestFunc func) -> VkCompareOp {
             switch (func) {
-            case DepthTestFunc::Never: return VK_COMPARE_OP_NEVER;
+            case DepthTestFunc::Never:
-            case DepthTestFunc::Less: return VK_COMPARE_OP_LESS;
+                return VK_COMPARE_OP_NEVER;
-            case DepthTestFunc::Equal: return VK_COMPARE_OP_EQUAL;
+            case DepthTestFunc::Less:
-            case DepthTestFunc::LessEqual: return VK_COMPARE_OP_LESS_OR_EQUAL;
+                return VK_COMPARE_OP_LESS;
-            case DepthTestFunc::Greater: return VK_COMPARE_OP_GREATER;
+            case DepthTestFunc::Equal:
-            case DepthTestFunc::NotEqual: return VK_COMPARE_OP_NOT_EQUAL;
+                return VK_COMPARE_OP_EQUAL;
-            case DepthTestFunc::GreaterEqual: return VK_COMPARE_OP_GREATER_OR_EQUAL;
+            case DepthTestFunc::LessEqual:
-            case DepthTestFunc::Always: return VK_COMPARE_OP_ALWAYS;
+                return VK_COMPARE_OP_LESS_OR_EQUAL;
-            default: return VK_COMPARE_OP_ALWAYS;
+            case DepthTestFunc::Greater:
+                return VK_COMPARE_OP_GREATER;
+            case DepthTestFunc::NotEqual:
+                return VK_COMPARE_OP_NOT_EQUAL;
+            case DepthTestFunc::GreaterEqual:
+                return VK_COMPARE_OP_GREATER_OR_EQUAL;
+            case DepthTestFunc::Always:
+                return VK_COMPARE_OP_ALWAYS;
+            default:
+                return VK_COMPARE_OP_ALWAYS;
             }
         };
         auto toVkBlendFactor = [](BlendFactor factor) -> VkBlendFactor {
             switch (factor) {
-            case BlendFactor::Zero: return VK_BLEND_FACTOR_ZERO;
+            case BlendFactor::Zero:
-            case BlendFactor::One: return VK_BLEND_FACTOR_ONE;
+                return VK_BLEND_FACTOR_ZERO;
-            case BlendFactor::SrcColor: return VK_BLEND_FACTOR_SRC_COLOR;
+            case BlendFactor::One:
-            case BlendFactor::OneMinusSrcColor: return VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR;
+                return VK_BLEND_FACTOR_ONE;
-            case BlendFactor::DstColor: return VK_BLEND_FACTOR_DST_COLOR;
+            case BlendFactor::SrcColor:
-            case BlendFactor::OneMinusDstColor: return VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR;
+                return VK_BLEND_FACTOR_SRC_COLOR;
-            case BlendFactor::SrcAlpha: return VK_BLEND_FACTOR_SRC_ALPHA;
+            case BlendFactor::OneMinusSrcColor:
-            case BlendFactor::OneMinusSrcAlpha: return VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
+                return VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR;
-            case BlendFactor::DstAlpha: return VK_BLEND_FACTOR_DST_ALPHA;
+            case BlendFactor::DstColor:
-            case BlendFactor::OneMinusDstAlpha: return VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA;
+                return VK_BLEND_FACTOR_DST_COLOR;
-            case BlendFactor::ConstantColor: return VK_BLEND_FACTOR_CONSTANT_COLOR;
+            case BlendFactor::OneMinusDstColor:
-            case BlendFactor::OneMinusConstantColor: return VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR;
+                return VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR;
-            case BlendFactor::ConstantAlpha: return VK_BLEND_FACTOR_CONSTANT_ALPHA;
+            case BlendFactor::SrcAlpha:
-            case BlendFactor::OneMinusConstantAlpha: return VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA;
+                return VK_BLEND_FACTOR_SRC_ALPHA;
-            default: return VK_BLEND_FACTOR_ONE;
+            case BlendFactor::OneMinusSrcAlpha:
+                return VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
+            case BlendFactor::DstAlpha:
+                return VK_BLEND_FACTOR_DST_ALPHA;
+            case BlendFactor::OneMinusDstAlpha:
+                return VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA;
+            case BlendFactor::ConstantColor:
+                return VK_BLEND_FACTOR_CONSTANT_COLOR;
+            case BlendFactor::OneMinusConstantColor:
+                return VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR;
+            case BlendFactor::ConstantAlpha:
+                return VK_BLEND_FACTOR_CONSTANT_ALPHA;
+            case BlendFactor::OneMinusConstantAlpha:
+                return VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA;
+            default:
+                return VK_BLEND_FACTOR_ONE;
             }
         };
 
@@ -153,8 +178,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     void VulkanRenderer::CreateFrameContexts() {
         VK_VERIFY(m_frameContext.Initialize(m_device, m_commandPool, m_config.MaxFramesInFlight),
                   "CreateFrameContexts");
-        VK_VERIFY(m_frameContext.InitializeSwapchainSemaphores(
+        VK_VERIFY(m_frameContext.InitializeSwapchainSemaphores(m_device,
-                      m_device, static_cast<Uint32>(m_swapchainObject.GetImageCount())),
+                                                               static_cast<Uint32>(m_swapchainObject.GetImageCount())),
                   "CreateFrameContexts, InitializeSwapchainSemaphores");
         MGLOG_I("CreateFrameContexts completed");
     }
@@ -186,8 +211,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         if (!m_uniformDescriptorBinder->Initialize(m_device, m_allocator,
                                                    m_physicalDevice.properties.limits.minUniformBufferOffsetAlignment,
                                                    m_config.MaxFramesInFlight, 16, 64, 4 * 1024 * 1024,
-                                                   m_textureSamplerManager.get(),
+                                                   m_textureSamplerManager.get(), m_framebufferManager.get())) {
-                                                   m_framebufferManager.get())) {
             MGLOG_E("UniformDescriptorBinder initialization failed. UBO sync on Vulkan backend is disabled.");
             m_uniformDescriptorBinder.reset();
         }
@@ -341,8 +365,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         barrier.subresourceRange.baseArrayLayer = 0;
         barrier.subresourceRange.layerCount = 1;
 
-        vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+        vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
-                             0, 0, nullptr, 0, nullptr, 1, &barrier);
+                             VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier);
         m_swapchainObject.SetImageLayout(imageIndex, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
     }
 
@@ -361,7 +385,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         vkCmdClearAttachments(commandBuffer, 1, &clearAttachment, 1, &clearRect);
     }
 
-    void VulkanRenderer::RecordDepthStencilClear(VkCommandBuffer commandBuffer, GLbitfield mask, Float depth, Uint32 stencil) {
+    void VulkanRenderer::RecordDepthStencilClear(VkCommandBuffer commandBuffer, GLbitfield mask, Float depth,
+                                                 Uint32 stencil) {
         if (m_activeDepthStencilFormat == VK_FORMAT_UNDEFINED) {
             return;
         }
@@ -404,7 +429,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         VkImageMemoryBarrier barrier{};
         barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
         barrier.srcAccessMask = 0;
-        barrier.dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
+        barrier.dstAccessMask =
+            VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
         barrier.oldLayout = oldLayout;
         barrier.newLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
         barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
@@ -420,8 +446,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         barrier.subresourceRange.layerCount = 1;
 
         vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
-                             VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
+                             VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, 0,
-                             0, 0, nullptr, 0, nullptr, 1, &barrier);
+                             0, nullptr, 0, nullptr, 1, &barrier);
         m_depthStencilImageLayouts[imageIndex] = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
     }
 
@@ -432,13 +458,15 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             return;
         }
 
-        const auto drawFbo = MG_State::pGLContext
+        const auto drawFbo =
+            MG_State::pGLContext
                 ? MG_State::pGLContext->GetFramebufferBindingSlot(FramebufferTarget::Draw).GetBoundObject()
                 : nullptr;
         const auto defaultFboInfo = MG_Impl::GLImpl::FramebufferImpl::pDefaultFramebufferInfo;
         const auto defaultFbo = defaultFboInfo ? defaultFboInfo->defaultFBO : nullptr;
         const Bool drawTargetsDefault = (drawFbo == defaultFbo) || (drawFbo == nullptr && defaultFbo != nullptr);
-        const Uint drawFboExternalIndex = drawFbo ? drawFbo->GetExternalIndex() : (defaultFbo ? defaultFbo->GetExternalIndex() : 0U);
+        const Uint drawFboExternalIndex =
+            drawFbo ? drawFbo->GetExternalIndex() : (defaultFbo ? defaultFbo->GetExternalIndex() : 0U);
         const Uint64 drawTargetKey = BuildPendingClearKey(drawFboExternalIndex, drawTargetsDefault);
 
         if (frame.isCommandRecording && m_isMainRenderPassActive) {
@@ -502,8 +530,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 presentBarrier.subresourceRange.levelCount = 1;
                 presentBarrier.subresourceRange.baseArrayLayer = 0;
                 presentBarrier.subresourceRange.layerCount = 1;
-                vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
+                vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
-                                     0, 0, nullptr, 0, nullptr, 1, &presentBarrier);
+                                     VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, nullptr, 0, nullptr, 1,
+                                     &presentBarrier);
                 m_swapchainObject.SetImageLayout(m_imageIndexAcquired, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR);
             }
 
@@ -667,8 +696,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     }
 
     Bool VulkanRenderer::UploadAndBindVertexStreams(
-        const VertexInputStateFactory::BackendVertexInputState& vertexInputState,
+        const VertexInputStateFactory::BackendVertexInputState& vertexInputState, const DrawArrayPayload& payload,
-        const DrawArrayPayload& payload,
         VkCommandBuffer commandBuffer) {
         if (vertexInputState.bindings.empty()) {
             return true;
@@ -783,8 +811,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             }
         }
 
-        VkPipeline pipelineToBind = GetOrCreatePipeline(*payload.program, pipelineLayoutToUse, vertexInputHash,
+        VkPipeline pipelineToBind =
-                                                        *vertexInputInfo);
+            GetOrCreatePipeline(*payload.program, pipelineLayoutToUse, vertexInputHash, *vertexInputInfo);
         if (pipelineToBind == VK_NULL_HANDLE) {
             MGLOG_D("DrawArrays skipped: failed to create/get pipeline");
             return;
@@ -898,8 +926,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             }
         }
 
-        VkPipeline pipelineToBind = GetOrCreatePipeline(*payload.drawArray.program, pipelineLayoutToUse, vertexInputHash,
+        VkPipeline pipelineToBind =
-                                                        *vertexInputInfo);
+            GetOrCreatePipeline(*payload.drawArray.program, pipelineLayoutToUse, vertexInputHash, *vertexInputInfo);
         if (pipelineToBind == VK_NULL_HANDLE) {
             MGLOG_D("DrawElements skipped: failed to create/get pipeline");
             return;
@@ -927,9 +955,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         const auto activeExtent = m_activeRenderExtent;
 
         vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineToBind);
-        if (m_uniformDescriptorBinder &&
+        if (m_uniformDescriptorBinder && !m_uniformDescriptorBinder->BindProgramUniformBuffers(
-            !m_uniformDescriptorBinder->BindProgramUniformBuffers(commandBuffer, pipelineLayoutToUse,
+                                             commandBuffer, pipelineLayoutToUse, *payload.drawArray.program,
-                                                                  *payload.drawArray.program,
                                              m_frameContext.GetCurrentFrameIndex())) {
             MGLOG_D("DrawElements skipped: failed to bind uniform descriptors");
             return;
@@ -1044,8 +1071,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             toTransferDstBarrier.subresourceRange.levelCount = 1;
             toTransferDstBarrier.subresourceRange.baseArrayLayer = 0;
             toTransferDstBarrier.subresourceRange.layerCount = 1;
-            vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
+            vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0,
-                                 0, 0, nullptr, 0, nullptr, 1, &toTransferDstBarrier);
+                                 nullptr, 0, nullptr, 1, &toTransferDstBarrier);
             m_swapchainObject.SetImageLayout(m_imageIndexAcquired, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
         }
 
@@ -1064,8 +1091,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         blitRegion.dstOffsets[1] = {dstX1, dstY1, 1};
 
         vkCmdBlitImage(commandBuffer, srcImage, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
-                       m_swapchainObject.GetImage(m_imageIndexAcquired), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+                       m_swapchainObject.GetImage(m_imageIndexAcquired), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1,
-                       1, &blitRegion, (filter == GL_LINEAR ? VK_FILTER_LINEAR : VK_FILTER_NEAREST));
+                       &blitRegion, (filter == GL_LINEAR ? VK_FILTER_LINEAR : VK_FILTER_NEAREST));
 
         VkImageMemoryBarrier toPresentBarrier{};
         toPresentBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
@@ -1081,8 +1108,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         toPresentBarrier.subresourceRange.levelCount = 1;
         toPresentBarrier.subresourceRange.baseArrayLayer = 0;
         toPresentBarrier.subresourceRange.layerCount = 1;
-        vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
+        vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0,
-                             0, 0, nullptr, 0, nullptr, 1, &toPresentBarrier);
+                             nullptr, 0, nullptr, 1, &toPresentBarrier);
         m_swapchainObject.SetImageLayout(m_imageIndexAcquired, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR);
 
         (void)srcExtent;
@@ -1115,9 +1142,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             m_pendingClears.clear();
         } else if (!m_pendingClears.empty()) {
             auto activateTarget = [&](Bool targetIsDefault, Uint targetFboExternalIndex) -> Bool {
-                const Bool alreadyMatched =
+                const Bool alreadyMatched = frame.isCommandRecording && m_isMainRenderPassActive &&
-                    frame.isCommandRecording &&
-                    m_isMainRenderPassActive &&
                                             (targetIsDefault == m_activeRenderTargetIsDefault) &&
                                             (targetIsDefault || targetFboExternalIndex == m_activeDrawFboExternalIndex);
                 if (alreadyMatched) {
@@ -1179,7 +1204,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 if (!m_framebufferManager->EnsureOffscreenColorTarget(targetFboExternalIndex, *pendingFbo)) {
                     return false;
                 }
-                if (!m_framebufferManager->TransitionOffscreenColorToAttachment(commandBuffer, targetFboExternalIndex)) {
+                if (!m_framebufferManager->TransitionOffscreenColorToAttachment(commandBuffer,
+                                                                                targetFboExternalIndex)) {
                     return false;
                 }
 
@@ -1211,8 +1237,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                     presentBarrier.subresourceRange.baseArrayLayer = 0;
                     presentBarrier.subresourceRange.layerCount = 1;
                     vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
-                                         VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
+                                         VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, nullptr, 0, nullptr, 1,
-                                         0, 0, nullptr, 0, nullptr, 1, &presentBarrier);
+                                         &presentBarrier);
                     m_swapchainObject.SetImageLayout(m_imageIndexAcquired, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR);
                 }
 
@@ -1706,11 +1732,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     }
 
     VkFormat VulkanRenderer::FindSupportedDepthStencilFormat(VkPhysicalDevice physicalDevice) {
-        const VkFormat candidates[] = {
+        const VkFormat candidates[] = {VK_FORMAT_D24_UNORM_S8_UINT, VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_D32_SFLOAT};
-            VK_FORMAT_D24_UNORM_S8_UINT,
-            VK_FORMAT_D32_SFLOAT_S8_UINT,
-            VK_FORMAT_D32_SFLOAT
-        };
         for (VkFormat format : candidates) {
             VkFormatProperties props{};
             vkGetPhysicalDeviceFormatProperties(physicalDevice, format, &props);
@@ -1759,9 +1781,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             VkMemoryAllocateInfo allocInfo{};
             allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
             allocInfo.allocationSize = memRequirements.size;
-            allocInfo.memoryTypeIndex = FindMemoryType(memRequirements.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+            allocInfo.memoryTypeIndex =
-            VK_VERIFY(vkAllocateMemory(m_device, &allocInfo, nullptr, &m_depthStencilImageMemories[i]), "vkAllocateMemory(depth)");
+                FindMemoryType(memRequirements.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
-            VK_VERIFY(vkBindImageMemory(m_device, m_depthStencilImages[i], m_depthStencilImageMemories[i], 0), "vkBindImageMemory(depth)");
+            VK_VERIFY(vkAllocateMemory(m_device, &allocInfo, nullptr, &m_depthStencilImageMemories[i]),
+                      "vkAllocateMemory(depth)");
+            VK_VERIFY(vkBindImageMemory(m_device, m_depthStencilImages[i], m_depthStencilImageMemories[i], 0),
+                      "vkBindImageMemory(depth)");
 
             VkImageViewCreateInfo viewInfo{};
             viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
@@ -1776,7 +1801,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             viewInfo.subresourceRange.levelCount = 1;
             viewInfo.subresourceRange.baseArrayLayer = 0;
             viewInfo.subresourceRange.layerCount = 1;
-            VK_VERIFY(vkCreateImageView(m_device, &viewInfo, nullptr, &m_depthStencilImageViews[i]), "vkCreateImageView(depth)");
+            VK_VERIFY(vkCreateImageView(m_device, &viewInfo, nullptr, &m_depthStencilImageViews[i]),
+                      "vkCreateImageView(depth)");
         }
     }
 
@@ -1994,7 +2020,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
     void VulkanRenderer::RecreateSwapchain() {
         // Handle cases like minimize on Windows, where swapchain could return a 0x0 extent
-        const auto swapchainCapabilities = SwapchainObject::GetSwapchainCapabilities(m_physicalDevice.handle, m_surface);
+        const auto swapchainCapabilities =
+            SwapchainObject::GetSwapchainCapabilities(m_physicalDevice.handle, m_surface);
         if (swapchainCapabilities.capabilities.currentExtent.width == 0 ||
             swapchainCapabilities.capabilities.currentExtent.height == 0) {
             return;
@@ -2005,8 +2032,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         ShutdownSwapchain();
 
         CreateSwapchain();
-        VK_VERIFY(m_frameContext.InitializeSwapchainSemaphores(
+        VK_VERIFY(m_frameContext.InitializeSwapchainSemaphores(m_device,
-                      m_device, static_cast<Uint32>(m_swapchainObject.GetImageCount())),
+                                                               static_cast<Uint32>(m_swapchainObject.GetImageCount())),
                   "RecreateSwapchain, InitializeSwapchainSemaphores");
         CreateDepthStencilResources();
         CreateDefaultRenderPass();
@@ -2033,4 +2060,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         m_pendingClears.clear();
     }
 
+    const PhysicalDevice& VulkanRenderer::GetPhysicalDevice() const {
+        return m_physicalDevice;
+    }
 } // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/VulkanRenderer.h

@@ -26,7 +26,7 @@
 namespace MobileGL::MG_State::GLState {
     class ProgramObject;
     class VertexArrayObject;
-}
+} // namespace MobileGL::MG_State::GLState
 
 namespace MobileGL::MG_Backend::DirectVulkan {
     struct DrawArrayPayload {
@@ -43,6 +43,21 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         SizeT indexByteOffset = 0;
     };
 
+    struct QueueFamilyIndices {
+        Int32 graphicsFamily = -1;
+        Int32 presentFamily = -1;
+    };
+
+    struct PhysicalDevice {
+        QueueFamilyIndices queueFamilies;
+        VkPhysicalDeviceProperties properties;
+        VkPhysicalDevice handle = VK_NULL_HANDLE;
+
+        Bool IsComplete() const {
+            return handle != VK_NULL_HANDLE && queueFamilies.graphicsFamily != -1 && queueFamilies.presentFamily != -1;
+        }
+    };
+
     class VulkanRenderer {
     public:
         VulkanRenderer(NativeWindowType window, const VulkanRendererConfig& cfg = {});
@@ -63,6 +78,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         void Render();
         void Present();
 
+        const PhysicalDevice& GetPhysicalDevice() const;
+
         void RecreateSwapchain();
 
     private:
@@ -75,23 +92,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             Bool targetsDefaultFramebuffer = true;
         };
 
-        struct QueueFamilyIndices {
-            Int32 graphicsFamily = -1;
-            Int32 presentFamily = -1;
-        };
-
-        struct PhysicalDevice {
-            QueueFamilyIndices queueFamilies;
-            VkPhysicalDeviceProperties properties;
-            VkPhysicalDevice handle = VK_NULL_HANDLE;
-
-            Bool IsComplete() const {
-                return handle != VK_NULL_HANDLE &&
-                    queueFamilies.graphicsFamily != -1 &&
-                    queueFamilies.presentFamily != -1;
-            }
-        };
-
         NativeWindowType m_window = 0;
         VulkanRendererConfig m_config;
 
@@ -178,39 +178,31 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         void CollectDeferredBufferReleases(Uint32 frameIndex);
         Bool EnsureFrameUploadBufferCapacity(Uint32 frameIndex, Bool isIndexBuffer, VkDeviceSize requiredEndOffset,
                                              VkDeviceSize minCapacity, VkBufferUsageFlags usage);
-        Bool UploadAndBindVertexStreams(
+        Bool UploadAndBindVertexStreams(const VertexInputStateFactory::BackendVertexInputState& vertexInputState,
-            const VertexInputStateFactory::BackendVertexInputState& vertexInputState,
+                                        const DrawArrayPayload& payload, VkCommandBuffer commandBuffer);
-            const DrawArrayPayload& payload,
-            VkCommandBuffer commandBuffer);
 
         void ShutdownSwapchain();
 
-        static Int GetPresentQueueFamilyIndex(
+        static Int GetPresentQueueFamilyIndex(const PhysicalDevice& physicalDevice, VkSurfaceKHR surface,
-            const PhysicalDevice& physicalDevice, VkSurfaceKHR surface,
+                                              const Vector<VkQueueFamilyProperties>& queueFamilies,
-            const Vector<VkQueueFamilyProperties>& queueFamilies, Int preferredFamilyIndex = -1);
+                                              Int preferredFamilyIndex = -1);
         static Vector<VkQueueFamilyProperties> GetQueueFamilyFromPhysicalDevice(VkPhysicalDevice device);
         static Int GetQueueFamilyIndex(const Vector<VkQueueFamilyProperties>& queueFamilies, VkQueueFlagBits flag);
         static Vector<VkExtensionProperties> EnumerateInstanceExtensions();
         static Bool IsNecessaryDeviceExtensionSupported(VkPhysicalDevice device);
-        static Bool GetMoreCapablePhysicalDevice(VkPhysicalDevice newVkDevice, VkSurfaceKHR surface, const PhysicalDevice& compareWithDevice, PhysicalDevice& outBetterDevice);
+        static Bool GetMoreCapablePhysicalDevice(VkPhysicalDevice newVkDevice, VkSurfaceKHR surface,
+                                                 const PhysicalDevice& compareWithDevice,
+                                                 PhysicalDevice& outBetterDevice);
         Uint32 FindMemoryType(Uint32 typeFilter, VkMemoryPropertyFlags properties) const;
         static Uint64 BuildPendingClearKey(Uint drawFboExternalIndex, Bool targetsDefaultFramebuffer);
         static Bool HasStencilComponent(VkFormat format);
         static VkFormat FindSupportedDepthStencilFormat(VkPhysicalDevice physicalDevice);
-        static constexpr VkDynamicState s_dynamicStates[] = {
+        static constexpr VkDynamicState s_dynamicStates[] = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR};
-            VK_DYNAMIC_STATE_VIEWPORT,
+        static constexpr const char* s_validationLayerNames[] = {"VK_LAYER_KHRONOS_validation"};
-            VK_DYNAMIC_STATE_SCISSOR
+        static constexpr const char* s_deviceExtensionNames[] = {VK_KHR_SWAPCHAIN_EXTENSION_NAME};
-        };
-        static constexpr const char* s_validationLayerNames[] = {
-            "VK_LAYER_KHRONOS_validation"
-        };
-        static constexpr const char* s_deviceExtensionNames[] = {
-            VK_KHR_SWAPCHAIN_EXTENSION_NAME
-        };
         static Bool CheckValidationLayerSupport();
 
-        static VKAPI_ATTR VkBool32 VKAPI_CALL DebugCallback(
+        static VKAPI_ATTR VkBool32 VKAPI_CALL DebugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
-            VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
                                                             VkDebugUtilsMessageTypeFlagsEXT messageType,
                                                             const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
                                                             void* pUserData);

MobileGL/MG_Backend/Init.cpp

@@ -6,89 +6,60 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 // End of Source File Header
 
-#include "Backends.h"
+#include "BackendObjects.h"
-#include "MG_Util/Debug/Log.h"
-#include "MG_Util/Types.h"
 #include <Config.h>
 #include <MG_Util/BackendLoaders/OpenGL/Loader.h>
 #include <MG_Util/Converters/MGToStr/GLExtensionConverter.h>
 
-namespace MobileGL {
+namespace MobileGL::MG_Backend {
-    namespace MG_Config {
-        UniquePtr<RendererInfo> RendererInfoPtr = nullptr;
-    } // namespace MG_Config
-
-    namespace MG_Backend {
     void LogBackendInfo() {
-            if (MG_Config::RendererInfoPtr) {
+        if (!pActiveBackendObject) {
+            MGLOG_W("No active backend object, cannot log backend info");
+            return;
+        }
+
+        const auto& rendererInfo = pActiveBackendObject->GetRendererInfo();
         MGLOG_I("MobileGL Backend Info:");
-                MGLOG_I("  Renderer Name: %s", MG_Config::RendererInfoPtr->RendererName.c_str());
+        MGLOG_I("  Renderer Name: %s", rendererInfo.RendererName.c_str());
-                MGLOG_I("  Backend Name: %s", MG_Config::RendererInfoPtr->BackendName.c_str());
+        MGLOG_I("  Backend Name: %s", rendererInfo.BackendName.c_str());
-                if (MG_Config::RendererInfoPtr->ExtraVendor) {
+        if (rendererInfo.ExtraVendor) {
-                    MGLOG_I("  Extra Vendor Info: %s", MG_Config::RendererInfoPtr->ExtraVendor->c_str());
+            MGLOG_I("  Extra Vendor Info: %s", rendererInfo.ExtraVendor->c_str());
         }
-                MGLOG_I("  Target OpenGL Version: %d.%d",
+        MGLOG_I("  Target OpenGL Version: %d.%d", rendererInfo.RendererGLInfo.TargetGLVersion.Major,
-                        MG_Config::RendererInfoPtr->RendererGLInfo.TargetGLVersion.Major,
+                rendererInfo.RendererGLInfo.TargetGLVersion.Minor);
-                        MG_Config::RendererInfoPtr->RendererGLInfo.TargetGLVersion.Minor);
+        MGLOG_I("  Target GLSL Version: %d.%d", rendererInfo.RendererGLInfo.TargetGLSLVersion.Major,
-                MGLOG_I("  Target GLSL Version: %d.%d",
+                rendererInfo.RendererGLInfo.TargetGLSLVersion.Minor);
-                        MG_Config::RendererInfoPtr->RendererGLInfo.TargetGLSLVersion.Major,
-                        MG_Config::RendererInfoPtr->RendererGLInfo.TargetGLSLVersion.Minor);
         MGLOG_I("  OpenGL Extensions:");
-                for (const auto& ext : MG_Config::RendererInfoPtr->RendererGLInfo.Extensions) {
+        for (const auto& ext : rendererInfo.RendererGLInfo.Extensions) {
             MGLOG_I("    - %s", MG_Util::ConvertGLExtToString(ext).c_str());
         }
-            } else {
-                MGLOG_W("  No renderer info available");
-            }
     }
 
     Bool InitSpecificBackendLibs() {
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_DILIGENT
+        if (!pActiveBackendObject) {
-            // Nothing to do
+            MGLOG_W("No active backend object, cannot initialize backend libraries");
-            MGLOG_D("Diligent Engine backend loaded");
-            return true;
-#elif MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
-            Bool result = MG_Util::BackendLoader::GLES::Init();
-            MGLOG_D("DirectGLES backend loaded, GLES version: %d.%d", MG_External::GLES::g_glesCaps.version.Major,
-                    MG_External::GLES::g_glesCaps.version.Minor);
-            return result;
-#elif MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_VULKAN
-#ifdef __ANDROID__
-            MGLOG_D("DirectVulkan backend loaded on Android");
-            return true;
-#else
-            MGLOG_E("TODO: add Vulkan loader for non-Android platforms"); // TODO: add Vulkan loader for non-Android
-                                                                          // platforms
             return false;
-#endif
+        }
-
+        pActiveBackendObject->Initialize();
-#else
+        gBackendFunctionsTable = pActiveBackendObject->GetBackendFunctions();
-            MGLOG_W("Unknown backend, skipping backend initialization");
+        return true;
-            return false;
-#endif
     }
 
     void Init() {
         MGLOG_D("Initializing MobileGL Backend...");
 
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_DILIGENT
+        switch (MG_Config::ActiveBackendType) {
-            switch (MG_Config::Backend::Diligent::SpecificBackend) {
+        case BackendType::DirectGLES:
-            case MG_Backend::Diligent::SpecificBackendType::Vulkan:
+            pActiveBackendObject = MakeUnique<DirectGLES::BackendObject_DirectGLES>();
-                MG_Config::RendererInfoPtr = MakeUnique<RendererInfo>(Diligent::RendererInfoVulkan);
             break;
-            case MG_Backend::Diligent::SpecificBackendType::Metal:
+        case BackendType::DirectVulkan:
-                MG_Config::RendererInfoPtr = MakeUnique<RendererInfo>(Diligent::RendererInfoMetal);
+            pActiveBackendObject = MakeUnique<DirectVulkan::BackendObject_DirectVulkan>();
             break;
+        case BackendType::Unknown:
         default:
-                throw RuntimeError("Unsupported renderer type");
+            MGLOG_W("Unknown backend type, defaulting to unknown backend");
+            pActiveBackendObject = nullptr;
         }
-#elif MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
-            MG_Config::RendererInfoPtr = MakeUnique<RendererInfo>(DirectGLES::RendererInfo);
-#elif MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_VULKAN
-            MG_Config::RendererInfoPtr = MakeUnique<RendererInfo>(DirectVulkan::RendererInfo);
-#else
-            MG_Config::RendererInfoPtr = MakeUnique<RendererInfo>(Unknown::RendererInfoUnknown);
-#endif
 
         Bool result = InitSpecificBackendLibs();
         if (!result) {
@@ -97,5 +68,4 @@ namespace MobileGL {
         }
         LogBackendInfo();
     }
-    } // namespace MG_Backend
+} // namespace MobileGL::MG_Backend
-} // namespace MobileGL

MobileGL/MG_Impl/EGLImpl/EGLForVulkan/EGLForVulkan.cpp

@@ -1,254 +0,0 @@
-// MobileGL - MobileGL/MG_Impl/EGLImpl/EGLForVulkan/EGLForVulkan.cpp
-// Copyright (c) 2025-2026 MobileGL-Dev
-// Licensed under the GNU Lesser General Public License v3.0:
-//   https://www.gnu.org/licenses/gpl-3.0.txt
-//   https://www.gnu.org/licenses/lgpl-3.0.txt
-// SPDX-License-Identifier: LGPL-3.0-only
-// End of Source File Header
-
-#include "EGLForVulkan.h"
-#include "MG_Backend/DirectVulkan/DirectVulkan.h"
-#include <Config.h>
-#include <MG_State/GLState/ProgramState/ProgramObject.h>
-
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_VULKAN
-namespace MobileGL {
-    namespace MG_Impl::EGLImpl {
-        // TODO: complete EGL impl for Vulkan
-        void CreateWindowSurfaceForVulkan(NativeWindowType window) {
-            MG_Backend::DirectVulkan::pVulkanRenderer = MakeUnique<MG_Backend::DirectVulkan::VulkanRenderer>(window);
-            MG_Backend::DirectVulkan::pVulkanRenderer->Initialize();
-        }
-
-        EGLSurface CreateWindowSurface(EGLDisplay dpy, EGLConfig config, NativeWindowType window,
-                                       const EGLint* attrib_list) {
-            MGLOG_D("EGLForVulkan::CreateWindowSurface called with window=%p", window);
-            CreateWindowSurfaceForVulkan(window);
-            return (EGLSurface)1;
-        }
-
-        EGLBoolean SwapBuffers(EGLDisplay dpy, EGLSurface draw) {
-            if (!MG_Backend::DirectVulkan::pVulkanRenderer) {
-                MGLOG_E("EGLForVulkan::SwapBuffers called but VulkanRenderer is null");
-                return EGL_FALSE;
-            }
-            MG_Backend::DirectVulkan::pVulkanRenderer->Present();
-            return EGL_TRUE;
-        }
-
-        EGLBoolean ChooseConfig(EGLDisplay dpy, const EGLint* attrib_list, EGLConfig* configs, EGLint config_size,
-                                EGLint* num_config) {
-            *num_config = 1;
-            return EGL_TRUE;
-        }
-
-        EGLContext CreateContext(EGLDisplay dpy, EGLConfig config, EGLContext shareCtx, const EGLint* attrib_list) {
-            return (EGLContext)1;
-        }
-
-        EGLBoolean Initialize(EGLDisplay dpy, EGLint* major, EGLint* minor) {
-            if (major) *major = 1;
-            if (minor) *minor = 5;
-            return EGL_TRUE;
-        }
-
-        EGLDisplay GetDisplay(NativeDisplayType display) {
-            return (EGLDisplay)1;
-        }
-
-        EGLint GetError() {
-            return EGL_SUCCESS;
-        }
-
-        EGLBoolean MakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx) {
-            return EGL_TRUE;
-        }
-
-        EGLBoolean DestroyContext(EGLDisplay dpy, EGLContext ctx) {
-            return EGL_TRUE;
-        }
-
-        EGLBoolean DestroySurface(EGLDisplay dpy, EGLSurface surface) {
-            return EGL_TRUE;
-        }
-
-        EGLBoolean Terminate(EGLDisplay dpy) {
-            return EGL_TRUE;
-        }
-
-        EGLBoolean ReleaseThread(void) {
-            return EGL_TRUE;
-        }
-
-        EGLContext GetCurrentContext(void) {
-            return (EGLContext)1;
-        }
-
-        EGLBoolean GetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint* value) {
-            if (attribute == EGL_NATIVE_VISUAL_ID) {
-#if defined(ANDROID)
-                *value = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
-                return EGL_TRUE;
-#elif defined(__linux__)
-                *value = 0;
-                return EGL_TRUE;
-#elif defined(_WIN32)
-                *value = 0;
-                return EGL_TRUE;
-#else
-                *value = 0;
-                return EGL_FALSE;
-#endif
-            }
-            return EGL_TRUE;
-        }
-
-        EGLBoolean BindAPI(EGLenum api) {
-            return EGL_TRUE;
-        }
-
-        EGLSurface GetCurrentSurface(EGLint readdraw) {
-            return (EGLSurface)1;
-        }
-
-        EGLBoolean QuerySurface(EGLDisplay display, EGLSurface surface, EGLint attribute, EGLint* value) {
-            return EGL_TRUE;
-        }
-
-        char const* QueryString(EGLDisplay display, EGLint name) {
-            return "";
-        }
-
-        EGLBoolean SwapInterval(EGLDisplay dpy, EGLint interval) {
-            return EGL_TRUE;
-        }
-
-        EGLSurface CreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint* attrib_list) {
-            return (EGLSurface)1;
-        }
-
-        EGLBoolean BindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) {
-            return EGL_TRUE;
-        }
-
-        EGLBoolean ReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) {
-            return EGL_TRUE;
-        }
-
-        EGLBoolean CopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target) {
-            return EGL_TRUE;
-        }
-
-        EGLSurface CreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer,
-                                                 EGLConfig config, const EGLint* attrib_list) {
-            return (EGLSurface)1;
-        }
-
-        EGLSurface CreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap,
-                                       const EGLint* attrib_list) {
-            return (EGLSurface)1;
-        }
-
-        EGLBoolean GetConfigs(EGLDisplay dpy, EGLConfig* configs, EGLint config_size, EGLint* num_config) {
-            if (num_config) {
-                *num_config = 1;
-            }
-            if (configs && config_size > 0) {
-                configs[0] = (EGLConfig)1;
-            }
-            return EGL_TRUE;
-        }
-
-        EGLDisplay GetCurrentDisplay(void) {
-            return (EGLDisplay)1;
-        }
-
-        EGLenum QueryAPI(void) {
-            return EGL_OPENGL_API;
-        }
-
-        EGLBoolean QueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint* value) {
-            if (value) {
-                *value = 0;
-            }
-            return EGL_TRUE;
-        }
-
-        EGLBoolean SurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value) {
-            return EGL_TRUE;
-        }
-
-        EGLBoolean WaitClient(void) {
-            return EGL_TRUE;
-        }
-
-        EGLBoolean WaitGL(void) {
-            return EGL_TRUE;
-        }
-
-        EGLBoolean WaitNative(EGLint engine) {
-            return EGL_TRUE;
-        }
-
-        EGLSync CreateSync(EGLDisplay dpy, EGLenum type, const EGLAttrib* attrib_list) {
-            return reinterpret_cast<EGLSync>(0x1);
-        }
-
-        EGLBoolean DestroySync(void* dpy, void* sync) {
-            return EGL_TRUE;
-        }
-
-        EGLint ClientWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout) {
-            return EGL_CONDITION_SATISFIED;
-        }
-
-        EGLBoolean GetSyncAttrib(EGLDisplay dpy, EGLSync sync, EGLint attribute, EGLAttrib* value) {
-            if (value) {
-                *value = 0;
-            }
-            return EGL_TRUE;
-        }
-
-        EGLImage CreateImage(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer,
-                             const EGLAttrib* attrib_list) {
-            return reinterpret_cast<EGLImage>(0x1);
-        }
-
-        EGLBoolean DestroyImage(EGLDisplay dpy, EGLImage image) {
-            return EGL_TRUE;
-        }
-
-        EGLDisplay GetPlatformDisplay(EGLenum platform, void* native_display, const EGLAttrib* attrib_list) {
-            return reinterpret_cast<EGLDisplay>(0x1);
-        }
-
-        EGLSurface CreatePlatformWindowSurface(EGLDisplay dpy, EGLConfig config, void* native_window,
-                                               const EGLAttrib* attrib_list) {
-            return reinterpret_cast<EGLSurface>(0x1);
-        }
-
-        EGLSurface CreatePlatformPixmapSurface(EGLDisplay dpy, EGLConfig config, void* native_pixmap,
-                                               const EGLAttrib* attrib_list) {
-            return reinterpret_cast<EGLSurface>(0x1);
-        }
-
-        EGLBoolean WaitSync(void* dpy, void* sync, int flags) {
-            return EGL_TRUE;
-        }
-
-        __eglMustCastToProperFunctionPointerType GetProcAddress(const char* name) {
-            MGLOG_D("eglGetProcAddress(%s)", name);
-#if !defined(WIN32) && !defined(__APPLE__)
-            void* proc = dlsym(RTLD_DEFAULT, (const char*)name);
-#else
-            void* proc = NULL;
-#endif
-            if (!proc) {
-                MGLOG_W("Failed to get function: %s", (const char*)name);
-                return nullptr;
-            }
-            return (__eglMustCastToProperFunctionPointerType)proc;
-        }
-    } // namespace MG_Impl::EGLImpl
-} // namespace MobileGL
-#endif

MobileGL/MG_Impl/EGLImpl/EGLForVulkan/EGLForVulkan.h

@@ -1,10 +0,0 @@
-// MobileGL - MobileGL/MG_Impl/EGLImpl/EGLForVulkan/EGLForVulkan.h
-// Copyright (c) 2025-2026 MobileGL-Dev
-// Licensed under the GNU Lesser General Public License v3.0:
-//   https://www.gnu.org/licenses/gpl-3.0.txt
-//   https://www.gnu.org/licenses/lgpl-3.0.txt
-// SPDX-License-Identifier: LGPL-3.0-only
-// End of Source File Header
-
-#pragma once
-#include <Includes.h>

MobileGL/MG_Impl/EGLImpl/EGLImpl.cpp

@@ -0,0 +1,252 @@
+// MobileGL - MobileGL/MG_Impl/EGLImpl/EGLImpl.cpp
+// Copyright (c) 2025-2026 MobileGL-Dev
+// Licensed under the GNU Lesser General Public License v3.0:
+//   https://www.gnu.org/licenses/gpl-3.0.txt
+//   https://www.gnu.org/licenses/lgpl-3.0.txt
+// SPDX-License-Identifier: LGPL-3.0-only
+// End of Source File Header
+
+#include "EGLImpl.h"
+#include "../GetProcAddress.h"
+#include <MG_Backend/BackendObjects.h>
+
+namespace MobileGL::MG_Impl::EGLImpl {
+    EGLSurface CreateWindowSurface(EGLDisplay dpy, EGLConfig config, NativeWindowType window,
+                                   const EGLint* attrib_list) {
+        MGLOG_D("EGLImpl::CreateWindowSurface called with window=%p", window);
+        const auto& activeBackendObject = MG_Backend::pActiveBackendObject;
+        if (!activeBackendObject) {
+            MGLOG_E("activeBackendObject not initialized!");
+            return EGL_NO_SURFACE;
+        }
+        activeBackendObject->SetWindowHandle({MG_Backend::WindowBackend::Android, reinterpret_cast<void*>(window)});
+        activeBackendObject->InitWindowSurface();
+        return (EGLSurface)1;
+    }
+
+    EGLBoolean SwapBuffers(EGLDisplay dpy, EGLSurface draw) {
+        MGLOG_D("EGLImpl::SwapBuffers called with dpy=%p", dpy);
+        if (!MG_Backend::gBackendFunctionsTable.Present) {
+            MGLOG_E("MG_Backend::gBackendFunctionsTable.Present not initialized!");
+            return EGL_FALSE;
+        }
+        MG_Backend::gBackendFunctionsTable.Present();
+        return EGL_TRUE;
+    }
+
+    EGLBoolean ChooseConfig(EGLDisplay dpy, const EGLint* attrib_list, EGLConfig* configs, EGLint config_size,
+                            EGLint* num_config) {
+        *num_config = 1;
+        return EGL_TRUE;
+    }
+
+    EGLContext CreateContext(EGLDisplay dpy, EGLConfig config, EGLContext shareCtx, const EGLint* attrib_list) {
+        return (EGLContext)1;
+    }
+
+    EGLBoolean Initialize(EGLDisplay dpy, EGLint* major, EGLint* minor) {
+        if (major) *major = 1;
+        if (minor) *minor = 5;
+        return EGL_TRUE;
+    }
+
+    EGLDisplay GetDisplay(NativeDisplayType display) {
+        return (EGLDisplay)1;
+    }
+
+    EGLint GetError() {
+        return EGL_SUCCESS;
+    }
+
+    EGLBoolean MakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx) {
+        const auto& activeBackendObject = MG_Backend::pActiveBackendObject;
+        if (!activeBackendObject) {
+            MGLOG_E("activeBackendObject not initialized!");
+            return EGL_FALSE;
+        }
+        activeBackendObject->InitCapabilities();
+        return EGL_TRUE;
+    }
+
+    EGLBoolean DestroyContext(EGLDisplay dpy, EGLContext ctx) {
+        return EGL_TRUE;
+    }
+
+    EGLBoolean DestroySurface(EGLDisplay dpy, EGLSurface surface) {
+        return EGL_TRUE;
+    }
+
+    EGLBoolean Terminate(EGLDisplay dpy) {
+        return EGL_TRUE;
+    }
+
+    EGLBoolean ReleaseThread() {
+        return EGL_TRUE;
+    }
+
+    EGLContext GetCurrentContext() {
+        return (EGLContext)1;
+    }
+
+    EGLBoolean GetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint* value) {
+        if (attribute == EGL_NATIVE_VISUAL_ID) {
+#if defined(ANDROID)
+            *value = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
+            return EGL_TRUE;
+#elif defined(__linux__)
+            *value = 0;
+            return EGL_TRUE;
+#elif defined(_WIN32)
+            *value = 0;
+            return EGL_TRUE;
+#else
+            *value = 0;
+            return EGL_FALSE;
+#endif
+        }
+        return EGL_TRUE;
+    }
+
+    EGLBoolean BindAPI(EGLenum api) {
+        return EGL_TRUE;
+    }
+
+    EGLSurface GetCurrentSurface(EGLint readdraw) {
+        return (EGLSurface)1;
+    }
+
+    EGLBoolean QuerySurface(EGLDisplay display, EGLSurface surface, EGLint attribute, EGLint* value) {
+        return EGL_TRUE;
+    }
+
+    char const* QueryString(EGLDisplay display, EGLint name) {
+        return "";
+    }
+
+    EGLBoolean SwapInterval(EGLDisplay dpy, EGLint interval) {
+        return EGL_TRUE;
+    }
+
+    EGLSurface CreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint* attrib_list) {
+        return (EGLSurface)1;
+    }
+
+    EGLBoolean BindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) {
+        return EGL_TRUE;
+    }
+
+    EGLBoolean ReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) {
+        return EGL_TRUE;
+    }
+
+    EGLBoolean CopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target) {
+        return EGL_TRUE;
+    }
+
+    EGLSurface CreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config,
+                                             const EGLint* attrib_list) {
+        return (EGLSurface)1;
+    }
+
+    EGLSurface CreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap,
+                                   const EGLint* attrib_list) {
+        return (EGLSurface)1;
+    }
+
+    EGLBoolean GetConfigs(EGLDisplay dpy, EGLConfig* configs, EGLint config_size, EGLint* num_config) {
+        if (num_config) {
+            *num_config = 1;
+        }
+        if (configs && config_size > 0) {
+            configs[0] = (EGLConfig)1;
+        }
+        return EGL_TRUE;
+    }
+
+    EGLDisplay GetCurrentDisplay() {
+        return (EGLDisplay)1;
+    }
+
+    EGLenum QueryAPI() {
+        return EGL_OPENGL_API;
+    }
+
+    EGLBoolean QueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint* value) {
+        if (value) {
+            *value = 1;
+        }
+        return EGL_TRUE;
+    }
+
+    EGLBoolean SurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value) {
+        return EGL_TRUE;
+    }
+
+    EGLBoolean WaitClient() {
+        return EGL_TRUE;
+    }
+
+    EGLBoolean WaitGL() {
+        return EGL_TRUE;
+    }
+
+    EGLBoolean WaitNative(EGLint engine) {
+        return EGL_TRUE;
+    }
+
+    EGLSync CreateSync(EGLDisplay dpy, EGLenum type, const EGLAttrib* attrib_list) {
+        return reinterpret_cast<EGLSync>(0x1);
+    }
+
+    EGLBoolean DestroySync(void* dpy, void* sync) {
+        return EGL_TRUE;
+    }
+
+    EGLint ClientWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout) {
+        return EGL_CONDITION_SATISFIED;
+    }
+
+    EGLBoolean GetSyncAttrib(EGLDisplay dpy, EGLSync sync, EGLint attribute, EGLAttrib* value) {
+        if (value) {
+            *value = 1;
+        }
+        return EGL_TRUE;
+    }
+
+    EGLImage CreateImage(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer,
+                         const EGLAttrib* attrib_list) {
+        return reinterpret_cast<EGLImage>(0x1);
+    }
+
+    EGLBoolean DestroyImage(EGLDisplay dpy, EGLImage image) {
+        return EGL_TRUE;
+    }
+
+    EGLDisplay GetPlatformDisplay(EGLenum platform, void* native_display, const EGLAttrib* attrib_list) {
+        return reinterpret_cast<EGLDisplay>(0x1);
+    }
+
+    EGLSurface CreatePlatformWindowSurface(EGLDisplay dpy, EGLConfig config, void* native_window,
+                                           const EGLAttrib* attrib_list) {
+        return reinterpret_cast<EGLSurface>(0x1);
+    }
+
+    EGLSurface CreatePlatformPixmapSurface(EGLDisplay dpy, EGLConfig config, void* native_pixmap,
+                                           const EGLAttrib* attrib_list) {
+        return reinterpret_cast<EGLSurface>(0x1);
+    }
+
+    EGLBoolean WaitSync(void* dpy, void* sync, int flags) {
+        return EGL_TRUE;
+    }
+
+    __eglMustCastToProperFunctionPointerType GetProcAddress(const char* name) {
+        MGLOG_D("eglGetProcAddress(%s)", name);
+        void* proc = MG_Impl::GetProcAddress(name);
+        if (!proc) {
+            MGLOG_W("Failed to get function: %s", (const char*)name);
+            return nullptr;
+        }
+        return (__eglMustCastToProperFunctionPointerType)proc;
+    }
+} // namespace MobileGL::MG_Impl::EGLImpl

MobileGL/MG_Impl/EGLImpl/EGLImpl.h

@@ -0,0 +1,64 @@
+// MobileGL - MobileGL/MG_Impl/EGLImpl/EGLImpl.h
+// Copyright (c) 2025-2026 MobileGL-Dev
+// Licensed under the GNU Lesser General Public License v3.0:
+//   https://www.gnu.org/licenses/gpl-3.0.txt
+//   https://www.gnu.org/licenses/lgpl-3.0.txt
+// SPDX-License-Identifier: LGPL-3.0-only
+// End of Source File Header
+
+#pragma once
+#include <Includes.h>
+
+namespace MobileGL::MG_Impl::EGLImpl {
+    EGLSurface CreateWindowSurface(EGLDisplay dpy, EGLConfig config, NativeWindowType window,
+                                   const EGLint* attrib_list);
+    EGLBoolean SwapBuffers(EGLDisplay dpy, EGLSurface draw);
+    EGLBoolean ChooseConfig(EGLDisplay dpy, const EGLint* attrib_list, EGLConfig* configs, EGLint config_size,
+                            EGLint* num_config);
+    EGLContext CreateContext(EGLDisplay dpy, EGLConfig config, EGLContext shareCtx, const EGLint* attrib_list);
+    EGLBoolean Initialize(EGLDisplay dpy, EGLint* major, EGLint* minor);
+    EGLDisplay GetDisplay(NativeDisplayType display);
+    EGLint GetError();
+    EGLBoolean MakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
+    EGLBoolean DestroyContext(EGLDisplay dpy, EGLContext ctx);
+    EGLBoolean DestroySurface(EGLDisplay dpy, EGLSurface surface);
+    EGLBoolean Terminate(EGLDisplay dpy);
+    EGLBoolean ReleaseThread();
+    EGLContext GetCurrentContext();
+    EGLBoolean GetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint* value);
+    EGLBoolean BindAPI(EGLenum api);
+    EGLSurface GetCurrentSurface(EGLint readdraw);
+    EGLBoolean QuerySurface(EGLDisplay display, EGLSurface surface, EGLint attribute, EGLint* value);
+    const char* QueryString(EGLDisplay display, EGLint name);
+    EGLBoolean SwapInterval(EGLDisplay dpy, EGLint interval);
+    EGLSurface CreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint* attrib_list);
+    EGLBoolean BindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer);
+    EGLBoolean ReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer);
+    EGLBoolean CopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target);
+    EGLSurface CreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config,
+                                             const EGLint* attrib_list);
+    EGLSurface CreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap,
+                                   const EGLint* attrib_list);
+    EGLBoolean GetConfigs(EGLDisplay dpy, EGLConfig* configs, EGLint config_size, EGLint* num_config);
+    EGLDisplay GetCurrentDisplay();
+    EGLenum QueryAPI();
+    EGLBoolean QueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint* value);
+    EGLBoolean SurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value);
+    EGLBoolean WaitClient();
+    EGLBoolean WaitGL();
+    EGLBoolean WaitNative(EGLint engine);
+    EGLSync CreateSync(EGLDisplay dpy, EGLenum type, const EGLAttrib* attrib_list);
+    EGLBoolean DestroySync(void* dpy, void* sync);
+    EGLint ClientWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout);
+    EGLBoolean GetSyncAttrib(EGLDisplay dpy, EGLSync sync, EGLint attribute, EGLAttrib* value);
+    EGLImage CreateImage(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer,
+                         const EGLAttrib* attrib_list);
+    EGLBoolean DestroyImage(EGLDisplay dpy, EGLImage image);
+    EGLDisplay GetPlatformDisplay(EGLenum platform, void* native_display, const EGLAttrib* attrib_list);
+    EGLSurface CreatePlatformWindowSurface(EGLDisplay dpy, EGLConfig config, void* native_window,
+                                           const EGLAttrib* attrib_list);
+    EGLSurface CreatePlatformPixmapSurface(EGLDisplay dpy, EGLConfig config, void* native_pixmap,
+                                           const EGLAttrib* attrib_list);
+    EGLBoolean WaitSync(void* dpy, void* sync, int flags);
+    __eglMustCastToProperFunctionPointerType GetProcAddress(const char* name);
+} // namespace MobileGL::MG_Impl::EGLImpl

MobileGL/MG_Impl/EGLImpl/EGLWrapper/EGLWrapper.cpp

@@ -1,218 +0,0 @@
-// MobileGL - MobileGL/MG_Impl/EGLImpl/EGLWrapper/EGLWrapper.cpp
-// Copyright (c) 2025-2026 MobileGL-Dev
-// Licensed under the GNU Lesser General Public License v3.0:
-//   https://www.gnu.org/licenses/gpl-3.0.txt
-//   https://www.gnu.org/licenses/lgpl-3.0.txt
-// SPDX-License-Identifier: LGPL-3.0-only
-// End of Source File Header
-
-#include "EGLWrapper.h"
-
-#include "MG_Impl/GetProcAddress.h"
-
-#include <Config.h>
-#include <MG_Util/BackendLoaders/OpenGL/Loader.h>
-
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
-namespace MobileGL {
-    namespace MG_Impl::EGLImpl {
-        // TODO: implement complete EGL functionality
-
-        EGLSurface CreateWindowSurface(EGLDisplay dpy, EGLConfig config, NativeWindowType window,
-                                       const EGLint* attrib_list) {
-            return MG_External::EGL::eglCreateWindowSurface(dpy, config, window, attrib_list);
-        }
-
-        EGLBoolean ChooseConfig(EGLDisplay dpy, const EGLint* attrib_list, EGLConfig* configs, EGLint config_size,
-                                EGLint* num_config) {
-            return MG_External::EGL::eglChooseConfig(dpy, attrib_list, configs, config_size, num_config);
-        }
-
-        EGLContext CreateContext(EGLDisplay dpy, EGLConfig config, EGLContext shareCtx, const EGLint* attrib_list) {
-            return MG_External::EGL::eglCreateContext(dpy, config, shareCtx, attrib_list);
-        }
-
-        EGLBoolean Initialize(EGLDisplay dpy, EGLint* major, EGLint* minor) {
-            return MG_External::EGL::eglInitialize(dpy, major, minor);
-        }
-
-        EGLDisplay GetDisplay(NativeDisplayType display) {
-            return MG_External::EGL::eglGetDisplay(display);
-        }
-
-        EGLint GetError() {
-            return MG_External::EGL::eglGetError();
-        }
-
-        EGLBoolean MakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx) {
-            return MG_External::EGL::eglMakeCurrent(dpy, draw, read, ctx);
-        }
-
-        EGLBoolean DestroyContext(EGLDisplay dpy, EGLContext ctx) {
-            return MG_External::EGL::eglDestroyContext(dpy, ctx);
-        }
-
-        EGLBoolean DestroySurface(EGLDisplay dpy, EGLSurface surface) {
-            return MG_External::EGL::eglDestroySurface(dpy, surface);
-        }
-
-        EGLBoolean Terminate(EGLDisplay dpy) {
-            return MG_External::EGL::eglTerminate(dpy);
-        }
-
-        EGLBoolean ReleaseThread(void) {
-            return MG_External::EGL::eglReleaseThread();
-        }
-
-        EGLContext GetCurrentContext(void) {
-            return MG_External::EGL::eglGetCurrentContext();
-        }
-
-        EGLBoolean GetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint* value) {
-            return MG_External::EGL::eglGetConfigAttrib(dpy, config, attribute, value);
-        }
-
-        EGLBoolean BindAPI(EGLenum api) {
-            // We should accept `EGL_OPENGL_API`,
-            // and bind to `EGL_OPENGL_ES_API` at the backend
-            MGLOG_D("%s: api = %s", __func__, api == EGL_OPENGL_API ? "EGL_OPENGL_API" : "EGL_OPENGL_ES_API");
-            MGLOG_D("%s: calling backend as EGL_OPENGL_ES_API", __func__);
-            return MG_External::EGL::eglBindAPI(EGL_OPENGL_ES_API);
-        }
-
-        EGLSurface GetCurrentSurface(EGLint readdraw) {
-            return MG_External::EGL::eglGetCurrentSurface(readdraw);
-        }
-
-        EGLBoolean QuerySurface(EGLDisplay display, EGLSurface surface, EGLint attribute, EGLint* value) {
-            return MG_External::EGL::eglQuerySurface(display, surface, attribute, value);
-        }
-
-        char const* QueryString(EGLDisplay display, EGLint name) {
-            return MG_External::EGL::eglQueryString(display, name);
-        }
-
-        EGLBoolean SwapInterval(EGLDisplay dpy, EGLint interval) {
-            return MG_External::EGL::eglSwapInterval(dpy, interval);
-        }
-
-        EGLBoolean SwapBuffers(EGLDisplay dpy, EGLSurface draw) {
-            return MG_External::EGL::eglSwapBuffers(dpy, draw);
-        }
-
-        EGLSurface CreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint* attrib_list) {
-            return MG_External::EGL::eglCreatePbufferSurface(dpy, config, attrib_list);
-        }
-
-        EGLBoolean BindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) {
-            return MG_External::EGL::eglBindTexImage(dpy, surface, buffer);
-        }
-
-        EGLBoolean ReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) {
-            return MG_External::EGL::eglReleaseTexImage(dpy, surface, buffer);
-        }
-
-        EGLBoolean CopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target) {
-            return MG_External::EGL::eglCopyBuffers(dpy, surface, target);
-        }
-
-        EGLSurface CreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer,
-                                                 EGLConfig config, const EGLint* attrib_list) {
-            return MG_External::EGL::eglCreatePbufferFromClientBuffer(dpy, buftype, buffer, config, attrib_list);
-        }
-
-        EGLSurface CreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap,
-                                       const EGLint* attrib_list) {
-            return MG_External::EGL::eglCreatePixmapSurface(dpy, config, pixmap, attrib_list);
-        }
-
-        EGLBoolean GetConfigs(EGLDisplay dpy, EGLConfig* configs, EGLint config_size, EGLint* num_config) {
-            return MG_External::EGL::eglGetConfigs(dpy, configs, config_size, num_config);
-        }
-
-        EGLDisplay GetCurrentDisplay(void) {
-            return MG_External::EGL::eglGetCurrentDisplay();
-        }
-
-        EGLenum QueryAPI(void) {
-            return MG_External::EGL::eglQueryAPI();
-        }
-
-        EGLBoolean QueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint* value) {
-            return MG_External::EGL::eglQueryContext(dpy, ctx, attribute, value);
-        }
-
-        EGLBoolean SurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value) {
-            return MG_External::EGL::eglSurfaceAttrib(dpy, surface, attribute, value);
-        }
-
-        EGLBoolean WaitClient(void) {
-            return MG_External::EGL::eglWaitClient();
-        }
-
-        EGLBoolean WaitGL(void) {
-            return MG_External::EGL::eglWaitGL();
-        }
-
-        EGLBoolean WaitNative(EGLint engine) {
-            return MG_External::EGL::eglWaitNative(engine);
-        }
-
-        __eglMustCastToProperFunctionPointerType GetProcAddress(const char* name) {
-            MGLOG_D("eglGetProcAddress(%s)", name);
-
-            void* proc = MG_Impl::GetProcAddress(name);
-
-            if (!proc) {
-                MGLOG_W("Failed to get function: %s", (const char*)name);
-                return nullptr;
-            }
-            return (__eglMustCastToProperFunctionPointerType)proc;
-        }
-
-        EGLSync CreateSync(EGLDisplay dpy, EGLenum type, const EGLAttrib* attrib_list) {
-            return MG_External::EGL::eglCreateSync(dpy, type, attrib_list);
-        }
-
-        EGLBoolean DestroySync(EGLDisplay dpy, EGLSync sync) {
-            return MG_External::EGL::eglDestroySync(dpy, sync);
-        }
-
-        EGLint ClientWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout) {
-            return MG_External::EGL::eglClientWaitSync(dpy, sync, flags, timeout);
-        }
-
-        EGLBoolean GetSyncAttrib(EGLDisplay dpy, EGLSync sync, EGLint attribute, EGLAttrib* value) {
-            return MG_External::EGL::eglGetSyncAttrib(dpy, sync, attribute, value);
-        }
-
-        EGLImage CreateImage(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer,
-                             const EGLAttrib* attrib_list) {
-            return MG_External::EGL::eglCreateImage(dpy, ctx, target, buffer, attrib_list);
-        }
-
-        EGLBoolean DestroyImage(EGLDisplay dpy, EGLImage image) {
-            return MG_External::EGL::eglDestroyImage(dpy, image);
-        }
-
-        EGLDisplay GetPlatformDisplay(EGLenum platform, void* native_display, const EGLAttrib* attrib_list) {
-            return MG_External::EGL::eglGetPlatformDisplay(platform, native_display, attrib_list);
-        }
-
-        EGLSurface CreatePlatformWindowSurface(EGLDisplay dpy, EGLConfig config, void* native_window,
-                                               const EGLAttrib* attrib_list) {
-            return MG_External::EGL::eglCreatePlatformWindowSurface(dpy, config, native_window, attrib_list);
-        }
-
-        EGLSurface CreatePlatformPixmapSurface(EGLDisplay dpy, EGLConfig config, void* native_pixmap,
-                                               const EGLAttrib* attrib_list) {
-            return MG_External::EGL::eglCreatePlatformPixmapSurface(dpy, config, native_pixmap, attrib_list);
-        }
-
-        EGLBoolean WaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags) {
-            return MG_External::EGL::eglWaitSync(dpy, sync, flags);
-        }
-    } // namespace MG_Impl::EGLImpl
-} // namespace MobileGL
-
-#endif

MobileGL/MG_Impl/EGLImpl/Exporting/Definitions.cpp

@@ -7,20 +7,24 @@
 // End of Source File Header
 
 #include <Includes.h>
-#include "../Temporary/TemporaryEGLImpl.h"
+#include "../EGLImpl.h"
 
 MOBILEGL_EGL_API EGLSurface eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, NativeWindowType window,
                                                    const EGLint* attrib_list) {
+    MGLOG_D("eglCreateWindowSurface(dpy=%p, config=%p, window=%p, attrib_list=%p)", dpy, config, window, attrib_list);
     return MobileGL::MG_Impl::EGLImpl::CreateWindowSurface(dpy, config, window, attrib_list);
 }
 
 MOBILEGL_EGL_API EGLBoolean eglChooseConfig(EGLDisplay dpy, const EGLint* attrib_list, EGLConfig* configs,
                                             EGLint config_size, EGLint* num_config) {
+    MGLOG_D("eglChooseConfig(dpy=%p, attrib_list=%p, configs=%p, config_size=%d, num_config=%p)", dpy, attrib_list,
+            configs, config_size, num_config);
     return MobileGL::MG_Impl::EGLImpl::ChooseConfig(dpy, attrib_list, configs, config_size, num_config);
 }
 
 MOBILEGL_EGL_API EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext shareCtx,
                                              const EGLint* attrib_list) {
+    MGLOG_D("eglCreateContext(dpy=%p, config=%p, shareCtx=%p, attrib_list=%p)", dpy, config, shareCtx, attrib_list);
 #ifdef TRACY_ENABLE
     tracy::StartupProfiler();
 #endif
@@ -28,22 +32,27 @@ MOBILEGL_EGL_API EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config, E
 }
 
 MOBILEGL_EGL_API EGLBoolean eglInitialize(EGLDisplay dpy, EGLint* major, EGLint* minor) {
+    MGLOG_D("eglInitialize(dpy=%p, major=%p, minor=%p)", dpy, major, minor);
     return MobileGL::MG_Impl::EGLImpl::Initialize(dpy, major, minor);
 }
 
 MOBILEGL_EGL_API EGLDisplay eglGetDisplay(NativeDisplayType display) {
+    MGLOG_D("eglGetDisplay(display=%p)", display);
     return MobileGL::MG_Impl::EGLImpl::GetDisplay(display);
 }
 
 MOBILEGL_EGL_API EGLint eglGetError() {
+    MGLOG_D("eglGetError()");
     return MobileGL::MG_Impl::EGLImpl::GetError();
 }
 
 MOBILEGL_EGL_API EGLBoolean eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx) {
+    MGLOG_D("eglMakeCurrent(dpy=%p, draw=%p, read=%p, ctx=%p)", dpy, draw, read, ctx);
     return MobileGL::MG_Impl::EGLImpl::MakeCurrent(dpy, draw, read, ctx);
 }
 
 MOBILEGL_EGL_API EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx) {
+    MGLOG_D("eglDestroyContext(dpy=%p, ctx=%p)", dpy, ctx);
 #ifdef TRACY_ENABLE
     tracy::ShutdownProfiler();
 #endif
@@ -51,46 +60,57 @@ MOBILEGL_EGL_API EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx) {
 }
 
 MOBILEGL_EGL_API EGLBoolean eglDestroySurface(EGLDisplay dpy, EGLSurface surface) {
+    MGLOG_D("eglDestroySurface(dpy=%p, surface=%p)", dpy, surface);
     return MobileGL::MG_Impl::EGLImpl::DestroySurface(dpy, surface);
 }
 
 MOBILEGL_EGL_API EGLBoolean eglTerminate(EGLDisplay dpy) {
+    MGLOG_D("eglTerminate(dpy=%p)", dpy);
     return MobileGL::MG_Impl::EGLImpl::Terminate(dpy);
 }
 
 MOBILEGL_EGL_API EGLBoolean eglReleaseThread(void) {
+    MGLOG_D("eglReleaseThread()");
     return MobileGL::MG_Impl::EGLImpl::ReleaseThread();
 }
 
 MOBILEGL_EGL_API EGLContext eglGetCurrentContext(void) {
+    MGLOG_D("eglGetCurrentContext()");
     return MobileGL::MG_Impl::EGLImpl::GetCurrentContext();
 }
 
 MOBILEGL_EGL_API EGLBoolean eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint* value) {
+    MGLOG_D("eglGetConfigAttrib(dpy=%p, config=%p, attribute=%d, value=%p)", dpy, config, attribute, value);
     return MobileGL::MG_Impl::EGLImpl::GetConfigAttrib(dpy, config, attribute, value);
 }
 
 MOBILEGL_EGL_API EGLBoolean eglBindAPI(EGLenum api) {
+    MGLOG_D("eglBindAPI(api=%u)", api);
     return MobileGL::MG_Impl::EGLImpl::BindAPI(api);
 }
 
 MOBILEGL_EGL_API EGLSurface eglGetCurrentSurface(EGLint readdraw) {
+    MGLOG_D("eglGetCurrentSurface(readdraw=%d)", readdraw);
     return MobileGL::MG_Impl::EGLImpl::GetCurrentSurface(readdraw);
 }
 
 MOBILEGL_EGL_API EGLBoolean eglQuerySurface(EGLDisplay display, EGLSurface surface, EGLint attribute, EGLint* value) {
+    MGLOG_D("eglQuerySurface(display=%p, surface=%p, attribute=%d, value=%p)", display, surface, attribute, value);
     return MobileGL::MG_Impl::EGLImpl::QuerySurface(display, surface, attribute, value);
 }
 
-MOBILEGL_EGL_API char const * eglQueryString(EGLDisplay display, EGLint name) {
+MOBILEGL_EGL_API char const* eglQueryString(EGLDisplay display, EGLint name) {
+    MGLOG_D("eglQueryString(display=%p, name=%d)", display, name);
     return MobileGL::MG_Impl::EGLImpl::QueryString(display, name);
 }
 
 MOBILEGL_EGL_API EGLBoolean eglSwapInterval(EGLDisplay dpy, EGLint interval) {
+    MGLOG_D("eglSwapInterval(dpy=%p, interval=%d)", dpy, interval);
     return MobileGL::MG_Impl::EGLImpl::SwapInterval(dpy, interval);
 }
 
 MOBILEGL_EGL_API EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface draw) {
+    MGLOG_D("eglSwapBuffers(dpy=%p, draw=%p)", dpy, draw);
 #ifdef TRACY_ENABLE
     FrameMark;
 #endif
@@ -98,108 +118,138 @@ MOBILEGL_EGL_API EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface draw) {
 }
 
 MOBILEGL_EGL_API EGLSurface eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint* attrib_list) {
+    MGLOG_D("eglCreatePbufferSurface(dpy=%p, config=%p, attrib_list=%p)", dpy, config, attrib_list);
     return MobileGL::MG_Impl::EGLImpl::CreatePbufferSurface(dpy, config, attrib_list);
 }
 
 MOBILEGL_EGL_API __eglMustCastToProperFunctionPointerType eglGetProcAddress(const char* name) {
+    MGLOG_D("eglGetProcAddress(name=%s)", name ? name : "null");
     return MobileGL::MG_Impl::EGLImpl::GetProcAddress(name);
 }
 
 MOBILEGL_EGL_API EGLBoolean eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) {
+    MGLOG_D("eglBindTexImage(dpy=%p, surface=%p, buffer=%d)", dpy, surface, buffer);
     return MobileGL::MG_Impl::EGLImpl::BindTexImage(dpy, surface, buffer);
 }
 
 MOBILEGL_EGL_API EGLBoolean eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) {
+    MGLOG_D("eglReleaseTexImage(dpy=%p, surface=%p, buffer=%d)", dpy, surface, buffer);
     return MobileGL::MG_Impl::EGLImpl::ReleaseTexImage(dpy, surface, buffer);
 }
 
 MOBILEGL_EGL_API EGLBoolean eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target) {
+    MGLOG_D("eglCopyBuffers(dpy=%p, surface=%p, target=%p)", dpy, surface, target);
     return MobileGL::MG_Impl::EGLImpl::CopyBuffers(dpy, surface, target);
 }
 
-MOBILEGL_EGL_API EGLSurface eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype,
+MOBILEGL_EGL_API EGLSurface eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer,
-                                                             EGLClientBuffer buffer, EGLConfig config,
+                                                             EGLConfig config, const EGLint* attrib_list) {
-                                                             const EGLint* attrib_list) {
+    MGLOG_D("eglCreatePbufferFromClientBuffer(dpy=%p, buftype=%u, buffer=%p, config=%p, attrib_list=%p)", dpy, buftype,
+            buffer, config, attrib_list);
     return MobileGL::MG_Impl::EGLImpl::CreatePbufferFromClientBuffer(dpy, buftype, buffer, config, attrib_list);
 }
 
 MOBILEGL_EGL_API EGLSurface eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap,
                                                    const EGLint* attrib_list) {
+    MGLOG_D("eglCreatePixmapSurface(dpy=%p, config=%p, pixmap=%p, attrib_list=%p)", dpy, config, pixmap, attrib_list);
     return MobileGL::MG_Impl::EGLImpl::CreatePixmapSurface(dpy, config, pixmap, attrib_list);
 }
 
 MOBILEGL_EGL_API EGLBoolean eglGetConfigs(EGLDisplay dpy, EGLConfig* configs, EGLint config_size, EGLint* num_config) {
+    MGLOG_D("eglGetConfigs(dpy=%p, configs=%p, config_size=%d, num_config=%p)", dpy, configs, config_size, num_config);
     return MobileGL::MG_Impl::EGLImpl::GetConfigs(dpy, configs, config_size, num_config);
 }
 
 MOBILEGL_EGL_API EGLDisplay eglGetCurrentDisplay(void) {
+    MGLOG_D("eglGetCurrentDisplay()");
     return MobileGL::MG_Impl::EGLImpl::GetCurrentDisplay();
 }
 
 MOBILEGL_EGL_API EGLenum eglQueryAPI(void) {
+    MGLOG_D("eglQueryAPI()");
     return MobileGL::MG_Impl::EGLImpl::QueryAPI();
 }
 
 MOBILEGL_EGL_API EGLBoolean eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint* value) {
+    MGLOG_D("eglQueryContext(dpy=%p, ctx=%p, attribute=%d, value=%p)", dpy, ctx, attribute, value);
     return MobileGL::MG_Impl::EGLImpl::QueryContext(dpy, ctx, attribute, value);
 }
 
 MOBILEGL_EGL_API EGLBoolean eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value) {
+    MGLOG_D("eglSurfaceAttrib(dpy=%p, surface=%p, attribute=%d, value=%d)", dpy, surface, attribute, value);
     return MobileGL::MG_Impl::EGLImpl::SurfaceAttrib(dpy, surface, attribute, value);
 }
 
 MOBILEGL_EGL_API EGLBoolean eglWaitClient(void) {
+    MGLOG_D("eglWaitClient()");
     return MobileGL::MG_Impl::EGLImpl::WaitClient();
 }
 
 MOBILEGL_EGL_API EGLBoolean eglWaitGL(void) {
+    MGLOG_D("eglWaitGL()");
     return MobileGL::MG_Impl::EGLImpl::WaitGL();
 }
 
 MOBILEGL_EGL_API EGLBoolean eglWaitNative(EGLint engine) {
+    MGLOG_D("eglWaitNative(engine=%d)", engine);
     return MobileGL::MG_Impl::EGLImpl::WaitNative(engine);
 }
 
 MOBILEGL_EGL_API EGLSync eglCreateSync(EGLDisplay dpy, EGLenum type, const EGLAttrib* attrib_list) {
+    MGLOG_D("eglCreateSync(dpy=%p, type=%u, attrib_list=%p)", dpy, type, attrib_list);
     return MobileGL::MG_Impl::EGLImpl::CreateSync(dpy, type, attrib_list);
 }
 
 MOBILEGL_EGL_API EGLBoolean eglDestroySync(EGLDisplay dpy, EGLSync sync) {
+    MGLOG_D("eglDestroySync(dpy=%p, sync=%p)", dpy, sync);
     return MobileGL::MG_Impl::EGLImpl::DestroySync(dpy, sync);
 }
 
 MOBILEGL_EGL_API EGLint eglClientWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout) {
+    MGLOG_D("eglClientWaitSync(dpy=%p, sync=%p, flags=%d, timeout=%llu)", dpy, sync, flags,
+            static_cast<unsigned long long>(timeout));
     return MobileGL::MG_Impl::EGLImpl::ClientWaitSync(dpy, sync, flags, timeout);
 }
 
 MOBILEGL_EGL_API EGLBoolean eglGetSyncAttrib(EGLDisplay dpy, EGLSync sync, EGLint attribute, EGLAttrib* value) {
+    MGLOG_D("eglGetSyncAttrib(dpy=%p, sync=%p, attribute=%d, value=%p)", dpy, sync, attribute, value);
     return MobileGL::MG_Impl::EGLImpl::GetSyncAttrib(dpy, sync, attribute, value);
 }
 
 MOBILEGL_EGL_API EGLImage eglCreateImage(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer,
                                          const EGLAttrib* attrib_list) {
+    MGLOG_D("eglCreateImage(dpy=%p, ctx=%p, target=%u, buffer=%p, attrib_list=%p)", dpy, ctx, target, buffer,
+            attrib_list);
     return MobileGL::MG_Impl::EGLImpl::CreateImage(dpy, ctx, target, buffer, attrib_list);
 }
 
 MOBILEGL_EGL_API EGLBoolean eglDestroyImage(EGLDisplay dpy, EGLImage image) {
+    MGLOG_D("eglDestroyImage(dpy=%p, image=%p)", dpy, image);
     return MobileGL::MG_Impl::EGLImpl::DestroyImage(dpy, image);
 }
 
 MOBILEGL_EGL_API EGLDisplay eglGetPlatformDisplay(EGLenum platform, void* native_display,
                                                   const EGLAttrib* attrib_list) {
+    MGLOG_D("eglGetPlatformDisplay(platform=%u, native_display=%p, attrib_list=%p)", platform, native_display,
+            attrib_list);
     return MobileGL::MG_Impl::EGLImpl::GetPlatformDisplay(platform, native_display, attrib_list);
 }
 
 MOBILEGL_EGL_API EGLSurface eglCreatePlatformWindowSurface(EGLDisplay dpy, EGLConfig config, void* native_window,
                                                            const EGLAttrib* attrib_list) {
+    MGLOG_D("eglCreatePlatformWindowSurface(dpy=%p, config=%p, native_window=%p, attrib_list=%p)", dpy, config,
+            native_window, attrib_list);
     return MobileGL::MG_Impl::EGLImpl::CreatePlatformWindowSurface(dpy, config, native_window, attrib_list);
 }
 
 MOBILEGL_EGL_API EGLSurface eglCreatePlatformPixmapSurface(EGLDisplay dpy, EGLConfig config, void* native_pixmap,
                                                            const EGLAttrib* attrib_list) {
+    MGLOG_D("eglCreatePlatformPixmapSurface(dpy=%p, config=%p, native_pixmap=%p, attrib_list=%p)", dpy, config,
+            native_pixmap, attrib_list);
     return MobileGL::MG_Impl::EGLImpl::CreatePlatformPixmapSurface(dpy, config, native_pixmap, attrib_list);
 }
 
 MOBILEGL_EGL_API EGLBoolean eglWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags) {
+    MGLOG_D("eglWaitSync(dpy=%p, sync=%p, flags=%d)", dpy, sync, flags);
     return MobileGL::MG_Impl::EGLImpl::WaitSync(dpy, sync, flags);
 }

MobileGL/MG_Impl/EGLImpl/Temporary/TemporaryEGLImpl.cpp

@@ -1,195 +0,0 @@
-// MobileGL - MobileGL/MG_Impl/EGLImpl/Temporary/TemporaryEGLImpl.cpp
-// Copyright (c) 2025-2026 MobileGL-Dev
-// Licensed under the GNU Lesser General Public License v3.0:
-//   https://www.gnu.org/licenses/gpl-3.0.txt
-//   https://www.gnu.org/licenses/lgpl-3.0.txt
-// SPDX-License-Identifier: LGPL-3.0-only
-// End of Source File Header
-
-#include "TemporaryEGLImpl.h"
-#include <Config.h>
-
-#if MOBILEGL_BACKEND != MOBILEGL_BACKEND_TYPE_DIRECT_GLES && MOBILEGL_BACKEND != MOBILEGL_BACKEND_TYPE_DIRECT_VULKAN
-namespace MobileGL {
-    namespace MG_Impl::EGLImpl {
-        // TODO: implement complete EGL functionality
-
-        EGLSurface CreateWindowSurface(EGLDisplay dpy, EGLConfig config, NativeWindowType window,
-                                       const EGLint* attrib_list) {
-            return (EGLSurface)1;
-        }
-
-        EGLBoolean ChooseConfig(EGLDisplay dpy, const EGLint* attrib_list, EGLConfig* configs, EGLint config_size,
-                                EGLint* num_config) {
-            *num_config = 1;
-            return EGL_TRUE;
-        }
-
-        EGLContext CreateContext(EGLDisplay dpy, EGLConfig config, EGLContext shareCtx, const EGLint* attrib_list) {
-            return (EGLContext)1;
-        }
-
-        EGLBoolean Initialize(EGLDisplay dpy, EGLint* major, EGLint* minor) {
-            if (major) *major = 1;
-            if (minor) *minor = 5;
-            return EGL_TRUE;
-        }
-
-        EGLDisplay GetDisplay(NativeDisplayType display) {
-            return (EGLDisplay)1;
-        }
-
-        EGLint GetError() {
-            return EGL_SUCCESS;
-        }
-
-        EGLBoolean MakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx) {
-            return EGL_TRUE;
-        }
-
-        EGLBoolean DestroyContext(EGLDisplay dpy, EGLContext ctx) {
-            return EGL_TRUE;
-        }
-
-        EGLBoolean DestroySurface(EGLDisplay dpy, EGLSurface surface) {
-            return EGL_TRUE;
-        }
-
-        EGLBoolean Terminate(EGLDisplay dpy) {
-            return EGL_TRUE;
-        }
-
-        EGLBoolean ReleaseThread(void) {
-            return EGL_TRUE;
-        }
-
-        EGLContext GetCurrentContext(void) {
-            return (EGLContext)1;
-        }
-
-        EGLBoolean GetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint* value) {
-            if (attribute == EGL_NATIVE_VISUAL_ID) {
-#if defined(ANDROID)
-                *value = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
-                return EGL_TRUE;
-#elif defined(__linux__)
-                *value = 0;
-                return EGL_TRUE;
-#elif defined(_WIN32)
-                *value = 0;
-                return EGL_TRUE;
-#else
-                *value = 0;
-                return EGL_FALSE;
-#endif
-            }
-            return EGL_TRUE;
-        }
-
-        EGLBoolean BindAPI(EGLenum api) {
-            return EGL_TRUE;
-        }
-
-        EGLSurface GetCurrentSurface(EGLint readdraw) {
-            return (EGLSurface)1;
-        }
-
-        EGLBoolean QuerySurface(EGLDisplay display, EGLSurface surface, EGLint attribute, EGLint* value) {
-            return EGL_TRUE;
-        }
-
-        char const* QueryString(EGLDisplay display, EGLint name) {
-            return "";
-        }
-
-        EGLBoolean SwapInterval(EGLDisplay dpy, EGLint interval) {
-            return EGL_TRUE;
-        }
-
-        EGLBoolean SwapBuffers(EGLDisplay dpy, EGLSurface draw) {
-            return EGL_TRUE;
-        }
-
-        EGLSurface CreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint* attrib_list) {
-            return (EGLSurface)1;
-        }
-
-        EGLBoolean BindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) {
-            return EGL_TRUE;
-        }
-
-        EGLBoolean ReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) {
-            return EGL_TRUE;
-        }
-
-        EGLBoolean CopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target) {
-            return EGL_TRUE;
-        }
-
-        EGLSurface CreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer,
-                                                 EGLConfig config, const EGLint* attrib_list) {
-            return (EGLSurface)1;
-        }
-
-        EGLSurface CreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap,
-                                       const EGLint* attrib_list) {
-            return (EGLSurface)1;
-        }
-
-        EGLBoolean GetConfigs(EGLDisplay dpy, EGLConfig* configs, EGLint config_size, EGLint* num_config) {
-            if (num_config) {
-                *num_config = 1;
-            }
-            if (configs && config_size > 0) {
-                configs[0] = (EGLConfig)1;
-            }
-            return EGL_TRUE;
-        }
-
-        EGLDisplay GetCurrentDisplay(void) {
-            return (EGLDisplay)1;
-        }
-
-        EGLenum QueryAPI(void) {
-            return EGL_OPENGL_API;
-        }
-
-        EGLBoolean QueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint* value) {
-            if (value) {
-                *value = 0;
-            }
-            return EGL_TRUE;
-        }
-
-        EGLBoolean SurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value) {
-            return EGL_TRUE;
-        }
-
-        EGLBoolean WaitClient(void) {
-            return EGL_TRUE;
-        }
-
-        EGLBoolean WaitGL(void) {
-            return EGL_TRUE;
-        }
-
-        EGLBoolean WaitNative(EGLint engine) {
-            return EGL_TRUE;
-        }
-
-        __eglMustCastToProperFunctionPointerType GetProcAddress(const char* name) {
-            MGLOG_D("eglGetProcAddress(%s)", name);
-#if !defined(WIN32) && !defined(__APPLE__)
-            void* proc = dlsym(RTLD_DEFAULT, (const char*)name);
-#else
-            void* proc = NULL;
-#endif
-            if (!proc) {
-                MGLOG_W("Failed to get function: %s", (const char*)name);
-                return nullptr;
-            }
-            return (__eglMustCastToProperFunctionPointerType)proc;
-        }
-    } // namespace MG_Impl::EGLImpl
-} // namespace MobileGL
-#endif

MobileGL/MG_Impl/EGLImpl/Temporary/TemporaryEGLImpl.h

@@ -1,66 +0,0 @@
-// MobileGL - MobileGL/MG_Impl/EGLImpl/Temporary/TemporaryEGLImpl.h
-// Copyright (c) 2025-2026 MobileGL-Dev
-// Licensed under the GNU Lesser General Public License v3.0:
-//   https://www.gnu.org/licenses/gpl-3.0.txt
-//   https://www.gnu.org/licenses/lgpl-3.0.txt
-// SPDX-License-Identifier: LGPL-3.0-only
-// End of Source File Header
-
-#pragma once
-#include <Includes.h>
-
-namespace MobileGL {
-    namespace MG_Impl::EGLImpl {
-        EGLSurface CreateWindowSurface(EGLDisplay dpy, EGLConfig config, NativeWindowType window,
-                                       const EGLint* attrib_list);
-        EGLBoolean ChooseConfig(EGLDisplay dpy, const EGLint* attrib_list, EGLConfig* configs, EGLint config_size,
-                                EGLint* num_config);
-        EGLContext CreateContext(EGLDisplay dpy, EGLConfig config, EGLContext shareCtx, const EGLint* attrib_list);
-        EGLBoolean Initialize(EGLDisplay dpy, EGLint* major, EGLint* minor);
-        EGLDisplay GetDisplay(NativeDisplayType display);
-        EGLint GetError();
-        EGLBoolean MakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
-        EGLBoolean DestroyContext(EGLDisplay dpy, EGLContext ctx);
-        EGLBoolean DestroySurface(EGLDisplay dpy, EGLSurface surface);
-        EGLBoolean Terminate(EGLDisplay dpy);
-        EGLBoolean ReleaseThread(void);
-        EGLContext GetCurrentContext(void);
-        EGLBoolean GetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint* value);
-        EGLBoolean BindAPI(EGLenum api);
-        EGLSurface GetCurrentSurface(EGLint readdraw);
-        EGLBoolean QuerySurface(EGLDisplay display, EGLSurface surface, EGLint attribute, EGLint* value);
-        char const* QueryString(EGLDisplay display, EGLint name);
-        EGLBoolean SwapInterval(EGLDisplay dpy, EGLint interval);
-        EGLBoolean SwapBuffers(EGLDisplay dpy, EGLSurface draw);
-        EGLSurface CreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint* attrib_list);
-        EGLBoolean BindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer);
-        EGLBoolean ReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer);
-        EGLBoolean CopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target);
-        EGLSurface CreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer,
-                                                 EGLConfig config, const EGLint* attrib_list);
-        EGLSurface CreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap,
-                                       const EGLint* attrib_list);
-        EGLBoolean GetConfigs(EGLDisplay dpy, EGLConfig* configs, EGLint config_size, EGLint* num_config);
-        EGLDisplay GetCurrentDisplay(void);
-        EGLenum QueryAPI(void);
-        EGLBoolean QueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint* value);
-        EGLBoolean SurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value);
-        EGLBoolean WaitClient(void);
-        EGLBoolean WaitGL(void);
-        EGLBoolean WaitNative(EGLint engine);
-        __eglMustCastToProperFunctionPointerType GetProcAddress(const char* name);
-        EGLSync CreateSync(EGLDisplay dpy, EGLenum type, const EGLAttrib* attrib_list);
-        EGLBoolean DestroySync(EGLDisplay dpy, EGLSync sync);
-        EGLint ClientWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout);
-        EGLBoolean GetSyncAttrib(EGLDisplay dpy, EGLSync sync, EGLint attribute, EGLAttrib* value);
-        EGLImage CreateImage(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer,
-                             const EGLAttrib* attrib_list);
-        EGLBoolean DestroyImage(EGLDisplay dpy, EGLImage image);
-        EGLDisplay GetPlatformDisplay(EGLenum platform, void* native_display, const EGLAttrib* attrib_list);
-        EGLSurface CreatePlatformWindowSurface(EGLDisplay dpy, EGLConfig config, void* native_window,
-                                               const EGLAttrib* attrib_list);
-        EGLSurface CreatePlatformPixmapSurface(EGLDisplay dpy, EGLConfig config, void* native_pixmap,
-                                               const EGLAttrib* attrib_list);
-        EGLBoolean WaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags);
-    } // namespace MG_Impl::EGLImpl
-} // namespace MobileGL

MobileGL/MG_Impl/GLImpl/Drawing/GL_Drawing.cpp

@@ -1,4 +1,4 @@
-// MobileGL - MobileGL/MG_Impl/GLImpl/Drawing/GL_Drawing.cpp
+// MobileGL - MobileGL/MG_Impl/GLImpl/Drawing/GL_Drawing.cpp
 // Copyright (c) 2025-2026 MobileGL-Dev
 // Licensed under the GNU Lesser General Public License v3.0:
 //   https://www.gnu.org/licenses/gpl-3.0.txt
@@ -9,36 +9,21 @@
 #include "GL_Drawing.h"
 #include <Config.h>
 #include <MG_State/GLState/Core.h>
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
+#include <MG_Backend/BackendObjects.h>
-#include <MG_Backend/DirectGLES/DirectGLES.h>
-#endif
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_VULKAN
-#include <MG_Backend/DirectVulkan/DirectVulkan.h>
-#endif
-#include <MG_Util/BackendLoaders/OpenGL/Loader.h>
 
-namespace MobileGL {
+namespace MobileGL::MG_Impl::GLImpl {
-    namespace MG_Impl::GLImpl {
     void Clear_Backend(GLbitfield mask) {
 #ifdef TRACY_ENABLE
         ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
 #endif
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
+        MG_Backend::gBackendFunctionsTable.GL.Clear(mask);
-            MG_Backend::DirectGLES::Clear(mask);
-#elif MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_VULKAN
-            MG_Backend::DirectVulkan::Clear(mask);
-#endif
     }
 
     void DrawElements_Backend(GLenum mode, GLsizei count, GLenum type, const void* indices) {
 #ifdef TRACY_ENABLE
         ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
 #endif
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
+        MG_Backend::gBackendFunctionsTable.GL.DrawElements(mode, count, type, indices);
-            MG_Backend::DirectGLES::DrawElements(mode, count, type, indices);
-#elif MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_VULKAN
-            MG_Backend::DirectVulkan::DrawElements(mode, count, type, indices);
-#endif
     }
 
     void MultiDrawElements_Backend(GLenum mode, const GLsizei* count, GLenum type, const void* const* indices,
@@ -46,31 +31,23 @@ namespace MobileGL {
 #ifdef TRACY_ENABLE
         ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
 #endif
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
+        MG_Backend::gBackendFunctionsTable.GL.MultiDrawElements(mode, count, type, indices, drawcount);
-            MG_Backend::DirectGLES::MultiDrawElements(mode, count, type, indices, drawcount);
-#endif
     }
 
-        void MultiDrawElementsBaseVertex_Backend(GLenum mode, const GLsizei* count, GLenum type,
+    void MultiDrawElementsBaseVertex_Backend(GLenum mode, const GLsizei* count, GLenum type, const void* const* indices,
-                                                 const void* const* indices, GLsizei drawcount,
+                                             GLsizei drawcount, const GLint* basevertex) {
-                                                 const GLint* basevertex) {
 #ifdef TRACY_ENABLE
         ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
 #endif
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
+        MG_Backend::gBackendFunctionsTable.GL.MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount,
-            MG_Backend::DirectGLES::MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
+                                                                          basevertex);
-#endif
     }
 
     void DrawArrays_Backend(GLenum mode, GLint first, GLsizei count) {
 #ifdef TRACY_ENABLE
         ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
 #endif
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
+        MG_Backend::gBackendFunctionsTable.GL.DrawArrays(mode, first, count);
-            MG_Backend::DirectGLES::DrawArrays(mode, first, count);
-#elif MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_VULKAN
-            MG_Backend::DirectVulkan::DrawArrays(mode, first, count);
-#endif
     }
 
     void DrawElementsBaseVertex_Backend(GLenum mode, GLsizei count, GLenum type, const void* indices,
@@ -78,9 +55,7 @@ namespace MobileGL {
 #ifdef TRACY_ENABLE
         ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
 #endif
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
+        MG_Backend::gBackendFunctionsTable.GL.DrawElementsBaseVertex(mode, count, type, indices, basevertex);
-            MG_Backend::DirectGLES::DrawElementsBaseVertex(mode, count, type, indices, basevertex);
-#endif
     }
 
     void MultiDrawElementsIndirect_Backend(GLenum mode, GLenum type, const void* indirect, GLsizei drawcount,
@@ -88,18 +63,14 @@ namespace MobileGL {
 #ifdef TRACY_ENABLE
         ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
 #endif
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
+        MG_Backend::gBackendFunctionsTable.GL.MultiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
-            MG_Backend::DirectGLES::MultiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
-#endif
     }
 
     void MultiDrawArraysIndirect_Backend(GLenum mode, const void* indirect, GLsizei drawcount, GLsizei stride) {
 #ifdef TRACY_ENABLE
         ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
 #endif
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
+        MG_Backend::gBackendFunctionsTable.GL.MultiDrawArraysIndirect(mode, indirect, drawcount, stride);
-            MG_Backend::DirectGLES::MultiDrawArraysIndirect(mode, indirect, drawcount, stride);
-#endif
     }
 
     void DrawRangeElementsBaseVertex_Backend(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type,
@@ -107,9 +78,8 @@ namespace MobileGL {
 #ifdef TRACY_ENABLE
         ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
 #endif
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
+        MG_Backend::gBackendFunctionsTable.GL.DrawRangeElementsBaseVertex(mode, start, end, count, type, indices,
-            MG_Backend::DirectGLES::DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
+                                                                          basevertex);
-#endif
     }
 
     void DrawRangeElements_Backend(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type,
@@ -117,9 +87,7 @@ namespace MobileGL {
 #ifdef TRACY_ENABLE
         ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
 #endif
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
+        MG_Backend::gBackendFunctionsTable.GL.DrawRangeElements(mode, start, end, count, type, indices);
-            MG_Backend::DirectGLES::DrawRangeElements(mode, start, end, count, type, indices);
-#endif
     }
 
     void DrawElementsInstancedBaseVertexBaseInstance_Backend(GLenum mode, GLsizei count, GLenum type,
@@ -128,10 +96,8 @@ namespace MobileGL {
 #ifdef TRACY_ENABLE
         ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
 #endif
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
+        MG_Backend::gBackendFunctionsTable.GL.DrawElementsInstancedBaseVertexBaseInstance(
-            MG_Backend::DirectGLES::DrawElementsInstancedBaseVertexBaseInstance(
             mode, count, type, indices, instancecount, basevertex, baseinstance);
-#endif
     }
 
     void DrawElementsInstancedBaseVertex_Backend(GLenum mode, GLsizei count, GLenum type, const void* indices,
@@ -139,10 +105,8 @@ namespace MobileGL {
 #ifdef TRACY_ENABLE
         ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
 #endif
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
+        MG_Backend::gBackendFunctionsTable.GL.DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount,
-            MG_Backend::DirectGLES::DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount,
                                                                               basevertex);
-#endif
     }
 
     void DrawElementsInstancedBaseInstance_Backend(GLenum mode, GLsizei count, GLenum type, const void* indices,
@@ -150,10 +114,8 @@ namespace MobileGL {
 #ifdef TRACY_ENABLE
         ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
 #endif
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
+        MG_Backend::gBackendFunctionsTable.GL.DrawElementsInstancedBaseInstance(mode, count, type, indices,
-            MG_Backend::DirectGLES::DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount,
+                                                                                instancecount, baseinstance);
-                                                                      baseinstance);
-#endif
     }
 
     void DrawElementsInstanced_Backend(GLenum mode, GLsizei count, GLenum type, const void* indices,
@@ -161,50 +123,40 @@ namespace MobileGL {
 #ifdef TRACY_ENABLE
         ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
 #endif
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
+        MG_Backend::gBackendFunctionsTable.GL.DrawElementsInstanced(mode, count, type, indices, instancecount);
-            MG_Backend::DirectGLES::DrawElementsInstanced(mode, count, type, indices, instancecount);
-#endif
     }
 
     void DrawElementsIndirect_Backend(GLenum mode, GLenum type, const void* indirect) {
 #ifdef TRACY_ENABLE
         ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
 #endif
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
+        MG_Backend::gBackendFunctionsTable.GL.DrawElementsIndirect(mode, type, indirect);
-            MG_Backend::DirectGLES::DrawElementsIndirect(mode, type, indirect);
-#endif
     }
     void DrawArraysInstancedBaseInstance_Backend(GLenum mode, GLint first, GLsizei count, GLsizei instancecount,
                                                  GLuint baseinstance) {
 #ifdef TRACY_ENABLE
         ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
 #endif
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
+        MG_Backend::gBackendFunctionsTable.GL.DrawArraysInstancedBaseInstance(mode, first, count, instancecount,
-            MG_Backend::DirectGLES::DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
+                                                                              baseinstance);
-#endif
     }
 
     void DrawArraysInstanced_Backend(GLenum mode, GLint first, GLsizei count, GLsizei instancecount) {
 #ifdef TRACY_ENABLE
         ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
 #endif
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
+        MG_Backend::gBackendFunctionsTable.GL.DrawArraysInstanced(mode, first, count, instancecount);
-            MG_Backend::DirectGLES::DrawArraysInstanced(mode, first, count, instancecount);
-#endif
     }
 
     void DrawArraysIndirect_Backend(GLenum mode, const void* indirect) {
 #ifdef TRACY_ENABLE
         ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
 #endif
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
+        MG_Backend::gBackendFunctionsTable.GL.DrawArraysIndirect(mode, indirect);
-            MG_Backend::DirectGLES::DrawArraysIndirect(mode, indirect);
-#endif
     }
 
     /* @INSERTION_POINT:FUNCTION_IMPLEMENTATION@ */
-        void MultiDrawElementsIndirect(GLenum mode, GLenum type, const void* indirect, GLsizei drawcount,
+    void MultiDrawElementsIndirect(GLenum mode, GLenum type, const void* indirect, GLsizei drawcount, GLsizei stride) {
-                                       GLsizei stride) {
         MultiDrawElementsIndirect_Backend(mode, type, indirect, drawcount, stride);
     }
 
@@ -237,8 +189,7 @@ namespace MobileGL {
         DrawElementsInstancedBaseInstance_Backend(mode, count, type, indices, instancecount, baseinstance);
     }
 
-        void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void* indices,
+    void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei instancecount) {
-                                   GLsizei instancecount) {
         DrawElementsInstanced_Backend(mode, count, type, indices, instancecount);
     }
 
@@ -285,6 +236,4 @@ namespace MobileGL {
         DrawElements_Backend(mode, count, type, indices);
     }
 
-    } // namespace MG_Impl::GLImpl
+} // namespace MobileGL::MG_Impl::GLImpl
-} // namespace MobileGL
-

MobileGL/MG_Impl/GLImpl/Framebuffer/GL_Framebuffer.cpp

@@ -9,6 +9,7 @@
 #include "GL_Framebuffer.h"
 #include "Validators.h"
 #include "Config.h"
+#include <MG_Backend/BackendObjects.h>
 #include <MG_Util/Metrics/TextureMetrics.h>
 #include <MG_Impl/GLImpl/Texture/Validators.h>
 #include <MG_State/GLState/ErrorState/Error.h>
@@ -16,81 +17,12 @@
 #include <MG_Util/Converters/GLToMG/TextureEnumConverter.h>
 #include <MG_Util/Converters/MGToGL/TextureEnumConverter.h>
 #include <MG_Util/Converters/GLToMG/FramebufferEnumConverter.h>
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
-#include <MG_Backend/DirectGLES/DirectGLES.h>
-#endif
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_VULKAN
-#include <MG_Backend/DirectVulkan/DirectVulkan.h>
-#endif
 
-namespace MobileGL {
+namespace MobileGL::MG_Impl::GLImpl {
-    namespace MG_Impl::GLImpl {
     void BlitFramebuffer_Backend(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0,
                                  GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) {
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
+        MG_Backend::gBackendFunctionsTable.GL.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1,
-            MG_Backend::DirectGLES::BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask,
+                                                              mask, filter);
-                                                    filter);
-#elif MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_VULKAN
-            MG_Backend::DirectVulkan::BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask,
-                                                      filter);
-#endif
-        }
-
-        Bool BlitFramebuffer_State(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0,
-                                   GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) {
-            (void)srcX0;
-            (void)srcY0;
-            (void)srcX1;
-            (void)srcY1;
-            (void)dstX0;
-            (void)dstY0;
-            (void)dstX1;
-            (void)dstY1;
-
-            constexpr GLbitfield kSupportedMask = GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT;
-            if ((mask & kSupportedMask) == 0 || (mask & ~kSupportedMask) != 0) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
-                                                 "`mask` must contain COLOR/DEPTH/STENCIL bits only."));
-                return false;
-            }
-
-            if (filter != GL_NEAREST && filter != GL_LINEAR) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidEnum,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
-                                                 "`filter` must be GL_NEAREST or GL_LINEAR."));
-                return false;
-            }
-
-            if ((mask & (GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT)) != 0 && filter != GL_NEAREST) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidOperation,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
-                                                 "Depth/stencil blit requires GL_NEAREST filter."));
-                return false;
-            }
-
-            const auto readFbo = MG_State::pGLContext->GetFramebufferBindingSlot(FramebufferTarget::Read).GetBoundObject();
-            const auto drawFbo = MG_State::pGLContext->GetFramebufferBindingSlot(FramebufferTarget::Draw).GetBoundObject();
-            if (!readFbo || !drawFbo) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidOperation,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
-                                                 "Read/draw framebuffer binding is null."));
-                return false;
-            }
-
-            if (!readFbo->CheckCompleteness() || !drawFbo->CheckCompleteness()) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidFramebufferOperation,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
-                                                 "Read/draw framebuffer is incomplete."));
-                return false;
-            }
-
-            return true;
     }
 
     void SampleMaski_State(GLuint maskNumber, GLbitfield mask) {
@@ -138,12 +70,6 @@ namespace MobileGL {
         // TODO: implement
     }
 
-        void GenerateMipmap_Backend(GLenum target) {
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
-            MG_Backend::DirectGLES::GenerateMipmap(target);
-#endif
-        }
-
     void GenRenderbuffers_State(GLsizei n, GLuint* renderbuffers) {
         if (n < 0) {
             MG_State::pGLContext->RecordError(
@@ -175,8 +101,7 @@ namespace MobileGL {
         // TODO: implement
     }
 
-        void FramebufferTexture2D_State(GLenum target, GLenum attachment, GLenum textarget, GLuint texture,
+    void FramebufferTexture2D_State(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {
-                                        GLint level) {
         if (target == GL_FRAMEBUFFER) {
             target = GL_DRAW_FRAMEBUFFER;
         }
@@ -220,8 +145,7 @@ namespace MobileGL {
         framebufferObject->AttachTexture(attachmentType, textureObject, textureObject ? level : 0);
     }
 
-        void FramebufferTexture1D_State(GLenum target, GLenum attachment, GLenum textarget, GLuint texture,
+    void FramebufferTexture1D_State(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {
-                                        GLint level) {
         // TODO: implement
     }
 
@@ -277,8 +201,7 @@ namespace MobileGL {
         } else if (n > MG_State::GLState::FramebufferObject::MAX_DRAW_BUFFERS) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidValue,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
+                MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "`n` is greater than `GL_MAX_DRAW_BUFFERS`."));
-                                                 "`n` is greater than `GL_MAX_DRAW_BUFFERS`."));
             return;
         }
 
@@ -288,8 +211,7 @@ namespace MobileGL {
         bool isDefaultFBO = (fbo == FramebufferImpl::pDefaultFramebufferInfo->defaultFBO);
 
         static int existenceMap[(SizeT)FramebufferAttachmentType::FramebufferAttachmentTypeCount] = {-1};
-            std::fill(existenceMap, existenceMap + (SizeT)FramebufferAttachmentType::FramebufferAttachmentTypeCount,
+        std::fill(existenceMap, existenceMap + (SizeT)FramebufferAttachmentType::FramebufferAttachmentTypeCount, -1);
-                      -1);
 
         for (GLsizei i = 0; i < n; ++i) {
             auto attType = MG_Util::ConvertGLEnumToFramebufferAttachmentType(bufs[i]);
@@ -390,8 +312,8 @@ namespace MobileGL {
     void DeleteRenderbuffers_State(GLsizei n, const GLuint* renderbuffers) {
         if (n < 0) {
             MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "DeleteRenderbuffers_State",
+                ErrorCode::InvalidValue,
-                                                                          "n must be non-negative."));
+                MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "DeleteRenderbuffers_State", "n must be non-negative."));
             return;
         }
 
@@ -413,14 +335,14 @@ namespace MobileGL {
     void DeleteFramebuffers_State(GLsizei n, const GLuint* framebuffers) {
         if (n < 0) {
             MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "DeleteFramebuffers_State",
+                ErrorCode::InvalidValue,
-                                                                          "n must be non-negative."));
+                MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "DeleteFramebuffers_State", "n must be non-negative."));
             return;
         }
 
         if (!framebuffers) {
-                MG_State::pGLContext->RecordError(
+            MG_State::pGLContext->RecordError(ErrorCode::InvalidValue,
-                    ErrorCode::InvalidValue, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "DeleteFramebuffers_State",
+                                              MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "DeleteFramebuffers_State",
                                                                            "Framebuffer names array cannot be null."));
             return;
         }
@@ -548,38 +470,29 @@ namespace MobileGL {
     }
 
     void ClearBufferfi_Backend(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) {
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
+        MG_Backend::gBackendFunctionsTable.GL.ClearBufferfi(buffer, drawbuffer, depth, stencil);
-            MG_Backend::DirectGLES::ClearBufferfi(buffer, drawbuffer, depth, stencil);
-#endif
     }
 
     void ClearBufferfv_Backend(GLenum buffer, GLint drawbuffer, const GLfloat* value) {
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
+        MG_Backend::gBackendFunctionsTable.GL.ClearBufferfv(buffer, drawbuffer, value);
-            MG_Backend::DirectGLES::ClearBufferfv(buffer, drawbuffer, value);
-#endif
     }
 
     void ClearBufferuiv_Backend(GLenum buffer, GLint drawbuffer, const GLuint* value) {
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
+        MG_Backend::gBackendFunctionsTable.GL.ClearBufferuiv(buffer, drawbuffer, value);
-            MG_Backend::DirectGLES::ClearBufferuiv(buffer, drawbuffer, value);
-#endif
     }
 
     void ClearBufferiv_Backend(GLenum buffer, GLint drawbuffer, const GLint* value) {
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
+        MG_Backend::gBackendFunctionsTable.GL.ClearBufferiv(buffer, drawbuffer, value);
-            MG_Backend::DirectGLES::ClearBufferiv(buffer, drawbuffer, value);
-#endif
     }
 
-        void ReadPixels_State(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type,
+    void ReadPixels_State(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels) {
-                              void* pixels) {
         TextureInputFormat textureInputFormat = MG_Util::ConvertGLEnumToTextureInputFormat(format);
         TexturePixelDataType texturePixelDataType = MG_Util::ConvertGLEnumToTexturePixelDataType(type);
 
         // Check width/height
         if (width < 0 || height < 0) {
-                MG_State::pGLContext->RecordError(
+            MG_State::pGLContext->RecordError(ErrorCode::InvalidValue,
-                    ErrorCode::InvalidValue, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ReadPixels_State",
+                                              MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ReadPixels_State",
                                                                            "Width and height must be non-negative"));
             return;
         }
@@ -664,8 +577,7 @@ namespace MobileGL {
             // Check if PBO is mapped
             if (pixelPackBufferObject->IsMapped()) {
                 MG_State::pGLContext->RecordError(
-                        ErrorCode::InvalidOperation,
+                    ErrorCode::InvalidOperation, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ReadPixels_State",
-                        MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ReadPixels_State",
                                                                               "Pixel pack buffer is currently mapped"));
                 return;
             }
@@ -694,11 +606,8 @@ namespace MobileGL {
         }
     }
 
-        void ReadPixels_Backend(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type,
+    void ReadPixels_Backend(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels) {
-                                void* pixels) {
+        MG_Backend::gBackendFunctionsTable.GL.ReadPixels(x, y, width, height, format, type, pixels);
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
-            MG_Backend::DirectGLES::ReadPixels(x, y, width, height, format, type, pixels);
-#endif
     }
 
     /* @INSERTION_POINT:FUNCTION_IMPLEMENTATION@ */
@@ -748,10 +657,6 @@ namespace MobileGL {
         GetFramebufferAttachmentParameteriv_State(target, attachment, pname, params);
     }
 
-        void GenerateMipmap(GLenum target) {
-            GenerateMipmap_Backend(target);
-        }
-
     void GenRenderbuffers(GLsizei n, GLuint* renderbuffers) {
         GenRenderbuffers_State(n, renderbuffers);
     }
@@ -811,9 +716,6 @@ namespace MobileGL {
 
     void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1,
                          GLint dstY1, GLbitfield mask, GLenum filter) {
-            if (!BlitFramebuffer_State(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter)) {
-                return;
-            }
         BlitFramebuffer_Backend(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
     }
 
@@ -831,6 +733,5 @@ namespace MobileGL {
 
     namespace FramebufferImpl {
         DefaultFramebufferInfo* pDefaultFramebufferInfo;
-        }
+    } // namespace FramebufferImpl
-    } // namespace MG_Impl::GLImpl
+} // namespace MobileGL::MG_Impl::GLImpl
-} // namespace MobileGL

MobileGL/MG_Impl/GLImpl/Framebuffer/GL_Framebuffer.h

@@ -29,14 +29,8 @@ namespace MobileGL {
         void DeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers);
         void BindRenderbuffer(GLenum target, GLuint renderbuffer);
         void SampleMaski(GLuint maskNumber, GLbitfield mask);
-        void RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width,
-                                            GLsizei height);
-        void RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
-        GLboolean IsRenderbuffer(GLuint renderbuffer);
         GLboolean IsFramebuffer(GLuint framebuffer);
         void GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params);
-        void GenerateMipmap(GLenum target);
-        void GenRenderbuffers(GLsizei n, GLuint* renderbuffers);
         void GenFramebuffers(GLsizei n, GLuint* framebuffers);
         void FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
         void FramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level,
@@ -44,16 +38,13 @@ namespace MobileGL {
         void FramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
         void FramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
         void FramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level);
-        void FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
         void DrawBuffer(GLenum buf);
         void DrawBuffers(GLsizei n, const GLenum* bufs);
         void ReadBuffer(GLenum src);
-        void DeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers);
         void DeleteFramebuffers(GLsizei n, const GLuint* framebuffers);
         GLenum CheckFramebufferStatus(GLenum target);
         void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1,
                              GLint dstY1, GLbitfield mask, GLenum filter);
-        void BindRenderbuffer(GLenum target, GLuint renderbuffer);
         void BindFramebuffer(GLenum target, GLuint framebuffer);
 
         namespace FramebufferImpl {

MobileGL/MG_Impl/GLImpl/Getter/GL_Getter.cpp

@@ -7,6 +7,8 @@
 // End of Source File Header
 
 #include "GL_Getter.h"
+#include "GL/gl.h"
+#include "MG_Util/Debug/Log.h"
 #include <Config.h>
 #include <MGGitHash.h>
 #include <MG_State/GLState/Core.h>
@@ -16,48 +18,9 @@
 #include <MG_Util/Converters/MGToStr/GLExtensionConverter.h>
 #include <MG_Util/Converters/MGToGL/RenderStateEnumConverter.h>
 #include <MG_State/GLState/FramebufferState/FramebufferObject.h>
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
+#include <MG_Backend/BackendObjects.h>
-#include <MG_Backend/DirectGLES/DirectGLES.h>
-#include "MG_Util/BackendLoaders/OpenGL/Loader.h"
-#endif
-
-namespace MobileGL {
-    namespace MG_Impl::GLImpl {
-        const GLubyte* GetString_Backend(GLenum name) {
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
-            return MG_Backend::DirectGLES::GetString(name);
-#endif
-            return (const GLubyte*)"3.3 <Unknown>";
-        }
-
-        inline String GetFormattedBackendGLVersion() {
-            const char* raw = reinterpret_cast<const char*>(GetString_Backend(GL_VERSION));
-            if (!raw || raw[0] == '\0') {
-                return "Unknown";
-            }
-
-            constexpr SizeT kOpenGLESLen = 9; // "OpenGL ES"
-            if (std::strncmp(raw, "OpenGL ES", kOpenGLESLen) == 0) {
-                std::istringstream iss(raw);
-                String a, b, c;
-                if (iss >> a >> b >> c) {
-                    return a + " " + b + " " + c; // e.g. "OpenGL ES 3.2"
-                } else {
-                    return "OpenGL ES ?";
-                }
-            }
-
-            {
-                std::istringstream iss(raw);
-                String ver;
-                if (iss >> ver) {
-                    return String("OpenGL ") + ver; // e.g. "OpenGL 4.6"
-                }
-            }
-
-            return "Unknown";
-        }
 
+namespace MobileGL::MG_Impl::GLImpl {
     /* @INSERTION_POINT:FUNCTION_IMPLEMENTATION@ */
     const GLubyte* GetString(GLenum name) {
         static String vendorString;
@@ -65,50 +28,58 @@ namespace MobileGL {
         static String rendererString;
         static String shadingLanguageVersion;
         static String extensionsString;
+        const auto& activeBackendObject = MG_Backend::pActiveBackendObject;
+
         MGLOG_D("glGetString, name: %s", MG_Util::ConvertGLEnumToString(name).c_str());
+        if (!activeBackendObject) {
+            MGLOG_E("activeBackendObject is not initialized!");
+            return (GLubyte*)"Unknown";
+        }
+
+        const auto& rendererInfo = activeBackendObject->GetRendererInfo();
+
         switch (name) {
         case GL_VENDOR:
             if (vendorString.empty()) {
-                    if (MG_Config::RendererInfoPtr->ExtraVendor.has_value()) {
+                if (rendererInfo.ExtraVendor.has_value()) {
-                        vendorString =
+                    vendorString = std::format("{}{}", MG_Config::CoreVendor, rendererInfo.ExtraVendor.value());
-                            std::format("{}{}", MG_Config::CoreVendor, MG_Config::RendererInfoPtr->ExtraVendor.value());
                 } else {
                     vendorString = MG_Config::CoreVendor;
                 }
             }
+            MGLOG_D("vendorString: %s", vendorString.c_str());
             return (const GLubyte*)vendorString.c_str();
         case GL_VERSION: {
             if (versionStr.empty()) {
-                    versionStr = std::format(
+                versionStr =
-                        "{} {} {}, {} Backend, GIT@" GIT_COMMIT_HASH_SHORT,
+                    std::format("{} {} {}, {} Backend, GIT@" GIT_COMMIT_HASH_SHORT,
-                        MG_Config::RendererInfoPtr->RendererGLInfo.TargetGLVersion.toString().c_str(),
+                                rendererInfo.RendererGLInfo.TargetGLVersion.toString(), MG_Config::ProjectName,
-                        MG_Config::ProjectName.c_str(),
+                                MG_Config::CoreVersion.toFormattedString(MG_Config::DefaultVersionStringFormatAttrib),
-                        MG_Config::CoreVersion.toFormattedString(MG_Config::DefaultVersionStringFormatAttrib).c_str(),
+                                rendererInfo.BackendName);
-                        MG_Config::RendererInfoPtr->BackendName.c_str());
             }
+            MGLOG_D("versionStr: %s", versionStr.c_str());
             return (const GLubyte*)versionStr.c_str();
         }
         case GL_RENDERER: {
             if (rendererString.empty()) {
-                    const char* backendStr = (const char*)GetString_Backend(GL_RENDERER);
+                String backendVersionStr = activeBackendObject->GetBackendAPIVersionString();
-                    String backendVersionStr = GetFormattedBackendGLVersion();
+                rendererString =
-                    rendererString = std::format("{} ({}) ({}, {})", MG_Config::RendererInfoPtr->RendererName.c_str(),
+                    std::format("{} ({}) ({})", rendererInfo.RendererName, MG_Config::CoreName, backendVersionStr);
-                                                 MG_Config::CoreName.c_str(), backendStr ? backendStr : "<Unknown GPU>",
-                                                 !backendVersionStr.empty() ? backendVersionStr : "<Unknown Version>");
             }
+            MGLOG_D("rendererString: %s", rendererString.c_str());
             return (const GLubyte*)rendererString.c_str();
         }
         case GL_SHADING_LANGUAGE_VERSION:
             if (shadingLanguageVersion.empty()) {
-                    shadingLanguageVersion = std::format(
+                shadingLanguageVersion =
-                        "{} {}",
+                    std::format("{} {}", rendererInfo.RendererGLInfo.TargetGLSLVersion.toString({true, false}),
-                        MG_Config::RendererInfoPtr->RendererGLInfo.TargetGLSLVersion.toString({true, false}).c_str(),
+                                MG_Config::ProjectName);
-                        MG_Config::ProjectName.c_str());
             }
+            MGLOG_D("shadingLanguageVersion: %s", shadingLanguageVersion.c_str());
             return (const GLubyte*)shadingLanguageVersion.c_str();
         case GL_EXTENSIONS:
             if (extensionsString.empty()) {
-                    for (auto& ext : MG_Config::RendererInfoPtr->RendererGLInfo.Extensions) {
+                for (auto& ext : rendererInfo.RendererGLInfo.Extensions) {
                     extensionsString += MG_Util::ConvertGLExtToString(ext);
                     extensionsString += " ";
                 }
@@ -126,7 +97,14 @@ namespace MobileGL {
             return (const GLubyte*)"";
         }
 
-            const auto& exts = MG_Config::RendererInfoPtr->RendererGLInfo.Extensions;
+        const auto& activeBackendObject = MG_Backend::pActiveBackendObject;
+        if (!activeBackendObject) {
+            MGLOG_E("activeBackendObject is not initialized!");
+            return (GLubyte*)"Unknown";
+        }
+        const auto& rendererInfo = activeBackendObject->GetRendererInfo();
+
+        const auto& exts = rendererInfo.RendererGLInfo.Extensions;
         if (index >= exts.size()) {
             return nullptr;
         }
@@ -153,6 +131,13 @@ namespace MobileGL {
             return;
         }
 
+        const auto& activeBackendObject = MG_Backend::pActiveBackendObject;
+        if (!activeBackendObject) {
+            MGLOG_E("activeBackendObject is not initialized!");
+            return;
+        }
+        const auto& rendererInfo = activeBackendObject->GetRendererInfo();
+
         switch (pname) {
         case GL_ACTIVE_TEXTURE:
             *params = MG_State::pGLContext->GetActiveTextureUnit() + GL_TEXTURE0;
@@ -302,14 +287,12 @@ namespace MobileGL {
             *params = 0; // TODO
             break;
         case GL_DRAW_FRAMEBUFFER_BINDING: {
-                const auto& FBO =
+            const auto& FBO = MG_State::pGLContext->GetFramebufferBindingSlot(FramebufferTarget::Draw).GetBoundObject();
-                    MG_State::pGLContext->GetFramebufferBindingSlot(FramebufferTarget::Draw).GetBoundObject();
             *params = FBO ? FBO->GetExternalIndex() : 0;
             break;
         }
         case GL_READ_FRAMEBUFFER_BINDING: {
-                const auto& FBO =
+            const auto& FBO = MG_State::pGLContext->GetFramebufferBindingSlot(FramebufferTarget::Read).GetBoundObject();
-                    MG_State::pGLContext->GetFramebufferBindingSlot(FramebufferTarget::Read).GetBoundObject();
             *params = FBO ? FBO->GetExternalIndex() : 0;
             break;
         }
@@ -318,8 +301,7 @@ namespace MobileGL {
                 *params = 0;
                 break;
             }
-                const auto& bufferObject =
+            const auto& bufferObject = MG_State::pGLContext->GetBufferBindingSlot(BufferTarget::Index).GetBoundObject();
-                    MG_State::pGLContext->GetBufferBindingSlot(BufferTarget::Index).GetBoundObject();
             *params = bufferObject ? bufferObject->GetExternalIndex() : 0;
             break;
         }
@@ -348,7 +330,7 @@ namespace MobileGL {
             *params = 0; // TODO
             break;
         case GL_MAJOR_VERSION:
-                *params = MG_Config::RendererInfoPtr->RendererGLInfo.TargetGLVersion.Major;
+            *params = rendererInfo.RendererGLInfo.TargetGLVersion.Major;
             break;
         case GL_MAX_3D_TEXTURE_SIZE:
             *params = 1024 * 16; // TODO
@@ -547,13 +529,13 @@ namespace MobileGL {
             *params = 16; // TODO
             break;
         case GL_MINOR_VERSION:
-                *params = MG_Config::RendererInfoPtr->RendererGLInfo.TargetGLVersion.Minor;
+            *params = rendererInfo.RendererGLInfo.TargetGLVersion.Minor;
             break;
         case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
             *params = 18; // TODO
             break;
         case GL_NUM_EXTENSIONS:
-                *params = static_cast<GLint>(MG_Config::RendererInfoPtr->RendererGLInfo.Extensions.size());
+            *params = (Int)rendererInfo.RendererGLInfo.Extensions.size();
             break;
         case GL_NUM_PROGRAM_BINARY_FORMATS:
             *params = 2; // TODO
@@ -604,8 +586,7 @@ namespace MobileGL {
             *params = 0; // TODO
             break;
         case GL_PROGRAM_POINT_SIZE:
-                *params =
+            *params = MG_State::pGLContext->IsCapabilityEnabled(CapabilityInput::ProgramPointSize) ? GL_TRUE : GL_FALSE;
-                    MG_State::pGLContext->IsCapabilityEnabled(CapabilityInput::ProgramPointSize) ? GL_TRUE : GL_FALSE;
             break;
         case GL_PROVOKING_VERTEX:
             *params = 0; // TODO
@@ -638,8 +619,7 @@ namespace MobileGL {
                 MG_State::pGLContext->IsCapabilityEnabled(CapabilityInput::PolygonOffsetPoint) ? GL_TRUE : GL_FALSE;
             break;
         case GL_POLYGON_SMOOTH:
-                *params =
+            *params = MG_State::pGLContext->IsCapabilityEnabled(CapabilityInput::PolygonSmooth) ? GL_TRUE : GL_FALSE;
-                    MG_State::pGLContext->IsCapabilityEnabled(CapabilityInput::PolygonSmooth) ? GL_TRUE : GL_FALSE;
             break;
         case GL_POLYGON_SMOOTH_HINT:
             *params = 0; // TODO
@@ -721,7 +701,7 @@ namespace MobileGL {
             *params = 0; // TODO
             break;
         case GL_STENCIL_CLEAR_VALUE:
-                *params = MG_State::pGLContext->GetClearStencil();
+            *params = 0; // TODO
             break;
         case GL_STENCIL_FAIL:
             *params = 0; // TODO
@@ -821,11 +801,7 @@ namespace MobileGL {
             *params = 0; // TODO
             break;
         case GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT:
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
+            *params = (Int)activeBackendObject->GetDynamicParameters().UniformBufferOffsetAlignment;
-                *params = MG_External::GLES::g_glesCaps.uniformBufferOffsetAlignment;
-#else
-                *params = 256;
-#endif
             break;
         case GL_UNIFORM_BUFFER_SIZE:
             *params = 0; // TODO
@@ -909,8 +885,8 @@ namespace MobileGL {
             break;
         default:
             MGLOG_E("glGetIntegerv: Invalid enum %s (0x%X)", MG_Util::ConvertGLEnumToString(pname).c_str(), pname);
-                MG_State::pGLContext->RecordError(
+            MG_State::pGLContext->RecordError(ErrorCode::InvalidEnum,
-                    ErrorCode::InvalidEnum, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "GetIntegerv",
+                                              MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "GetIntegerv",
                                                                            std::format("Invalid enum: 0x{:X}", pname)));
 
             break;
@@ -921,5 +897,4 @@ namespace MobileGL {
         ErrorCode errorCode = MG_State::pGLContext->PopGLError().value_or(Error{ErrorCode::NoError, nullptr}).code;
         return MG_Util::ConvertErrorCodeToGLEnum(errorCode);
     }
-    } // namespace MG_Impl::GLImpl
+} // namespace MobileGL::MG_Impl::GLImpl
-} // namespace MobileGL

MobileGL/MG_Impl/GLImpl/Getter/GL_Getter.h

@@ -9,12 +9,10 @@
 #pragma once
 #include <Includes.h>
 
-namespace MobileGL {
+namespace MobileGL::MG_Impl::GLImpl {
-    namespace MG_Impl::GLImpl {
     /* @INSERTION_POINT:FUNCTION_DECLARATION@ */
     const GLubyte* GetString(GLenum name);
     const GLubyte* GetStringi(GLenum name, GLuint index);
     void GetIntegerv(GLenum pname, GLint* params);
     GLenum GetError();
-    } // namespace MG_Impl::GLImpl
+} // namespace MobileGL::MG_Impl::GLImpl
-} // namespace MobileGL

MobileGL/MG_Impl/GLImpl/Program/GL_Program.cpp

@@ -477,7 +477,19 @@ namespace MobileGL {
             auto programObject = TryToGetProgramObject(program);
             if (!programObject) return;
             MGLOG_D("%s: linking program %d", __func__, program);
-            programObject->Link(!MG_Config::RendererInfoPtr->BackendCapability.AllowVSOnlyPrograms);
+
+            static Bool allowVSOnlyPrograms;
+            static Bool initialized = false;
+            if (!initialized) {
+                const auto& activeBackendObject = MG_Backend::pActiveBackendObject;
+                if (!activeBackendObject) {
+                    MGLOG_E("activeBackendObject is not initialized!");
+                    return;
+                }
+                const auto& rendererInfo = activeBackendObject->GetRendererInfo();
+                allowVSOnlyPrograms = (Int)rendererInfo.StaticBackendCapability.AllowVSOnlyPrograms;
+            }
+            programObject->Link(!allowVSOnlyPrograms);
         }
 
         void ShaderSource_State(GLuint shader, GLsizei count, const GLchar* const* string, const GLint* length) {

MobileGL/MG_Impl/GLImpl/Texture/GL_Texture.cpp

@@ -13,6 +13,7 @@
 #include "ProxyTexture.h"
 
 #include <MG_State/GLState/Core.h>
+#include <MG_Backend/BackendObjects.h>
 #include <MG_Util/Metrics/TextureMetrics.h>
 #include <MG_State/GLState/ErrorState/Error.h>
 #include <MG_Util/Texture/PixelStoreProcessor.h>
@@ -25,21 +26,15 @@
 #include <MG_Util/Converters/MGToStr/TextureEnumConverter.h>
 #include <MG_State/GLState/TextureState/TextureObjectBuffer.h>
 
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
+namespace MobileGL::MG_Impl::GLImpl {
-#include <MG_Backend/DirectGLES/DirectGLES.h>
+    SharedPtr<MG_State::GLState::ITextureObject> GetTextureObjectByTarget(TextureUploadTarget textureUploadingTarget,
-#endif
+                                                                          TextureTarget textureTarget) {
-
-namespace MobileGL {
-    namespace MG_Impl::GLImpl {
-        SharedPtr<MG_State::GLState::ITextureObject> GetTextureObjectByTarget(
-            TextureUploadTarget textureUploadingTarget, TextureTarget textureTarget) {
         SharedPtr<MG_State::GLState::ITextureObject> textureObject = nullptr;
         if (TextureImpl::IsProxyTextureTarget(textureUploadingTarget)) {
             textureObject =
                 TextureImpl::pProxyTextureManager->CreateOrReplaceProxyTextureObject(textureUploadingTarget);
         } else {
-                auto activeUnit =
+            auto activeUnit = MG_State::pGLContext->GetTextureUnitObject(MG_State::pGLContext->GetActiveTextureUnit());
-                    MG_State::pGLContext->GetTextureUnitObject(MG_State::pGLContext->GetActiveTextureUnit());
             auto& bindingSlot = activeUnit.GetBindingSlot(textureTarget);
             textureObject = bindingSlot.GetBoundObject();
         }
@@ -49,13 +44,17 @@ namespace MobileGL {
         return textureObject;
     }
 
+    void GenerateMipmap_Backend(GLenum target) {
+        MG_Backend::gBackendFunctionsTable.GL.GenerateMipmap(target);
+    }
+
     void TexSubImage3D_State(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width,
                              GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* pixels) {
         // TODO: implement
     }
 
-        void TexSubImage2D_State(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width,
+    void TexSubImage2D_State(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
-                                 GLsizei height, GLenum format, GLenum type, const void* pixels) {
+                             GLenum format, GLenum type, const void* pixels) {
         // ======================= Converting ================================
         TextureUploadTarget textureUploadingTarget = MG_Util::ConvertGLEnumToTextureUploadTarget(target);
         TextureTarget textureTarget = MG_Util::ConvertGLEnumToTextureTarget(target);
@@ -93,8 +92,8 @@ namespace MobileGL {
         // ===================== Error Checking ==============================
         if (!TextureImpl::ValidateTextureObject(textureObject)) return;
         if (!TextureImpl::ValidateTextureSubImageOffsets(textureObject, xoffset, width, yoffset, height)) return;
-            if (!TextureImpl::ValidateTextureInternalFormatCompatibleWithInput(
+        if (!TextureImpl::ValidateTextureInternalFormatCompatibleWithInput(textureInputFormat, textureInternalFormat,
-                    textureInputFormat, textureInternalFormat, texturePixelDataType))
+                                                                           texturePixelDataType))
             return;
 
         // ======================= Processing ================================
@@ -134,8 +133,8 @@ namespace MobileGL {
             {width, height, 1}, false, inputSize);
 
         if (!processedPixels || inputSize == 0) {
-                MGLOG_E("TexSubImage2D_State: Failed to process pixel data for TexSubImage2D, width: %d, height: %d",
+            MGLOG_E("TexSubImage2D_State: Failed to process pixel data for TexSubImage2D, width: %d, height: %d", width,
-                        width, height);
+                    height);
             if (processedPixels) free(processedPixels);
             return;
         }
@@ -233,8 +232,7 @@ namespace MobileGL {
             textureObject->GetSamplerObject()->SetCompareMode(MG_Util::ConvertGLEnumToSamplerCompareMode(param));
             break;
         case GL_TEXTURE_COMPARE_FUNC:
-                textureObject->GetSamplerObject()->SetSamplerCompareFunc(
+            textureObject->GetSamplerObject()->SetSamplerCompareFunc(MG_Util::ConvertGLEnumToSamplerCompareFunc(param));
-                    MG_Util::ConvertGLEnumToSamplerCompareFunc(param));
             break;
         case GL_TEXTURE_LOD_BIAS:
             textureObject->GetSamplerObject()->SetLodBias(param);
@@ -246,9 +244,9 @@ namespace MobileGL {
         default:
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidEnum,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
+                MakeShared<GenericErrorInfo>(
-                                                 std::format("pname {} is not a valid texture parameter.",
+                    "MG_Impl/GLImpl", __func__,
-                                                             MG_Util::ConvertGLEnumToString(pname))));
+                    std::format("pname {} is not a valid texture parameter.", MG_Util::ConvertGLEnumToString(pname))));
             return;
         }
     }
@@ -309,8 +307,7 @@ namespace MobileGL {
             textureObject->GetSamplerObject()->SetCompareMode(MG_Util::ConvertGLEnumToSamplerCompareMode(param));
             break;
         case GL_TEXTURE_COMPARE_FUNC:
-                textureObject->GetSamplerObject()->SetSamplerCompareFunc(
+            textureObject->GetSamplerObject()->SetSamplerCompareFunc(MG_Util::ConvertGLEnumToSamplerCompareFunc(param));
-                    MG_Util::ConvertGLEnumToSamplerCompareFunc(param));
             break;
         case GL_TEXTURE_LOD_BIAS:
             textureObject->GetSamplerObject()->SetLodBias((GLfloat)param);
@@ -322,9 +319,9 @@ namespace MobileGL {
         default:
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidEnum,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
+                MakeShared<GenericErrorInfo>(
-                                                 std::format("pname {} is not a valid texture parameter.",
+                    "MG_Impl/GLImpl", __func__,
-                                                             MG_Util::ConvertGLEnumToString(pname))));
+                    std::format("pname {} is not a valid texture parameter.", MG_Util::ConvertGLEnumToString(pname))));
             return;
         }
     }
@@ -504,16 +501,13 @@ namespace MobileGL {
             "%s called with target: %s, level: %d, internalformat: %s, width: %d, height: %d, depth: %d, "
             "border: %d, format: %s, type: %s (%u), pixels: %p",
             __func__,
-                MG_Util::ConvertTextureUploadTargetToString(MG_Util::ConvertGLEnumToTextureUploadTarget(target))
+            MG_Util::ConvertTextureUploadTargetToString(MG_Util::ConvertGLEnumToTextureUploadTarget(target)).c_str(),
-                    .c_str(),
             level,
-                MG_Util::ConvertTextureInternalFormatToString(
+            MG_Util::ConvertTextureInternalFormatToString(MG_Util::ConvertGLEnumToTextureInternalFormat(internalformat))
-                    MG_Util::ConvertGLEnumToTextureInternalFormat(internalformat))
                 .c_str(),
             width, height, depth, border,
             MG_Util::ConvertTextureInputFormatToString(MG_Util::ConvertGLEnumToTextureInputFormat(format)).c_str(),
-                MG_Util::ConvertTexturePixelDataTypeToString(MG_Util::ConvertGLEnumToTexturePixelDataType(type))
+            MG_Util::ConvertTexturePixelDataTypeToString(MG_Util::ConvertGLEnumToTexturePixelDataType(type)).c_str(),
-                    .c_str(),
             type, pixels);
         // ======================= Converting ================================
         TextureUploadTarget textureUploadingTarget = MG_Util::ConvertGLEnumToTextureUploadTarget(target);
@@ -531,8 +525,8 @@ namespace MobileGL {
         if (!TextureImpl::ValidateTextureSizeRange(width, height, depth)) return;
         if (!TextureImpl::ValidateTextureInternalFormat(textureInternalFormat)) return;
         if (!TextureImpl::ValidateTextureBorderNumber(border)) return;
-            if (!TextureImpl::ValidateTextureInternalFormatCompatibleWithInput(
+        if (!TextureImpl::ValidateTextureInternalFormatCompatibleWithInput(textureInputFormat, textureInternalFormat,
-                    textureInputFormat, textureInternalFormat, texturePixelDataType))
+                                                                           texturePixelDataType))
             return;
         if (!TextureImpl::ValidateTextureLevelWithUploadTarget(textureUploadingTarget, level)) return;
 
@@ -551,8 +545,7 @@ namespace MobileGL {
             textureObject =
                 TextureImpl::pProxyTextureManager->CreateOrReplaceProxyTextureObject(textureUploadingTarget);
         } else {
-                auto activeUnit =
+            auto activeUnit = MG_State::pGLContext->GetTextureUnitObject(MG_State::pGLContext->GetActiveTextureUnit());
-                    MG_State::pGLContext->GetTextureUnitObject(MG_State::pGLContext->GetActiveTextureUnit());
             auto& bindingSlot = activeUnit.GetBindingSlot(textureTarget);
             textureObject = bindingSlot.GetBoundObject();
         }
@@ -589,8 +582,7 @@ namespace MobileGL {
         auto textureMipmapObject = static_cast<MG_State::GLState::TextureObjectMipmap*>(textureObject.get());
 
         // Allocate in TextureObject
-            textureMipmapObject->AllocateStorage(textureUploadingTarget, level,
+        textureMipmapObject->AllocateStorage(textureUploadingTarget, level, {{width, height, depth}, internalBytes});
-                                                 {{width, height, depth}, internalBytes});
 
         if (!originalPixels) {
             MGLOG_D("%s: No input pixel and no PBO bound, no pixel transfer", __func__);
@@ -619,8 +611,8 @@ namespace MobileGL {
         free(processedPixels);
     }
 
-        void TexImage2D_State(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height,
+    void TexImage2D_State(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border,
-                              GLint border, GLenum format, GLenum type, const void* pixels) {
+                          GLenum format, GLenum type, const void* pixels) {
         // ======================= Converting ================================
         TextureUploadTarget textureUploadingTarget = MG_Util::ConvertGLEnumToTextureUploadTarget(target);
         TextureTarget textureTarget = MG_Util::ConvertGLEnumToTextureTarget(target);
@@ -646,8 +638,8 @@ namespace MobileGL {
         if (!TextureImpl::ValidateTextureSizeRange(width, height, 1)) return;
         if (!TextureImpl::ValidateTextureInternalFormat(textureInternalFormat)) return;
         if (!TextureImpl::ValidateTextureBorderNumber(border)) return;
-            if (!TextureImpl::ValidateTextureInternalFormatCompatibleWithInput(
+        if (!TextureImpl::ValidateTextureInternalFormatCompatibleWithInput(textureInputFormat, textureInternalFormat,
-                    textureInputFormat, textureInternalFormat, texturePixelDataType))
+                                                                           texturePixelDataType))
             return;
         if (!TextureImpl::ValidateTextureLevelWithUploadTarget(textureUploadingTarget, level)) return;
 
@@ -669,8 +661,7 @@ namespace MobileGL {
             textureObject =
                 TextureImpl::pProxyTextureManager->CreateOrReplaceProxyTextureObject(textureUploadingTarget);
         } else {
-                auto activeUnit =
+            auto activeUnit = MG_State::pGLContext->GetTextureUnitObject(MG_State::pGLContext->GetActiveTextureUnit());
-                    MG_State::pGLContext->GetTextureUnitObject(MG_State::pGLContext->GetActiveTextureUnit());
             auto& bindingSlot = activeUnit.GetBindingSlot(textureTarget);
             textureObject = bindingSlot.GetBoundObject();
         }
@@ -743,8 +734,8 @@ namespace MobileGL {
         textureMipmapObject->MarkStorageDirty(textureUploadingTarget, level, true);
     }
 
-        void TexImage1D_State(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border,
+    void TexImage1D_State(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format,
-                              GLenum format, GLenum type, const GLvoid* pixels) {
+                          GLenum type, const GLvoid* pixels) {
         // TODO: implement
         THROW_UNIMPL_EXCEPTION;
     }
@@ -763,8 +754,7 @@ namespace MobileGL {
         if (!bufferObject) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidOperation,
-                    MakeShared<GenericErrorInfo>(
+                MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
-                        "MG_Impl/GLImpl", __func__,
                                              "`buffer` is not zero and is not the name of an existing buffer object."));
             return;
         }
@@ -819,8 +809,7 @@ namespace MobileGL {
         if (TextureImpl::IsProxyTextureTarget(textureUploadingTarget)) {
             textureObject = TextureImpl::pProxyTextureManager->GetProxyTextureObject(textureUploadingTarget);
         } else {
-                auto activeUnit =
+            auto activeUnit = MG_State::pGLContext->GetTextureUnitObject(MG_State::pGLContext->GetActiveTextureUnit());
-                    MG_State::pGLContext->GetTextureUnitObject(MG_State::pGLContext->GetActiveTextureUnit());
             auto& bindingSlot = activeUnit.GetBindingSlot(textureTarget);
             textureObject = bindingSlot.GetBoundObject();
         }
@@ -830,14 +819,13 @@ namespace MobileGL {
         switch (pname) {
         case GL_TEXTURE_MAG_FILTER:
             if (params) {
-                    *params = MG_Util::ConvertSamplerFilterModeToGLEnum(
+                *params = MG_Util::ConvertSamplerFilterModeToGLEnum(textureObject->GetSamplerObject()->GetMagFilter(),
-                        textureObject->GetSamplerObject()->GetMagFilter(), SamplerMipmapMode::None);
+                                                                    SamplerMipmapMode::None);
             }
             break;
         case GL_TEXTURE_MIN_FILTER:
             if (params) {
-                    *params =
+                *params = MG_Util::ConvertSamplerFilterModeToGLEnum(textureObject->GetSamplerObject()->GetMinFilter(),
-                        MG_Util::ConvertSamplerFilterModeToGLEnum(textureObject->GetSamplerObject()->GetMinFilter(),
                                                                     textureObject->GetSamplerObject()->GetMipmapMode());
             }
             break;
@@ -883,8 +871,8 @@ namespace MobileGL {
             }
             break;
         default:
-                MG_State::pGLContext->RecordError(
+            MG_State::pGLContext->RecordError(ErrorCode::InvalidEnum,
-                    ErrorCode::InvalidEnum, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "GetTexParameteriv_State",
+                                              MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "GetTexParameteriv_State",
                                                                            "pname is not a valid texture parameter."));
             return;
         }
@@ -900,8 +888,7 @@ namespace MobileGL {
         if (TextureImpl::IsProxyTextureTarget(textureUploadingTarget)) {
             textureObject = TextureImpl::pProxyTextureManager->GetProxyTextureObject(textureUploadingTarget);
         } else {
-                auto activeUnit =
+            auto activeUnit = MG_State::pGLContext->GetTextureUnitObject(MG_State::pGLContext->GetActiveTextureUnit());
-                    MG_State::pGLContext->GetTextureUnitObject(MG_State::pGLContext->GetActiveTextureUnit());
             auto& bindingSlot = activeUnit.GetBindingSlot(textureTarget);
             textureObject = bindingSlot.GetBoundObject();
         }
@@ -911,14 +898,13 @@ namespace MobileGL {
         switch (pname) {
         case GL_TEXTURE_MAG_FILTER:
             if (params) {
-                    *params = MG_Util::ConvertSamplerFilterModeToGLEnum(
+                *params = MG_Util::ConvertSamplerFilterModeToGLEnum(textureObject->GetSamplerObject()->GetMagFilter(),
-                        textureObject->GetSamplerObject()->GetMagFilter(), SamplerMipmapMode::None);
+                                                                    SamplerMipmapMode::None);
             }
             break;
         case GL_TEXTURE_MIN_FILTER:
             if (params) {
-                    *params =
+                *params = MG_Util::ConvertSamplerFilterModeToGLEnum(textureObject->GetSamplerObject()->GetMinFilter(),
-                        MG_Util::ConvertSamplerFilterModeToGLEnum(textureObject->GetSamplerObject()->GetMinFilter(),
                                                                     textureObject->GetSamplerObject()->GetMipmapMode());
             }
             break;
@@ -969,8 +955,8 @@ namespace MobileGL {
             }
             break;
         default:
-                MG_State::pGLContext->RecordError(
+            MG_State::pGLContext->RecordError(ErrorCode::InvalidEnum,
-                    ErrorCode::InvalidEnum, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "GetTexParameterfv_State",
+                                              MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "GetTexParameterfv_State",
                                                                            "pname is not a valid texture parameter."));
             return;
         }
@@ -993,8 +979,7 @@ namespace MobileGL {
         if (TextureImpl::IsProxyTextureTarget(textureUploadingTarget)) {
             textureObject = TextureImpl::pProxyTextureManager->GetProxyTextureObject(textureUploadingTarget);
         } else {
-                auto activeUnit =
+            auto activeUnit = MG_State::pGLContext->GetTextureUnitObject(MG_State::pGLContext->GetActiveTextureUnit());
-                    MG_State::pGLContext->GetTextureUnitObject(MG_State::pGLContext->GetActiveTextureUnit());
             auto& bindingSlot = activeUnit.GetBindingSlot(textureTarget);
             textureObject = bindingSlot.GetBoundObject();
         }
@@ -1064,8 +1049,7 @@ namespace MobileGL {
             break; // TODO
         default:
             MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidEnum,
+                ErrorCode::InvalidEnum, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "GetTexLevelParameteriv_State",
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "GetTexLevelParameteriv_State",
                                                                      "pname is not a valid texture level parameter."));
             return;
         }
@@ -1086,8 +1070,7 @@ namespace MobileGL {
         if (TextureImpl::IsProxyTextureTarget(textureUploadingTarget)) {
             textureObject = TextureImpl::pProxyTextureManager->GetProxyTextureObject(textureUploadingTarget);
         } else {
-                auto activeUnit =
+            auto activeUnit = MG_State::pGLContext->GetTextureUnitObject(MG_State::pGLContext->GetActiveTextureUnit());
-                    MG_State::pGLContext->GetTextureUnitObject(MG_State::pGLContext->GetActiveTextureUnit());
             auto& bindingSlot = activeUnit.GetBindingSlot(textureTarget);
             textureObject = bindingSlot.GetBoundObject();
         }
@@ -1157,8 +1140,7 @@ namespace MobileGL {
             break; // TODO
         default:
             MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidEnum,
+                ErrorCode::InvalidEnum, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "GetTexLevelParameterfv_State",
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "GetTexLevelParameterfv_State",
                                                                      "pname is not a valid texture level parameter."));
             return;
         }
@@ -1214,9 +1196,7 @@ namespace MobileGL {
 
     void CopyTexSubImage2D_Backend(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y,
                                    GLsizei width, GLsizei height) {
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
+        MG_Backend::gBackendFunctionsTable.GL.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
-            MG_Backend::DirectGLES::CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
-#endif
     }
 
     void CopyTexSubImage1D_State(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) {
@@ -1231,8 +1211,7 @@ namespace MobileGL {
         if (!currentReadFBO) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidOperation,
-                    MakeShared<GenericErrorInfo>(
+                MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "CopyTexImage2D_State",
-                        "MG_Impl/GLImpl", "CopyTexImage2D_State",
                                              "No framebuffer is currently bound to the GL_READ_FRAMEBUFFER target."));
             return;
         }
@@ -1264,15 +1243,14 @@ namespace MobileGL {
             GET_SRC_INTERNAL_FORMAT(readBufferType);
         }
 
-            if (!TextureImpl::ValidateBaseInternalFormatMatch(internalFormat, srcInternalFormat))
+        if (!TextureImpl::ValidateBaseInternalFormatMatch(internalFormat, srcInternalFormat)) THROW_UNIMPL_EXCEPTION;
-                THROW_UNIMPL_EXCEPTION;
 
         GLenum outInternalFormat = MG_Util::ConvertTextureInternalFormatToGLEnum(srcInternalFormat);
         GLenum realInternalFormat = GL_RGBA8;
         GLenum format = GL_DEPTH_COMPONENT;
         GLenum type = GL_UNSIGNED_INT;
-            MG_Util::TextureFormatProcessor::NormalizePixelFormat(
+        MG_Util::TextureFormatProcessor::NormalizePixelFormat(outInternalFormat, PixelFormatNormalizeOptionBit::None,
-                outInternalFormat, PixelFormatNormalizeOptionBit::None, &realInternalFormat, &format, &type);
+                                                              &realInternalFormat, &format, &type);
         const auto pixelUnpackBufferObject =
             MG_State::pGLContext->GetBufferBindingSlot(BufferTarget::PixelUnpack).GetBoundObject();
         TexImage2D_State(target, level, realInternalFormat, width, height, border, format, type, nullptr);
@@ -1281,9 +1259,8 @@ namespace MobileGL {
 
     void CopyTexImage2D_Backend(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width,
                                 GLsizei height, GLint border) {
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
+        MG_Backend::gBackendFunctionsTable.GL.CopyTexImage2D(target, level, internalformat, x, y, width, height,
-            MG_Backend::DirectGLES::CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+                                                             border);
-#endif
     }
 
     void CopyTexImage1D_State(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width,
@@ -1293,8 +1270,8 @@ namespace MobileGL {
     }
 
     void CompressedTexSubImage3D_State(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset,
-                                           GLsizei width, GLsizei height, GLsizei depth, GLenum format,
+                                       GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize,
-                                           GLsizei imageSize, const void* data) {
+                                       const void* data) {
         // TODO: implement
         THROW_UNIMPL_EXCEPTION;
     }
@@ -1311,15 +1288,14 @@ namespace MobileGL {
         THROW_UNIMPL_EXCEPTION;
     }
 
-        void CompressedTexImage3D_State(GLenum target, GLint level, GLenum internalformat, GLsizei width,
+    void CompressedTexImage3D_State(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height,
-                                        GLsizei height, GLsizei depth, GLint border, GLsizei imageSize,
+                                    GLsizei depth, GLint border, GLsizei imageSize, const void* data) {
-                                        const void* data) {
         // TODO: implement
         THROW_UNIMPL_EXCEPTION;
     }
 
-        void CompressedTexImage2D_State(GLenum target, GLint level, GLenum internalformat, GLsizei width,
+    void CompressedTexImage2D_State(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height,
-                                        GLsizei height, GLint border, GLsizei imageSize, const void* data) {
+                                    GLint border, GLsizei imageSize, const void* data) {
         // TODO: implement
         THROW_UNIMPL_EXCEPTION;
     }
@@ -1351,8 +1327,7 @@ namespace MobileGL {
             textureObject = MG_State::pGLContext->CreateTextureObject(texture, textureTarget);
         }
 
-            auto& currentUnit =
+        auto& currentUnit = MG_State::pGLContext->GetTextureUnitObject(MG_State::pGLContext->GetActiveTextureUnit());
-                MG_State::pGLContext->GetTextureUnitObject(MG_State::pGLContext->GetActiveTextureUnit());
         auto& bindingSlot = currentUnit.GetBindingSlot(textureTarget);
         bindingSlot.Bind(textureObject);
     }
@@ -1371,13 +1346,11 @@ namespace MobileGL {
         }
 
         // ======================= Processing ================================
-            MG_State::pGLContext->SetActiveTextureUnit(texture - GL_TEXTURE0);
+        MG_State::pGLContext->SetActiveTextureUnit((Int)texture - GL_TEXTURE0);
     }
 
     void GetTexImage_Backend(GLenum target, GLint level, GLenum format, GLenum type, GLvoid* pixels) {
-#if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
+        MG_Backend::gBackendFunctionsTable.GL.GetTexImage(target, level, format, type, pixels);
-            MG_Backend::DirectGLES::GetTexImage(target, level, format, type, pixels);
-#endif
     }
 
     // Add to GL_Texture.cpp
@@ -1426,8 +1399,7 @@ namespace MobileGL {
         if (TextureImpl::IsProxyTextureTarget(textureUploadTarget)) {
             textureObject = TextureImpl::pProxyTextureManager->GetProxyTextureObject(textureUploadTarget);
         } else {
-                auto activeUnit =
+            auto activeUnit = MG_State::pGLContext->GetTextureUnitObject(MG_State::pGLContext->GetActiveTextureUnit());
-                    MG_State::pGLContext->GetTextureUnitObject(MG_State::pGLContext->GetActiveTextureUnit());
             auto& bindingSlot = activeUnit.GetBindingSlot(textureTarget);
             textureObject = bindingSlot.GetBoundObject();
         }
@@ -1455,8 +1427,7 @@ namespace MobileGL {
             // Check if PBO is mapped
             if (pixelPackBufferObject->IsMapped()) {
                 MG_State::pGLContext->RecordError(
-                        ErrorCode::InvalidOperation,
+                    ErrorCode::InvalidOperation, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "GetTexImage_State",
-                        MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "GetTexImage_State",
                                                                               "Pixel pack buffer is currently mapped"));
                 return;
             }
@@ -1499,6 +1470,10 @@ namespace MobileGL {
     }
 
     /* @INSERTION_POINT:FUNCTION_IMPLEMENTATION@ */
+    void GenerateMipmap(GLenum target) {
+        GenerateMipmap_Backend(target);
+    }
+
     void GetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid* pixels) {
         GetTexImage_State(target, level, format, type, pixels);
         GetTexImage_Backend(target, level, format, type, pixels);
@@ -1612,13 +1587,13 @@ namespace MobileGL {
         DeleteTextures_State(n, textures);
     }
 
-        void CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x,
+    void CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y,
-                               GLint y, GLsizei width, GLsizei height) {
+                           GLsizei width, GLsizei height) {
         CopyTexSubImage3D_State(target, level, xoffset, yoffset, zoffset, x, y, width, height);
     }
 
-        void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y,
+    void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width,
-                               GLsizei width, GLsizei height) {
+                           GLsizei height) {
         CopyTexSubImage2D_Backend(target, level, xoffset, yoffset, x, y, width, height);
     }
 
@@ -1637,11 +1612,10 @@ namespace MobileGL {
         CopyTexImage1D_State(target, level, internalformat, x, y, width, border);
     }
 
-        void CompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset,
+    void CompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width,
-                                     GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize,
+                                 GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void* data) {
-                                     const void* data) {
+        CompressedTexSubImage3D_State(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize,
-            CompressedTexSubImage3D_State(target, level, xoffset, yoffset, zoffset, width, height, depth, format,
+                                      data);
-                                          imageSize, data);
     }
 
     void CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width,
@@ -1677,5 +1651,4 @@ namespace MobileGL {
         ActiveTexture_State(texture);
     }
 
-    } // namespace MG_Impl::GLImpl
+} // namespace MobileGL::MG_Impl::GLImpl
-} // namespace MobileGL

MobileGL/MG_Impl/GLImpl/Texture/GL_Texture.h

@@ -9,9 +9,9 @@
 #pragma once
 #include <Includes.h>
 
-namespace MobileGL {
+namespace MobileGL::MG_Impl::GLImpl {
-    namespace MG_Impl::GLImpl {
     /* @INSERTION_POINT:FUNCTION_DECLARATION@ */
+    void GenerateMipmap(GLenum target);
     void GetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid* pixels);
     void TexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width,
                        GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* pixels);
@@ -47,18 +47,17 @@ namespace MobileGL {
     void GetCompressedTexImage(GLenum target, GLint level, void* img);
     void GenTextures(GLsizei n, GLuint* textures);
     void DeleteTextures(GLsizei n, const GLuint* textures);
-        void CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x,
+    void CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y,
-                               GLint y, GLsizei width, GLsizei height);
-        void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y,
                            GLsizei width, GLsizei height);
+    void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width,
+                           GLsizei height);
     void CopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
     void CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width,
                         GLsizei height, GLint border);
     void CopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width,
                         GLint border);
-        void CompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset,
+    void CompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width,
-                                     GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize,
+                                 GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void* data);
-                                     const void* data);
     void CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width,
                                  GLsizei height, GLenum format, GLsizei imageSize, const void* data);
     void CompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format,
@@ -71,5 +70,4 @@ namespace MobileGL {
                               GLsizei imageSize, const void* data);
     void BindTexture(GLenum target, GLuint texture);
     void ActiveTexture(GLenum texture);
-    } // namespace MG_Impl::GLImpl
+} // namespace MobileGL::MG_Impl::GLImpl
-} // namespace MobileGL

MobileGL/MG_Impl/Init.cpp

@@ -14,8 +14,7 @@
 #include <MG_State/GLState/TextureState/TextureObject2D.h>
 #include <MG_State/GLState/TextureState/TextureObject3D.h>
 
-namespace MobileGL {
+namespace MobileGL::MG_Impl {
-    namespace MG_Impl {
     void Init() {
         MGLOG_D("Initializing MobileGL Implementation...");
         GLImpl::TextureImpl::pProxyTextureManager = new GLImpl::TextureImpl::ProxyTextureManager();
@@ -40,5 +39,4 @@ namespace MobileGL {
         GLImpl::FramebufferImpl::pDefaultFramebufferInfo =
             new GLImpl::FramebufferImpl::DefaultFramebufferInfo(fbo0, colorTex, depthTex, stencilTex);
     }
-    } // namespace MG_Impl
+} // namespace MobileGL::MG_Impl
-} // namespace MobileGL

MobileGL/MG_State/GLState/FramebufferState/FramebufferObject.cpp

@@ -13,12 +13,13 @@ namespace MobileGL {
     namespace MG_State {
         namespace GLState {
             // FramebufferAttachmentObject
-            FramebufferAttachmentObject::FramebufferAttachmentObject(SharedPtr<MG_State::GLState::ITextureObject> texture,
+            FramebufferAttachmentObject::FramebufferAttachmentObject(
-                                                                     Int level)
+                SharedPtr<MG_State::GLState::ITextureObject> texture, Int level)
                 : m_texture(texture), m_textureLevel(level) {}
             FramebufferAttachmentObject::FramebufferAttachmentObject(SharedPtr<RenderbufferObject> renderbuffer)
                 : m_renderbuffer(renderbuffer) {}
-            FramebufferAttachmentObject::FramebufferAttachmentObject(Bool IsValid) : m_texture(nullptr), m_renderbuffer(nullptr) {
+            FramebufferAttachmentObject::FramebufferAttachmentObject(Bool IsValid)
+                : m_texture(nullptr), m_renderbuffer(nullptr) {
                 m_isValid = IsValid;
             }
 
@@ -104,7 +105,8 @@ namespace MobileGL {
                 return m_attachmentObjects[static_cast<SizeT>(type)];
             }
 
-            const FramebufferObject::FramebufferAttachmentObjectArray& FramebufferObject::GetAllAttachmentObjects() const {
+            const FramebufferObject::FramebufferAttachmentObjectArray& FramebufferObject::GetAllAttachmentObjects()
+                const {
                 return m_attachmentObjects;
             }
 

MobileGL/MG_State/GLState/TextureState/TextureObject.h

@@ -69,6 +69,7 @@ namespace MobileGL {
                 void SetBaseLevel(Uint baseLevel) override;
                 void SetMaxLevel(Uint maxLevel) override;
                 Uint16 GetTextureParamsVersion() const override;
+
             protected:
                 const Uint m_externalIndex;
                 const TextureTarget m_target = TextureTarget::Unknown;

MobileGL/MG_Util/BackendLoaders/OpenGL/Loader.cpp

@@ -7,540 +7,55 @@
 // End of Source File Header
 
 #include "Loader.h"
+#include "MG_Util/Types.h"
 
-#define GL_FUNC_DECL(name) name##_PTR name;
+namespace MobileGL::MG_Util::BackendLoader {
-#define EGL_FUNC_DECL(name) name##_PTR name;
+    static void* OpenLib(const Vector<String>& names) {
-
-namespace MobileGL {
-    namespace MG_External {
-        namespace GLES {
-            Caps::GLESCaps g_glesCaps;
-
-            GL_FUNC_DECL(glActiveTexture)
-            GL_FUNC_DECL(glAttachShader)
-            GL_FUNC_DECL(glBindAttribLocation)
-            GL_FUNC_DECL(glBindBuffer)
-            GL_FUNC_DECL(glBindFramebuffer)
-            GL_FUNC_DECL(glBindRenderbuffer)
-            GL_FUNC_DECL(glBindTexture)
-            GL_FUNC_DECL(glBlendColor)
-            GL_FUNC_DECL(glBlendEquation)
-            GL_FUNC_DECL(glBlendEquationSeparate)
-            GL_FUNC_DECL(glBlendFunc)
-            GL_FUNC_DECL(glBlendFuncSeparate)
-            GL_FUNC_DECL(glBufferData)
-            GL_FUNC_DECL(glBufferSubData)
-            GL_FUNC_DECL(glCheckFramebufferStatus)
-            GL_FUNC_DECL(glClear)
-            GL_FUNC_DECL(glClearColor)
-            GL_FUNC_DECL(glClearDepthf)
-            GL_FUNC_DECL(glClearStencil)
-            GL_FUNC_DECL(glColorMask)
-            GL_FUNC_DECL(glCompileShader)
-            GL_FUNC_DECL(glCompressedTexImage2D)
-            GL_FUNC_DECL(glCompressedTexSubImage2D)
-            GL_FUNC_DECL(glCopyTexImage2D)
-            GL_FUNC_DECL(glCopyTexSubImage2D)
-            GL_FUNC_DECL(glCreateProgram)
-            GL_FUNC_DECL(glCreateShader)
-            GL_FUNC_DECL(glCullFace)
-            GL_FUNC_DECL(glDeleteBuffers)
-            GL_FUNC_DECL(glDeleteFramebuffers)
-            GL_FUNC_DECL(glDeleteProgram)
-            GL_FUNC_DECL(glDeleteRenderbuffers)
-            GL_FUNC_DECL(glDeleteShader)
-            GL_FUNC_DECL(glDeleteTextures)
-            GL_FUNC_DECL(glDepthFunc)
-            GL_FUNC_DECL(glDepthMask)
-            GL_FUNC_DECL(glDepthRangef)
-            GL_FUNC_DECL(glDetachShader)
-            GL_FUNC_DECL(glDisable)
-            GL_FUNC_DECL(glDisableVertexAttribArray)
-            GL_FUNC_DECL(glDrawArrays)
-            GL_FUNC_DECL(glDrawElements)
-            GL_FUNC_DECL(glEnable)
-            GL_FUNC_DECL(glEnableVertexAttribArray)
-            GL_FUNC_DECL(glFinish)
-            GL_FUNC_DECL(glFlush)
-            GL_FUNC_DECL(glFramebufferRenderbuffer)
-            GL_FUNC_DECL(glFramebufferTexture2D)
-            GL_FUNC_DECL(glFrontFace)
-            GL_FUNC_DECL(glGenBuffers)
-            GL_FUNC_DECL(glGenerateMipmap)
-            GL_FUNC_DECL(glGenFramebuffers)
-            GL_FUNC_DECL(glGenRenderbuffers)
-            GL_FUNC_DECL(glGenTextures)
-            GL_FUNC_DECL(glGetActiveAttrib)
-            GL_FUNC_DECL(glGetActiveUniform)
-            GL_FUNC_DECL(glGetAttachedShaders)
-            GL_FUNC_DECL(glGetAttribLocation)
-            GL_FUNC_DECL(glGetBooleanv)
-            GL_FUNC_DECL(glGetBufferParameteriv)
-            GL_FUNC_DECL(glGetError)
-            GL_FUNC_DECL(glGetString)
-            GL_FUNC_DECL(glGetStringi)
-            GL_FUNC_DECL(glGetFloatv)
-            GL_FUNC_DECL(glGetFramebufferAttachmentParameteriv)
-            GL_FUNC_DECL(glGetIntegerv)
-            GL_FUNC_DECL(glGetProgramiv)
-            GL_FUNC_DECL(glGetProgramInfoLog)
-            GL_FUNC_DECL(glGetRenderbufferParameteriv)
-            GL_FUNC_DECL(glGetShaderiv)
-            GL_FUNC_DECL(glGetShaderInfoLog)
-            GL_FUNC_DECL(glGetShaderPrecisionFormat)
-            GL_FUNC_DECL(glGetShaderSource)
-            GL_FUNC_DECL(glGetTexParameterfv)
-            GL_FUNC_DECL(glGetTexParameteriv)
-            GL_FUNC_DECL(glGetUniformfv)
-            GL_FUNC_DECL(glGetUniformiv)
-            GL_FUNC_DECL(glGetUniformLocation)
-            GL_FUNC_DECL(glGetVertexAttribfv)
-            GL_FUNC_DECL(glGetVertexAttribiv)
-            GL_FUNC_DECL(glGetVertexAttribPointerv)
-            GL_FUNC_DECL(glHint)
-            GL_FUNC_DECL(glIsBuffer)
-            GL_FUNC_DECL(glIsEnabled)
-            GL_FUNC_DECL(glIsFramebuffer)
-            GL_FUNC_DECL(glIsProgram)
-            GL_FUNC_DECL(glIsRenderbuffer)
-            GL_FUNC_DECL(glIsShader)
-            GL_FUNC_DECL(glIsTexture)
-            GL_FUNC_DECL(glLineWidth)
-            GL_FUNC_DECL(glLinkProgram)
-            GL_FUNC_DECL(glPixelStorei)
-            GL_FUNC_DECL(glPolygonOffset)
-            GL_FUNC_DECL(glReadPixels)
-            GL_FUNC_DECL(glReleaseShaderCompiler)
-            GL_FUNC_DECL(glRenderbufferStorage)
-            GL_FUNC_DECL(glSampleCoverage)
-            GL_FUNC_DECL(glScissor)
-            GL_FUNC_DECL(glShaderBinary)
-            GL_FUNC_DECL(glShaderSource)
-            GL_FUNC_DECL(glStencilFunc)
-            GL_FUNC_DECL(glStencilFuncSeparate)
-            GL_FUNC_DECL(glStencilMask)
-            GL_FUNC_DECL(glStencilMaskSeparate)
-            GL_FUNC_DECL(glStencilOp)
-            GL_FUNC_DECL(glStencilOpSeparate)
-            GL_FUNC_DECL(glTexImage2D)
-            GL_FUNC_DECL(glTexParameterf)
-            GL_FUNC_DECL(glTexParameterfv)
-            GL_FUNC_DECL(glTexParameteri)
-            GL_FUNC_DECL(glTexParameteriv)
-            GL_FUNC_DECL(glTexSubImage2D)
-            GL_FUNC_DECL(glUniform1f)
-            GL_FUNC_DECL(glUniform1fv)
-            GL_FUNC_DECL(glUniform1i)
-            GL_FUNC_DECL(glUniform1iv)
-            GL_FUNC_DECL(glUniform2f)
-            GL_FUNC_DECL(glUniform2fv)
-            GL_FUNC_DECL(glUniform2i)
-            GL_FUNC_DECL(glUniform2iv)
-            GL_FUNC_DECL(glUniform3f)
-            GL_FUNC_DECL(glUniform3fv)
-            GL_FUNC_DECL(glUniform3i)
-            GL_FUNC_DECL(glUniform3iv)
-            GL_FUNC_DECL(glUniform4f)
-            GL_FUNC_DECL(glUniform4fv)
-            GL_FUNC_DECL(glUniform4i)
-            GL_FUNC_DECL(glUniform4iv)
-            GL_FUNC_DECL(glUniformMatrix2fv)
-            GL_FUNC_DECL(glUniformMatrix3fv)
-            GL_FUNC_DECL(glUniformMatrix4fv)
-            GL_FUNC_DECL(glUseProgram)
-            GL_FUNC_DECL(glValidateProgram)
-            GL_FUNC_DECL(glVertexAttrib1f)
-            GL_FUNC_DECL(glVertexAttrib1fv)
-            GL_FUNC_DECL(glVertexAttrib2f)
-            GL_FUNC_DECL(glVertexAttrib2fv)
-            GL_FUNC_DECL(glVertexAttrib3f)
-            GL_FUNC_DECL(glVertexAttrib3fv)
-            GL_FUNC_DECL(glVertexAttrib4f)
-            GL_FUNC_DECL(glVertexAttrib4fv)
-            GL_FUNC_DECL(glVertexAttribPointer)
-            GL_FUNC_DECL(glViewport)
-            GL_FUNC_DECL(glReadBuffer)
-            GL_FUNC_DECL(glDrawRangeElements)
-            GL_FUNC_DECL(glTexImage3D)
-            GL_FUNC_DECL(glTexSubImage3D)
-            GL_FUNC_DECL(glCopyTexSubImage3D)
-            GL_FUNC_DECL(glCompressedTexImage3D)
-            GL_FUNC_DECL(glCompressedTexSubImage3D)
-            GL_FUNC_DECL(glGenQueries)
-            GL_FUNC_DECL(glDeleteQueries)
-            GL_FUNC_DECL(glIsQuery)
-            GL_FUNC_DECL(glBeginQuery)
-            GL_FUNC_DECL(glEndQuery)
-            GL_FUNC_DECL(glGetQueryiv)
-            GL_FUNC_DECL(glGetQueryObjectuiv)
-            GL_FUNC_DECL(glUnmapBuffer)
-            GL_FUNC_DECL(glGetBufferPointerv)
-            GL_FUNC_DECL(glDrawBuffers)
-            GL_FUNC_DECL(glUniformMatrix2x3fv)
-            GL_FUNC_DECL(glUniformMatrix3x2fv)
-            GL_FUNC_DECL(glUniformMatrix2x4fv)
-            GL_FUNC_DECL(glUniformMatrix4x2fv)
-            GL_FUNC_DECL(glUniformMatrix3x4fv)
-            GL_FUNC_DECL(glUniformMatrix4x3fv)
-            GL_FUNC_DECL(glBlitFramebuffer)
-            GL_FUNC_DECL(glRenderbufferStorageMultisample)
-            GL_FUNC_DECL(glFramebufferTextureLayer)
-            GL_FUNC_DECL(glFlushMappedBufferRange)
-            GL_FUNC_DECL(glBindVertexArray)
-            GL_FUNC_DECL(glDeleteVertexArrays)
-            GL_FUNC_DECL(glGenVertexArrays)
-            GL_FUNC_DECL(glIsVertexArray)
-            GL_FUNC_DECL(glGetIntegeri_v)
-            GL_FUNC_DECL(glBeginTransformFeedback)
-            GL_FUNC_DECL(glEndTransformFeedback)
-            GL_FUNC_DECL(glBindBufferRange)
-            GL_FUNC_DECL(glBindBufferBase)
-            GL_FUNC_DECL(glTransformFeedbackVaryings)
-            GL_FUNC_DECL(glGetTransformFeedbackVarying)
-            GL_FUNC_DECL(glVertexAttribIPointer)
-            GL_FUNC_DECL(glGetVertexAttribIiv)
-            GL_FUNC_DECL(glGetVertexAttribIuiv)
-            GL_FUNC_DECL(glVertexAttribI4i)
-            GL_FUNC_DECL(glVertexAttribI4ui)
-            GL_FUNC_DECL(glVertexAttribI4iv)
-            GL_FUNC_DECL(glVertexAttribI4uiv)
-            GL_FUNC_DECL(glGetUniformuiv)
-            GL_FUNC_DECL(glGetFragDataLocation)
-            GL_FUNC_DECL(glUniform1ui)
-            GL_FUNC_DECL(glUniform2ui)
-            GL_FUNC_DECL(glUniform3ui)
-            GL_FUNC_DECL(glUniform4ui)
-            GL_FUNC_DECL(glUniform1uiv)
-            GL_FUNC_DECL(glUniform2uiv)
-            GL_FUNC_DECL(glUniform3uiv)
-            GL_FUNC_DECL(glUniform4uiv)
-            GL_FUNC_DECL(glClearBufferiv)
-            GL_FUNC_DECL(glClearBufferuiv)
-            GL_FUNC_DECL(glClearBufferfv)
-            GL_FUNC_DECL(glClearBufferfi)
-            GL_FUNC_DECL(glCopyBufferSubData)
-            GL_FUNC_DECL(glGetUniformIndices)
-            GL_FUNC_DECL(glGetActiveUniformsiv)
-            GL_FUNC_DECL(glGetUniformBlockIndex)
-            GL_FUNC_DECL(glGetActiveUniformBlockiv)
-            GL_FUNC_DECL(glGetActiveUniformBlockName)
-            GL_FUNC_DECL(glUniformBlockBinding)
-            GL_FUNC_DECL(glDrawArraysInstanced)
-            GL_FUNC_DECL(glDrawElementsInstanced)
-            GL_FUNC_DECL(glFenceSync)
-            GL_FUNC_DECL(glIsSync)
-            GL_FUNC_DECL(glDeleteSync)
-            GL_FUNC_DECL(glClientWaitSync)
-            GL_FUNC_DECL(glWaitSync)
-            GL_FUNC_DECL(glGetInteger64v)
-            GL_FUNC_DECL(glGetSynciv)
-            GL_FUNC_DECL(glGetInteger64i_v)
-            GL_FUNC_DECL(glGetBufferParameteri64v)
-            GL_FUNC_DECL(glGenSamplers)
-            GL_FUNC_DECL(glDeleteSamplers)
-            GL_FUNC_DECL(glIsSampler)
-            GL_FUNC_DECL(glBindSampler)
-            GL_FUNC_DECL(glSamplerParameteri)
-            GL_FUNC_DECL(glSamplerParameteriv)
-            GL_FUNC_DECL(glSamplerParameterf)
-            GL_FUNC_DECL(glSamplerParameterfv)
-            GL_FUNC_DECL(glGetSamplerParameteriv)
-            GL_FUNC_DECL(glGetSamplerParameterfv)
-            GL_FUNC_DECL(glVertexAttribDivisor)
-            GL_FUNC_DECL(glBindTransformFeedback)
-            GL_FUNC_DECL(glDeleteTransformFeedbacks)
-            GL_FUNC_DECL(glGenTransformFeedbacks)
-            GL_FUNC_DECL(glIsTransformFeedback)
-            GL_FUNC_DECL(glPauseTransformFeedback)
-            GL_FUNC_DECL(glResumeTransformFeedback)
-            GL_FUNC_DECL(glGetProgramBinary)
-            GL_FUNC_DECL(glProgramBinary)
-            GL_FUNC_DECL(glProgramParameteri)
-            GL_FUNC_DECL(glInvalidateFramebuffer)
-            GL_FUNC_DECL(glInvalidateSubFramebuffer)
-            GL_FUNC_DECL(glTexStorage2D)
-            GL_FUNC_DECL(glTexStorage3D)
-            GL_FUNC_DECL(glGetInternalformativ)
-            GL_FUNC_DECL(glDispatchCompute)
-            GL_FUNC_DECL(glDispatchComputeIndirect)
-            GL_FUNC_DECL(glDrawArraysIndirect)
-            GL_FUNC_DECL(glDrawElementsIndirect)
-            GL_FUNC_DECL(glFramebufferParameteri)
-            GL_FUNC_DECL(glGetFramebufferParameteriv)
-            GL_FUNC_DECL(glGetProgramInterfaceiv)
-            GL_FUNC_DECL(glGetProgramResourceIndex)
-            GL_FUNC_DECL(glGetProgramResourceName)
-            GL_FUNC_DECL(glGetProgramResourceiv)
-            GL_FUNC_DECL(glGetProgramResourceLocation)
-            GL_FUNC_DECL(glUseProgramStages)
-            GL_FUNC_DECL(glActiveShaderProgram)
-            GL_FUNC_DECL(glCreateShaderProgramv)
-            GL_FUNC_DECL(glBindProgramPipeline)
-            GL_FUNC_DECL(glDeleteProgramPipelines)
-            GL_FUNC_DECL(glGenProgramPipelines)
-            GL_FUNC_DECL(glIsProgramPipeline)
-            GL_FUNC_DECL(glGetProgramPipelineiv)
-            GL_FUNC_DECL(glProgramUniform1i)
-            GL_FUNC_DECL(glProgramUniform2i)
-            GL_FUNC_DECL(glProgramUniform3i)
-            GL_FUNC_DECL(glProgramUniform4i)
-            GL_FUNC_DECL(glProgramUniform1ui)
-            GL_FUNC_DECL(glProgramUniform2ui)
-            GL_FUNC_DECL(glProgramUniform3ui)
-            GL_FUNC_DECL(glProgramUniform4ui)
-            GL_FUNC_DECL(glProgramUniform1f)
-            GL_FUNC_DECL(glProgramUniform2f)
-            GL_FUNC_DECL(glProgramUniform3f)
-            GL_FUNC_DECL(glProgramUniform4f)
-            GL_FUNC_DECL(glProgramUniform1iv)
-            GL_FUNC_DECL(glProgramUniform2iv)
-            GL_FUNC_DECL(glProgramUniform3iv)
-            GL_FUNC_DECL(glProgramUniform4iv)
-            GL_FUNC_DECL(glProgramUniform1uiv)
-            GL_FUNC_DECL(glProgramUniform2uiv)
-            GL_FUNC_DECL(glProgramUniform3uiv)
-            GL_FUNC_DECL(glProgramUniform4uiv)
-            GL_FUNC_DECL(glProgramUniform1fv)
-            GL_FUNC_DECL(glProgramUniform2fv)
-            GL_FUNC_DECL(glProgramUniform3fv)
-            GL_FUNC_DECL(glProgramUniform4fv)
-            GL_FUNC_DECL(glProgramUniformMatrix2fv)
-            GL_FUNC_DECL(glProgramUniformMatrix3fv)
-            GL_FUNC_DECL(glProgramUniformMatrix4fv)
-            GL_FUNC_DECL(glProgramUniformMatrix2x3fv)
-            GL_FUNC_DECL(glProgramUniformMatrix3x2fv)
-            GL_FUNC_DECL(glProgramUniformMatrix2x4fv)
-            GL_FUNC_DECL(glProgramUniformMatrix4x2fv)
-            GL_FUNC_DECL(glProgramUniformMatrix3x4fv)
-            GL_FUNC_DECL(glProgramUniformMatrix4x3fv)
-            GL_FUNC_DECL(glValidateProgramPipeline)
-            GL_FUNC_DECL(glGetProgramPipelineInfoLog)
-            GL_FUNC_DECL(glBindImageTexture)
-            GL_FUNC_DECL(glGetBooleani_v)
-            GL_FUNC_DECL(glMemoryBarrier)
-            GL_FUNC_DECL(glMemoryBarrierByRegion)
-            GL_FUNC_DECL(glTexStorage2DMultisample)
-            GL_FUNC_DECL(glGetMultisamplefv)
-            GL_FUNC_DECL(glSampleMaski)
-            GL_FUNC_DECL(glGetTexLevelParameteriv)
-            GL_FUNC_DECL(glGetTexLevelParameterfv)
-            GL_FUNC_DECL(glBindVertexBuffer)
-            GL_FUNC_DECL(glVertexAttribFormat)
-            GL_FUNC_DECL(glVertexAttribIFormat)
-            GL_FUNC_DECL(glVertexAttribBinding)
-            GL_FUNC_DECL(glVertexBindingDivisor)
-            GL_FUNC_DECL(glBlendBarrier)
-            GL_FUNC_DECL(glCopyImageSubData)
-            GL_FUNC_DECL(glDebugMessageControl)
-            GL_FUNC_DECL(glDebugMessageInsert)
-            GL_FUNC_DECL(glDebugMessageCallback)
-            GL_FUNC_DECL(glGetDebugMessageLog)
-            GL_FUNC_DECL(glPushDebugGroup)
-            GL_FUNC_DECL(glPopDebugGroup)
-            GL_FUNC_DECL(glObjectLabel)
-            GL_FUNC_DECL(glGetObjectLabel)
-            GL_FUNC_DECL(glObjectPtrLabel)
-            GL_FUNC_DECL(glGetObjectPtrLabel)
-            GL_FUNC_DECL(glGetPointerv)
-            GL_FUNC_DECL(glEnablei)
-            GL_FUNC_DECL(glDisablei)
-            GL_FUNC_DECL(glBlendEquationi)
-            GL_FUNC_DECL(glBlendEquationSeparatei)
-            GL_FUNC_DECL(glBlendFunci)
-            GL_FUNC_DECL(glBlendFuncSeparatei)
-            GL_FUNC_DECL(glColorMaski)
-            GL_FUNC_DECL(glIsEnabledi)
-            GL_FUNC_DECL(glDrawElementsBaseVertex)
-            GL_FUNC_DECL(glDrawRangeElementsBaseVertex)
-            GL_FUNC_DECL(glDrawElementsInstancedBaseVertex)
-            GL_FUNC_DECL(glFramebufferTexture)
-            GL_FUNC_DECL(glPrimitiveBoundingBox)
-            GL_FUNC_DECL(glGetGraphicsResetStatus)
-            GL_FUNC_DECL(glReadnPixels)
-            GL_FUNC_DECL(glGetnUniformfv)
-            GL_FUNC_DECL(glGetnUniformiv)
-            GL_FUNC_DECL(glGetnUniformuiv)
-            GL_FUNC_DECL(glMinSampleShading)
-            GL_FUNC_DECL(glPatchParameteri)
-            GL_FUNC_DECL(glTexParameterIiv)
-            GL_FUNC_DECL(glTexParameterIuiv)
-            GL_FUNC_DECL(glGetTexParameterIiv)
-            GL_FUNC_DECL(glGetTexParameterIuiv)
-            GL_FUNC_DECL(glSamplerParameterIiv)
-            GL_FUNC_DECL(glSamplerParameterIuiv)
-            GL_FUNC_DECL(glGetSamplerParameterIiv)
-            GL_FUNC_DECL(glGetSamplerParameterIuiv)
-            GL_FUNC_DECL(glTexBuffer)
-            GL_FUNC_DECL(glTexBufferRange)
-            GL_FUNC_DECL(glTexStorage3DMultisample)
-            GL_FUNC_DECL(glMapBufferRange)
-            GL_FUNC_DECL(glBufferStorageEXT)
-            GL_FUNC_DECL(glGetQueryObjectivEXT)
-            GL_FUNC_DECL(glGetQueryObjecti64vEXT)
-            GL_FUNC_DECL(glBindFragDataLocationEXT)
-            GL_FUNC_DECL(glMapBufferOES)
-
-            GL_FUNC_DECL(glMultiDrawArraysIndirectEXT)
-            GL_FUNC_DECL(glMultiDrawElementsIndirectEXT)
-            GL_FUNC_DECL(glMultiDrawElementsBaseVertexEXT)
-
-            GL_FUNC_DECL(glBruh)
-        } // namespace GLES
-
-        namespace EGL {
-            EGL_FUNC_DECL(eglBindAPI)
-            EGL_FUNC_DECL(eglBindTexImage)
-            EGL_FUNC_DECL(eglChooseConfig)
-            EGL_FUNC_DECL(eglCopyBuffers)
-            EGL_FUNC_DECL(eglCreateContext)
-            EGL_FUNC_DECL(eglCreatePbufferFromClientBuffer)
-            EGL_FUNC_DECL(eglCreatePbufferSurface)
-            EGL_FUNC_DECL(eglCreatePixmapSurface)
-            EGL_FUNC_DECL(eglCreatePlatformWindowSurface)
-            EGL_FUNC_DECL(eglCreateWindowSurface)
-            EGL_FUNC_DECL(eglDestroyContext)
-            EGL_FUNC_DECL(eglDestroySurface)
-            EGL_FUNC_DECL(eglGetConfigAttrib)
-            EGL_FUNC_DECL(eglGetConfigs)
-            EGL_FUNC_DECL(eglGetCurrentContext)
-            EGL_FUNC_DECL(eglGetCurrentDisplay)
-            EGL_FUNC_DECL(eglGetCurrentSurface)
-            EGL_FUNC_DECL(eglGetDisplay)
-            EGL_FUNC_DECL(eglGetPlatformDisplay)
-            EGL_FUNC_DECL(eglGetError)
-            EGL_FUNC_DECL(eglGetProcAddress)
-            EGL_FUNC_DECL(eglInitialize)
-            EGL_FUNC_DECL(eglMakeCurrent)
-            EGL_FUNC_DECL(eglQueryAPI)
-            EGL_FUNC_DECL(eglQueryContext)
-            EGL_FUNC_DECL(eglQueryString)
-            EGL_FUNC_DECL(eglQuerySurface)
-            EGL_FUNC_DECL(eglReleaseTexImage)
-            EGL_FUNC_DECL(eglReleaseThread)
-            EGL_FUNC_DECL(eglSurfaceAttrib)
-            EGL_FUNC_DECL(eglSwapBuffers)
-            EGL_FUNC_DECL(eglSwapBuffersWithDamageEXT)
-            EGL_FUNC_DECL(eglSwapInterval)
-            EGL_FUNC_DECL(eglTerminate)
-            EGL_FUNC_DECL(eglUnlockSurfaceKHR)
-            EGL_FUNC_DECL(eglWaitClient)
-            EGL_FUNC_DECL(eglWaitGL)
-            EGL_FUNC_DECL(eglWaitNative)
-            EGL_FUNC_DECL(eglCreateSync)
-            EGL_FUNC_DECL(eglDestroySync)
-            EGL_FUNC_DECL(eglClientWaitSync)
-            EGL_FUNC_DECL(eglGetSyncAttrib)
-            EGL_FUNC_DECL(eglCreateImage)
-            EGL_FUNC_DECL(eglDestroyImage)
-            EGL_FUNC_DECL(eglCreatePlatformPixmapSurface)
-            EGL_FUNC_DECL(eglWaitSync)
-        } // namespace EGL
-    } // namespace MG_External
-
-#undef GL_FUNC_DECL
-#undef EGL_FUNC_DECL
-
-    namespace MG_Util {
-        namespace BackendLoader::GLES {
-            Bool Init() {
-                LoadLibs();
-                if (libGLES == nullptr || libEGL == nullptr ||
-                    (glGetError_PTR)ProcAddress(libGLES, "glGetError") == nullptr) {
-                    return false;
-                }
-                InitEGL();
-                InitGLES();
-                DestroyTempEGLCtx();
-                return true;
-            }
-
-            void *libGLES = nullptr, *libEGL = nullptr;
-
-            static const char* LibPathPrefixes[] = {
-                "/opt/vc/lib/",
-                "/usr/local/lib/",
-                "/usr/lib/",
-                "/usr/lib/x86_64-linux-gnu/",
-                "", // We should put this to the end of the list to avoid breaking `LD_LIBRARY_PATH` usage
-                nullptr};
-            static const char* LibExts[] = {"so", "so.1", "so.2", "dylib", "dll", nullptr};
-            static const char* GLES3Libs[] = {"libGLESv3_CM", "libGLESv3", "libGLESv2_CM", "libGLESv2", nullptr};
-            static const char* EGLLibs[] = {"libEGL", nullptr};
-
-            void* OpenLib(const char** names, const char* override) {
 #if !defined(__WIN32) && !defined(_WIN32) && !defined(__APPLE__)
+        static const String LibPathPrefixes[] = {
+            "/opt/vc/lib/", "/usr/local/lib/", "/usr/lib/", "/usr/lib/x86_64-linux-gnu/",
+            "" // We should put this to the end of the list to avoid breaking `LD_LIBRARY_PATH` usage
+        };
+
         void* lib = nullptr;
 
-                char path_name[PATH_MAX + 1];
+        Int flags = RTLD_LOCAL | RTLD_NOW;
-                int flags = RTLD_LOCAL | RTLD_NOW;
+        for (const auto& prefix : LibPathPrefixes) {
-                if (override) {
+            for (const auto& name : names) {
-                    if ((lib = dlopen(override, flags))) {
+                String path_name = prefix + name;
-                        strncpy(path_name, override, PATH_MAX);
+                if ((lib = dlopen(path_name.c_str(), flags))) {
-                        return lib;
-                    }
-                }
-                for (int p = 0; LibPathPrefixes[p]; p++) {
-                    for (int i = 0; names[i]; i++) {
-                        for (int e = 0; LibExts[e]; e++) {
-                            snprintf(path_name, PATH_MAX, "%s%s.%s", LibPathPrefixes[p], names[i], LibExts[e]);
-                            if ((lib = dlopen(path_name, flags))) {
                     return lib;
                 }
             }
         }
-                }
-                return lib;
-#else
-                return nullptr;
 #endif
+        return nullptr;
     }
 
-            void LoadLibs() {
+    inline void* ProcAddress(void* lib, const char* name) {
-                // TODO: Add ANGLE override?
-                libGLES = OpenLib(GLES3Libs, nullptr);
-                libEGL = OpenLib(EGLLibs, nullptr);
-            }
-
-            void* ProcAddress(void* lib, const char* name) {
 #if !defined(__WIN32) && !defined(_WIN32) && !defined(__APPLE__)
         return dlsym(lib, name);
 #else
-                return nullptr;
+        return nullptrptr;
 #endif
     }
 
-            void InitGLESCapabilities() {
+    Bool AcquireGLESFunctions(MG_External::GLESFunctionsTable& funcs,
-                auto* vendorName = MG_External::GLES::glGetString(GL_VENDOR);
+                              MG_External::EGL::eglGetProcAddress_PTR procAddress) {
-                MGLOG_I("GL_VENDOR: %s", vendorName);
+        if (!procAddress) {
-                auto* gpuName = MG_External::GLES::glGetString(GL_RENDERER);
+            MGLOG_E("eglGetProcAddress is nullptr, cannot load GLES functions");
-                MGLOG_I("GL_RENDERER: %s", gpuName);
+            return false;
-                MG_External::GLES::glGetIntegerv(GL_MAJOR_VERSION, &MG_External::GLES::g_glesCaps.version.Major);
-                MG_External::GLES::glGetIntegerv(GL_MINOR_VERSION, &MG_External::GLES::g_glesCaps.version.Minor);
-
-                GLint extCount = 0;
-                MG_External::GLES::glGetIntegerv(GL_NUM_EXTENSIONS, &extCount);
-                MGLOG_I("Detected %d OpenGL ES extensions:", extCount);
-                for (GLint i = 0; i < extCount; ++i) {
-                    const char* extension = (const char*)MG_External::GLES::glGetStringi(GL_EXTENSIONS, i);
-                    if (extension) {
-                        MGLOG_I("    %s", extension);
-                        if (std::strcmp(extension, "GL_EXT_buffer_storage") == 0) {
-                            MG_External::GLES::g_glesCaps.hasPersistentMapping = true;
-                        }
-                        if (std::strcmp(extension, "GL_EXT_texture_norm16") == 0) {
-                            MG_External::GLES::g_glesCaps.hasNorm16Texture = true;
-                        }
-                    }
         }
 
-                MGLOG_I("OpenGL ES capabilities:");
+#define INIT_GLES_FUNC(name)                                                                                           \
-                MG_External::GLES::glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT,
+    do {                                                                                                               \
-                                                 &MG_External::GLES::g_glesCaps.uniformBufferOffsetAlignment);
+        funcs.name = (MG_External::GLES::name##_PTR)procAddress(#name);                                                \
-                MGLOG_I("    GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT: %d",
+        if (!funcs.name) {                                                                                             \
-                        MG_External::GLES::g_glesCaps.uniformBufferOffsetAlignment);
+            MGLOG_E("Failed to load GLES function: %s", #name);                                                        \
-            }
+        }                                                                                                              \
+    } while (0);
 
-            void InitGLES() {
+        {
             INIT_GLES_FUNC(glActiveTexture)
             INIT_GLES_FUNC(glAttachShader)
             INIT_GLES_FUNC(glBindAttribLocation)
@@ -910,19 +425,26 @@ namespace MobileGL {
             INIT_GLES_FUNC(glMultiDrawArraysIndirectEXT)
             INIT_GLES_FUNC(glMultiDrawElementsIndirectEXT)
             INIT_GLES_FUNC(glMultiDrawElementsBaseVertexEXT)
-
+        }
-                InitGLESCapabilities();
+        return true;
     }
 
-            static EGLDisplay eglDisplay = EGL_NO_DISPLAY;
+    Bool AcquireEGLFunctions(MG_External::EGLFunctionsTable& funcs) {
-            static EGLSurface eglSurface = EGL_NO_SURFACE;
+        static const Vector<String> EGLLibNames = {"libEGL.so"};
-            static EGLContext eglContext = EGL_NO_CONTEXT;
+        void* eglLib = OpenLib(EGLLibNames);
-
+        if (!eglLib) {
+            MGLOG_E("Failed to open libEGL.so");
+            return false;
+        }
 #define INIT_EGL_FUNC(name)                                                                                            \
-    if (libEGL != NULL) {                                                                                              \
+    do {                                                                                                               \
-        MG_External::EGL::name = (MG_External::EGL::name##_PTR)ProcAddress(libEGL, #name);                             \
+        funcs.name = (MG_External::EGL::name##_PTR)ProcAddress(eglLib, #name);                                         \
-    }
+        if (!funcs.name) {                                                                                             \
-            void InitEGL() {
+            MGLOG_E("Failed to load EGL function: %s", #name);                                                         \
+        }                                                                                                              \
+    } while (0);
+
+        {
             INIT_EGL_FUNC(eglBindAPI)
             INIT_EGL_FUNC(eglBindTexImage)
             INIT_EGL_FUNC(eglChooseConfig)
@@ -970,100 +492,48 @@ namespace MobileGL {
             INIT_EGL_FUNC(eglDestroyImage)
             INIT_EGL_FUNC(eglGetPlatformDisplay)
             INIT_EGL_FUNC(eglWaitSync)
-
+        }
-                EGLint configAttribs[] = {EGL_RED_SIZE,
+        return true;
-                                          8,
-                                          EGL_GREEN_SIZE,
-                                          8,
-                                          EGL_BLUE_SIZE,
-                                          8,
-                                          EGL_ALPHA_SIZE,
-                                          8,
-                                          EGL_SURFACE_TYPE,
-                                          EGL_PBUFFER_BIT,
-                                          EGL_RENDERABLE_TYPE,
-                                          EGL_OPENGL_ES2_BIT,
-                                          EGL_NONE};
-
-                EGLint ctxAttribs[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
-
-                EGLint pbAttribs[] = {EGL_WIDTH, 32, EGL_HEIGHT, 32, EGL_NONE};
-
-                EGLConfig pbufConfig;
-                EGLint configsFound = 0;
-
-                eglDisplay = MG_External::EGL::eglGetDisplay(EGL_DEFAULT_DISPLAY);
-                if (eglDisplay == EGL_NO_DISPLAY) {
-                    goto cleanup;
     }
 
-                if (MG_External::EGL::eglInitialize(eglDisplay, NULL, NULL) != EGL_TRUE) {
+    Bool FillInGLESCapabilities(MG_External::GLESCapabilities& caps, const MG_External::GLESFunctionsTable& glesFuncs) {
-                    goto cleanup;
+        if (!glesFuncs.glGetString || !glesFuncs.glGetIntegerv) {
+            MGLOG_E("Required GLES functions are not loaded, cannot query capabilities");
+            return false;
         }
 
-                if (MG_External::EGL::eglBindAPI(EGL_OPENGL_ES_API) != EGL_TRUE) {
+        auto* vendorName = glesFuncs.glGetString(GL_VENDOR);
-                    goto cleanup;
+        MGLOG_I("GL_VENDOR: %s", vendorName);
-                }
+        auto* gpuName = glesFuncs.glGetString(GL_RENDERER);
+        MGLOG_I("GL_RENDERER: %s", gpuName);
+        glesFuncs.glGetIntegerv(GL_MAJOR_VERSION, &caps.GLESVersion.Major);
+        glesFuncs.glGetIntegerv(GL_MINOR_VERSION, &caps.GLESVersion.Minor);
 
-                if (MG_External::EGL::eglChooseConfig(eglDisplay, configAttribs, &pbufConfig, 1, &configsFound) !=
+        caps.GLESVersionString = String((char*)glesFuncs.glGetString(GL_VERSION));
-                    EGL_TRUE) {
+        caps.GLESRendererString = String((char*)gpuName);
-                    goto cleanup;
+        caps.GLESVendorString = String((char*)vendorName);
-                }
+        caps.GLESShadingLanguageVersionString = String((char*)glesFuncs.glGetString(GL_SHADING_LANGUAGE_VERSION));
 
-                if (configsFound == 0) {
+        GLint extCount = 0;
-                    configAttribs[6] = 0;
+        glesFuncs.glGetIntegerv(GL_NUM_EXTENSIONS, &extCount);
-                    if (MG_External::EGL::eglChooseConfig(eglDisplay, configAttribs, &pbufConfig, 1, &configsFound) !=
+        MGLOG_I("Detected %d OpenGL ES extensions:", extCount);
-                        EGL_TRUE) {
+        for (GLint i = 0; i < extCount; ++i) {
-                        goto cleanup;
+            const char* extension = (const char*)glesFuncs.glGetStringi(GL_EXTENSIONS, i);
+            if (extension) {
+                MGLOG_I("    %s", extension);
+                if (std::strcmp(extension, "GL_EXT_buffer_storage") == 0) {
+                    caps.SupportsPersistentMapping = true;
+                }
+                if (std::strcmp(extension, "GL_EXT_texture_norm16") == 0) {
+                    caps.SupportsNorm16Texture = true;
                 }
-                    if (!configsFound) {
-                        goto cleanup;
             }
         }
 
-                eglContext = MG_External::EGL::eglCreateContext(eglDisplay, pbufConfig, EGL_NO_CONTEXT, ctxAttribs);
+        MGLOG_I("OpenGL ES capabilities:");
-                if (eglContext == EGL_NO_CONTEXT) {
+        glesFuncs.glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &caps.UniformBufferOffsetAlignment);
-                    goto cleanup;
+        MGLOG_I("    GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT: %d", caps.UniformBufferOffsetAlignment);
+
+        return true;
     }
-
+} // namespace MobileGL::MG_Util::BackendLoader
-                eglSurface = MG_External::EGL::eglCreatePbufferSurface(eglDisplay, pbufConfig, pbAttribs);
-                if (eglSurface == EGL_NO_SURFACE) {
-                    goto cleanup;
-                }
-
-                if (MG_External::EGL::eglMakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext) != EGL_TRUE) {
-                    goto cleanup;
-                }
-
-                return;
-
-            cleanup:
-                if (eglSurface != EGL_NO_SURFACE) {
-                    MG_External::EGL::eglDestroySurface(eglDisplay, eglSurface);
-                }
-                if (eglContext != EGL_NO_CONTEXT) {
-                    MG_External::EGL::eglDestroyContext(eglDisplay, eglContext);
-                }
-                if (eglDisplay != EGL_NO_DISPLAY) {
-                    MG_External::EGL::eglTerminate(eglDisplay);
-                }
-            }
-
-            void DestroyTempEGLCtx() {
-                INIT_EGL_FUNC(eglDestroySurface)
-                INIT_EGL_FUNC(eglDestroyContext)
-                INIT_EGL_FUNC(eglMakeCurrent)
-                INIT_EGL_FUNC(eglTerminate)
-
-                MG_External::EGL::eglMakeCurrent(eglDisplay, 0, 0, EGL_NO_CONTEXT);
-                MG_External::EGL::eglDestroySurface(eglDisplay, eglSurface);
-                MG_External::EGL::eglDestroyContext(eglDisplay, eglContext);
-
-                MG_External::EGL::eglTerminate(eglDisplay);
-            }
-
-#undef LOAD_EGL
-
-        } // namespace BackendLoader::GLES
-    } // namespace MG_Util
-} // namespace MobileGL

MobileGL/MG_Util/BackendLoaders/Vulkan/Loader.cpp

@@ -0,0 +1,59 @@
+// MobileGL - MobileGL/MG_Util/BackendLoaders/Vulkan/Loader.cpp
+// Copyright (c) 2025-2026 MobileGL-Dev
+// Licensed under the GNU Lesser General Public License v3.0:
+//   https://www.gnu.org/licenses/gpl-3.0.txt
+//   https://www.gnu.org/licenses/lgpl-3.0.txt
+// SPDX-License-Identifier: LGPL-3.0-only
+// End of Source File Header
+
+#include "Loader.h"
+
+namespace MobileGL::MG_Util::BackendLoader {
+    inline Version DecodeApiVersion(uint32_t version) {
+        return {(Int)VK_VERSION_MAJOR(version), (Int)VK_VERSION_MINOR(version), (Int)VK_VERSION_PATCH(version)};
+    }
+
+    inline std::string DecodeDriverVersion(uint32_t driverVersion) {
+        std::ostringstream oss;
+        oss << VK_VERSION_MAJOR(driverVersion) << "." << VK_VERSION_MINOR(driverVersion) << "."
+            << VK_VERSION_PATCH(driverVersion);
+        return oss.str();
+    }
+
+    Bool QueryVulkanCapabilities(MobileGL::MG_External::VulkanCapabilities& caps, VkPhysicalDevice physicalDevice) {
+        if (!physicalDevice) {
+            MGLOG_E("Invalid physical device handle");
+            return false;
+        }
+
+        VkPhysicalDeviceProperties props{};
+        vkGetPhysicalDeviceProperties(physicalDevice, &props);
+
+        if (props.apiVersion < VK_API_VERSION_1_1) {
+            MGLOG_E("Vulkan API version %u.%u.%u is not supported, requires at least 1.1",
+                    VK_VERSION_MAJOR(props.apiVersion), VK_VERSION_MINOR(props.apiVersion),
+                    VK_VERSION_PATCH(props.apiVersion));
+            return false;
+        }
+
+        VkPhysicalDeviceProperties2 props2{};
+        props2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
+        vkGetPhysicalDeviceProperties2(physicalDevice, &props2);
+
+        const VkPhysicalDeviceProperties& p = props2.properties;
+        caps.VulkanAPIVersion = DecodeApiVersion(p.apiVersion);
+        caps.DeviceName = p.deviceName;
+        caps.DriverVersionString = DecodeDriverVersion(p.driverVersion);
+        caps.UniformBufferOffsetAlignment = static_cast<int>(p.limits.minUniformBufferOffsetAlignment);
+
+        return true;
+    }
+
+    void FillInVulkanCapabilities(MobileGL::MG_External::VulkanCapabilities& caps,
+                                  VkPhysicalDeviceProperties properties) {
+        caps.VulkanAPIVersion = DecodeApiVersion(properties.apiVersion);
+        caps.DeviceName = properties.deviceName;
+        caps.DriverVersionString = DecodeDriverVersion(properties.driverVersion);
+        caps.UniformBufferOffsetAlignment = static_cast<int>(properties.limits.minUniformBufferOffsetAlignment);
+    }
+} // namespace MobileGL::MG_Util::BackendLoader

MobileGL/MG_Util/BackendLoaders/Vulkan/Loader.h

@@ -0,0 +1,26 @@
+// MobileGL - MobileGL/MG_Util/BackendLoaders/Vulkan/Loader.h
+// Copyright (c) 2025-2026 MobileGL-Dev
+// Licensed under the GNU Lesser General Public License v3.0:
+//   https://www.gnu.org/licenses/gpl-3.0.txt
+//   https://www.gnu.org/licenses/lgpl-3.0.txt
+// SPDX-License-Identifier: LGPL-3.0-only
+// End of Source File Header
+
+#pragma once
+#include <Includes.h>
+
+namespace MobileGL {
+    namespace MG_External {
+        struct VulkanCapabilities {
+            Version VulkanAPIVersion{1, 0, 0};
+            String DeviceName;
+            String DriverVersionString;
+            Int UniformBufferOffsetAlignment = 256;
+        };
+    } // namespace MG_External
+    namespace MG_Util::BackendLoader {
+        Bool QueryVulkanCapabilities(MobileGL::MG_External::VulkanCapabilities& caps, VkPhysicalDevice physicalDevice);
+        void FillInVulkanCapabilities(MobileGL::MG_External::VulkanCapabilities& caps,
+                                      VkPhysicalDeviceProperties properties);
+    } // namespace MG_Util::BackendLoader
+} // namespace MobileGL

MobileGL/MG_Util/Converters/EGLToStr/EGLEnumConverter.h

@@ -12,5 +12,5 @@
 namespace MobileGL {
     namespace MG_Util {
         String ConvertEGLEnumToString(GLenum value);
-    }
+    } // namespace MG_Util
 } // namespace MobileGL

MobileGL/MG_Util/Converters/GLToGlslang/ProgramEnumConverter.h

@@ -12,5 +12,5 @@
 namespace MobileGL {
     namespace MG_Util {
         EShLanguage ConvertGLEnumToEShLanguage(GLenum shaderType);
-    }
+    } // namespace MG_Util
 } // namespace MobileGL

MobileGL/MG_Util/Converters/GLToMG/DataTypeConverter.h

@@ -12,5 +12,5 @@
 namespace MobileGL {
     namespace MG_Util {
         DataType ConvertGLEnumToDataType(GLenum type);
-    }
+    } // namespace MG_Util
 } // namespace MobileGL

MobileGL/MG_Util/Converters/GLToMG/ProgramEnumConverter.h

@@ -13,5 +13,5 @@
 namespace MobileGL {
     namespace MG_Util {
         ShaderStage ConvertGLEnumToShaderStage(GLenum type);
-    }
+    } // namespace MG_Util
 } // namespace MobileGL

MobileGL/MG_Util/Converters/GLToStr/GLEnumConverter.cpp

@@ -1823,7 +1823,7 @@ namespace MobileGL {
                 CASE(GL_FOG_SPECULAR_TEXTURE_WIN)
 
             default:
-                return std::format("0x%x", value);
+                return std::format("0x{:x}", value);
             }
 #undef CASE
         }

MobileGL/MG_Util/Converters/GLToStr/GLEnumConverter.h

@@ -12,5 +12,5 @@
 namespace MobileGL {
     namespace MG_Util {
         String ConvertGLEnumToString(GLenum value);
-    }
+    } // namespace MG_Util
 } // namespace MobileGL

MobileGL/MG_Util/Converters/MGToGL/DataTypeConverter.h

@@ -12,5 +12,5 @@
 namespace MobileGL {
     namespace MG_Util {
         GLenum ConvertDataTypeToGLEnum(DataType type);
-    }
+    } // namespace MG_Util
 } // namespace MobileGL

MobileGL/MG_Util/Converters/MGToGL/ErrorCodeConverter.h

@@ -13,5 +13,5 @@
 namespace MobileGL {
     namespace MG_Util {
         GLenum ConvertErrorCodeToGLEnum(ErrorCode code);
-    }
+    } // namespace MG_Util
 } // namespace MobileGL

MobileGL/MG_Util/Converters/MGToGL/ProgramEnumConverter.h

@@ -13,5 +13,5 @@
 namespace MobileGL {
     namespace MG_Util {
         GLenum ConvertShaderStageToGLEnum(ShaderStage stage);
-    }
+    } // namespace MG_Util
 } // namespace MobileGL

MobileGL/MG_Util/Converters/MGToStr/DataTypeConverter.h

@@ -12,5 +12,5 @@
 namespace MobileGL {
     namespace MG_Util {
         String ConvertDataTypeToString(DataType type);
-    }
+    } // namespace MG_Util
 } // namespace MobileGL

MobileGL/MG_Util/Converters/MGToStr/GLExtensionConverter.h

@@ -12,5 +12,5 @@
 namespace MobileGL {
     namespace MG_Util {
         String ConvertGLExtToString(GLExtension extension);
-    }
+    } // namespace MG_Util
 } // namespace MobileGL

MobileGL/MG_Util/Metrics/BufferMetrics.h

@@ -12,5 +12,5 @@
 namespace MobileGL {
     namespace MG_Util {
         SizeT GetGLTypeSize(GLenum type);
-    }
+    } // namespace MG_Util
 } // namespace MobileGL

MobileGL/MG_Util/Texture/PixelStoreProcessor.cpp

@@ -72,7 +72,7 @@ namespace MobileGL::MG_Util::PixelStoreProcessor {
 
     // assume 8 bit per channel
     // swizzle.size() == channel count
-    static void ProcessColorSwizzle(void* data, SizeT pixelCount, const Vector<TextureSwizzleParam>& swizzle) {
+    void ProcessColorSwizzle(void* data, SizeT pixelCount, const Vector<TextureSwizzleParam>& swizzle) {
         const auto bpp = swizzle.size();
         Uint8* bytes = static_cast<Uint8*>(data);
         Uint8 pixelScratch[4];
@@ -172,22 +172,25 @@ namespace MobileGL::MG_Util::PixelStoreProcessor {
         return outputPixels;
     }
 
-    void* ProcessTexturePixelsDataPack(const void* inputPixels, const PixelStoreParameters& params, SizeT pixelSize,
+    void* ProcessTexturePixelsDataPack(const void* inputPixels, const PixelStoreParameters& params,
+                                       TextureInternalFormat srcInternalFormat, TexturePixelDataType srcDataType,
+                                       TextureInputFormat dstInputFormat, TexturePixelDataType dstDataType,
                                        IntVec3 dimension, Bool isBitmap, SizeT& outSize) {
-        if (pixelSize == 0) {
+        const SizeT pixelSize = MG_Util::GetInternalBytesPerPixel(srcInternalFormat, srcDataType);
-            outSize = 0;
-            return nullptr;
-        }
 
         Int width = dimension.x();
         Int height = dimension.y();
         Int depth = dimension.z();
 
-        const Int outputWidth = (params.RowLength > 0) ? params.RowLength : width;
+        if (pixelSize == 0) {
-        const SizeT outputRowStride = CalculateRowStride(outputWidth, pixelSize, params.Alignment);
+            outSize = 0;
-        const SizeT inputRowStride = static_cast<SizeT>(width) * pixelSize;
+            return nullptr;
+        }
 
-        const Int effectiveHeight = (params.ImageHeight > 0) ? params.ImageHeight : height;
+        // TODO: take care of PixelStoreParameters
+        const SizeT outputRowStride = width * pixelSize;
+        const Int effectiveHeight = height;
+        const SizeT inputRowStride = outputRowStride;
 
         outSize = static_cast<SizeT>(outputRowStride) * static_cast<SizeT>(effectiveHeight) * static_cast<SizeT>(depth);
         void* outputPixels = malloc(outSize);
@@ -201,12 +204,22 @@ namespace MobileGL::MG_Util::PixelStoreProcessor {
         const Uint8* src = static_cast<const Uint8*>(inputPixels);
         Uint8* dst = static_cast<Uint8*>(outputPixels);
 
-        dst += static_cast<SizeT>(params.SkipImages) * static_cast<SizeT>(effectiveHeight) * outputRowStride;
-        dst += static_cast<SizeT>(params.SkipRows) * outputRowStride;
-        dst += static_cast<SizeT>(params.SkipPixels) * pixelSize;
-
         Vector<Uint8> tempRow(static_cast<SizeT>(width) * pixelSize);
 
+        bool needSwizzle = false;
+        static Vector<TextureSwizzleParam> swizzle;
+        swizzle = {TextureSwizzleParam::Red, TextureSwizzleParam::Green, TextureSwizzleParam::Blue,
+                   TextureSwizzleParam::Alpha};
+        if (srcInternalFormat == TextureInternalFormat::RGBA && dstInputFormat == TextureInputFormat::BGRA) {
+            swizzle = {TextureSwizzleParam::Blue, TextureSwizzleParam::Green, TextureSwizzleParam::Red,
+                       TextureSwizzleParam::Alpha};
+            needSwizzle = true;
+        }
+        if (dstDataType == TexturePixelDataType::UnsignedInt8888) {
+            std::reverse(swizzle.begin(), swizzle.end());
+            needSwizzle = true;
+        }
+
         for (Int z = 0; z < depth; ++z) {
             Uint8* layerDst = dst;
             const Uint8* layerSrc = src;
@@ -222,6 +235,10 @@ namespace MobileGL::MG_Util::PixelStoreProcessor {
                     ProcessLSBFirst(tempRow.data(), static_cast<SizeT>(width), 1);
                 }
 
+                if (needSwizzle) {
+                    ProcessColorSwizzle(tempRow.data(), static_cast<SizeT>(width), swizzle);
+                }
+
                 Memcpy(layerDst, tempRow.data(), static_cast<SizeT>(width) * pixelSize);
 
                 layerSrc += inputRowStride;

MobileGL/MG_Util/Texture/PixelStoreProcessor.h

@@ -17,6 +17,9 @@ namespace MobileGL::MG_Util::PixelStoreProcessor {
                                          TextureInternalFormat targetInternalFormat,
                                          TextureInputFormat textureInputFormat, TexturePixelDataType inputDataType,
                                          IntVec3 dimension, Bool isBitmap, SizeT& outSize);
-    void* ProcessTexturePixelsDataPack(const void* inputPixels, const PixelStoreParameters& params, SizeT pixelSize,
+    void* ProcessTexturePixelsDataPack(const void* inputPixels, const PixelStoreParameters& params,
+                                       TextureInternalFormat srcInternalFormat, TexturePixelDataType srcDataType,
+                                       TextureInputFormat dstInputFormat, TexturePixelDataType dstDataType,
                                        IntVec3 dimension, Bool isBitmap, SizeT& outSize);
+    void ProcessColorSwizzle(void* data, SizeT pixelCount, const Vector<TextureSwizzleParam>& swizzle);
 } // namespace MobileGL::MG_Util::PixelStoreProcessor

MobileGL/MG_Util/Texture/TextureFormatProcessor.h

@@ -17,5 +17,5 @@ namespace MobileGL {
     namespace MG_Util::TextureFormatProcessor {
         void NormalizePixelFormat(GLenum internalFormat, Flags<PixelFormatNormalizeOptionBit> options,
                                   GLenum* outInternalFormat, GLenum* outFormat, GLenum* outType);
-    }
+    } // namespace MG_Util::TextureFormatProcessor
 } // namespace MobileGL

MobileGL/MG_Util/Types.h

@@ -75,6 +75,10 @@ namespace MobileGL {
         using E = std::common_type_t<Ts...>;
         return std::array<E, sizeof...(Ts)>{{std::forward<Ts>(elems)...}};
     }
+    template <typename T>
+    inline String ToString(const T& value) {
+        return std::to_string(value);
+    }
     class RuntimeError : public std::runtime_error {
     public:
         using std::runtime_error::runtime_error;
@@ -252,7 +256,7 @@ namespace MobileGL {
         }
     };
 
-    struct BackendCap {
+    struct StaticBackendCapabilityT {
         Bool AllowVSOnlyPrograms = false;
     };
 
@@ -268,7 +272,7 @@ namespace MobileGL {
         String BackendName;
         Optional<String> ExtraVendor;
         GLInfo RendererGLInfo;
-        BackendCap BackendCapability;
+        StaticBackendCapabilityT StaticBackendCapability;
     };
 
     template <typename Bit,

scripts/format_code.sh

@@ -18,7 +18,7 @@ cd "$(dirname "$0")" || { printf "%s\n" "Cannot cd to script dir"; exit 1; }
 DIR="../MobileGL"
 CLANG_FORMAT_CONFIG="../.clang-format"
 
-CLANG_FORMAT_PATH="$(command -v clang-format-21 2>/dev/null || true)"
+CLANG_FORMAT_PATH="$(command -v clang-format-23 2>/dev/null || true)"
 if [ -z "$CLANG_FORMAT_PATH" ]; then
     CLANG_FORMAT_PATH="$(command -v clang-format 2>/dev/null || true)"
 fi