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

MobileGL/MG_Impl/EGLImpl/EGLImpl.cpp

@@ -9,177 +9,451 @@
 #include "EGLImpl.h"
 #include "../GetProcAddress.h"
 #include <MG_Backend/BackendObjects.h>
+#include <MG_State/EGLState/Core.h>
+#include <type_traits>
 
 namespace MobileGL::MG_Impl::EGLImpl {
+    namespace {
+        using EGLStateContext = MG_State::EGLState::EGLContext;
+
+        EGLStateContext* GetState() {
+            if (!MG_State::pEGLContext) {
+                MGLOG_E("pEGLContext is null. MG_State may not be initialized.");
+            }
+            return MG_State::pEGLContext.get();
+        }
+
+        MG_Backend::BackendObject* GetBackendObject(EGLStateContext* state) {
+            auto* backendObject = MG_Backend::pActiveBackendObject.get();
+            if (!backendObject && state) {
+                state->SetError(EGL_NOT_INITIALIZED);
+            }
+            return backendObject;
+        }
+
+        MG_Backend::WindowBackend DetectWindowBackend() {
+#if defined(ANDROID) || defined(__ANDROID__)
+            return MG_Backend::WindowBackend::Android;
+#else
+            return MG_Backend::WindowBackend::Unknown;
+#endif
+        }
+
+        template <typename NativeType>
+        Bool IsNullNativeHandle(NativeType nativeHandle) {
+            if constexpr (std::is_pointer_v<NativeType>) {
+                return nativeHandle == nullptr;
+            } else {
+                return nativeHandle == 0;
+            }
+        }
+
+        template <typename NativeType>
+        void* ToVoidHandle(NativeType nativeHandle) {
+            if constexpr (std::is_pointer_v<NativeType>) {
+                return reinterpret_cast<void*>(nativeHandle);
+            } else {
+                return reinterpret_cast<void*>(static_cast<SizeT>(nativeHandle));
+            }
+        }
+    } // namespace
+
     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) {
+        auto* state = GetState();
+        if (!state) {
+            return EGL_NO_SURFACE;
+        }
+        if (!state->IsDisplayInitialized(dpy)) {
+            state->SetError(EGL_NOT_INITIALIZED);
+            return EGL_NO_SURFACE;
+        }
+        if (!state->ValidateConfigOnDisplay(dpy, config)) {
+            state->SetError(EGL_BAD_CONFIG);
+            return EGL_NO_SURFACE;
+        }
+        if (IsNullNativeHandle(window)) {
+            state->SetError(EGL_BAD_NATIVE_WINDOW);
+            return EGL_NO_SURFACE;
+        }
+
+        auto* backendObject = GetBackendObject(state);
+        if (!backendObject) {
             MGLOG_E("activeBackendObject not initialized!");
             return EGL_NO_SURFACE;
         }
-        activeBackendObject->SetWindowHandle({MG_Backend::WindowBackend::Android, reinterpret_cast<void*>(window)});
-        activeBackendObject->InitWindowSurface();
-        return (EGLSurface)1;
+
+        const MG_Backend::WindowHandle windowHandle = {
+            .Backend = DetectWindowBackend(),
+            .Handle = ToVoidHandle(window),
+        };
+        if (!backendObject->CreateEGLWindowSurface(windowHandle)) {
+            state->SetError(EGL_BAD_NATIVE_WINDOW);
+            return EGL_NO_SURFACE;
+        }
+
+        return state->CreateWindowSurface(dpy, config, window, attrib_list);
     }
 
     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!");
+        auto* state = GetState();
+        if (!state) {
+            return EGL_FALSE;
+        }
+        if (!state->ValidateSurfaceOnDisplay(dpy, draw)) {
+            state->SetError(EGL_BAD_SURFACE);
+            return EGL_FALSE;
+        }
+
+        auto* backendObject = GetBackendObject(state);
+        if (!backendObject) {
+            MGLOG_E("activeBackendObject not initialized!");
+            return EGL_FALSE;
+        }
+        if (!backendObject->SwapEGLBuffers(dpy, draw)) {
+            state->SetError(EGL_BAD_SURFACE);
             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;
+        auto* state = GetState();
+        if (!state) {
+            return EGL_FALSE;
+        }
+        return state->ChooseConfig(dpy, attrib_list, configs, config_size, num_config) ? EGL_TRUE : EGL_FALSE;
     }
 
     EGLContext CreateContext(EGLDisplay dpy, EGLConfig config, EGLContext shareCtx, const EGLint* attrib_list) {
-        return (EGLContext)1;
+        auto* state = GetState();
+        if (!state) {
+            return EGL_NO_CONTEXT;
+        }
+        return state->CreateContext(dpy, config, shareCtx, attrib_list);
     }
 
     EGLBoolean Initialize(EGLDisplay dpy, EGLint* major, EGLint* minor) {
-        if (major) *major = 1;
-        if (minor) *minor = 5;
+        auto* state = GetState();
+        if (!state) {
+            return EGL_FALSE;
+        }
+        if (!state->InitializeDisplay(dpy, major, minor)) {
+            return EGL_FALSE;
+        }
+
+        auto* backendObject = GetBackendObject(state);
+        if (!backendObject) {
+            MGLOG_E("activeBackendObject not initialized!");
+            return EGL_FALSE;
+        }
+        if (!backendObject->InitializeEGLDisplay(dpy, major, minor)) {
+            state->SetError(EGL_NOT_INITIALIZED);
+            return EGL_FALSE;
+        }
         return EGL_TRUE;
     }
 
     EGLDisplay GetDisplay(NativeDisplayType display) {
-        return (EGLDisplay)1;
+        auto* state = GetState();
+        if (!state) {
+            return EGL_NO_DISPLAY;
+        }
+        return state->GetDisplay(display);
     }
 
     EGLint GetError() {
-        return EGL_SUCCESS;
+        auto* state = GetState();
+        if (!state) {
+            return EGL_NOT_INITIALIZED;
+        }
+        return state->ConsumeError();
     }
 
     EGLBoolean MakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx) {
-        const auto& activeBackendObject = MG_Backend::pActiveBackendObject;
-        if (!activeBackendObject) {
+        auto* state = GetState();
+        if (!state) {
+            return EGL_FALSE;
+        }
+
+        const auto oldDisplay = state->GetCurrentDisplay();
+        const auto oldDraw = state->GetCurrentSurface(EGL_DRAW);
+        const auto oldRead = state->GetCurrentSurface(EGL_READ);
+        const auto oldContext = state->GetCurrentContext();
+
+        if (!state->MakeCurrent(dpy, draw, read, ctx)) {
+            return EGL_FALSE;
+        }
+
+        const Bool releaseCurrentRequest =
+            dpy == EGL_NO_DISPLAY && draw == EGL_NO_SURFACE && read == EGL_NO_SURFACE && ctx == EGL_NO_CONTEXT;
+        if (releaseCurrentRequest) {
+            if (auto* backendObject = MG_Backend::pActiveBackendObject.get()) {
+                (void)backendObject->MakeEGLCurrent(dpy, draw, read, ctx);
+            }
+            return EGL_TRUE;
+        }
+
+        auto* backendObject = GetBackendObject(state);
+        if (!backendObject) {
             MGLOG_E("activeBackendObject not initialized!");
+            state->MakeCurrent(oldDisplay, oldDraw, oldRead, oldContext);
+            return EGL_FALSE;
+        }
+        if (!backendObject->MakeEGLCurrent(dpy, draw, read, ctx)) {
+            state->SetError(EGL_BAD_ACCESS);
+            state->MakeCurrent(oldDisplay, oldDraw, oldRead, oldContext);
             return EGL_FALSE;
         }
-        activeBackendObject->InitCapabilities();
         return EGL_TRUE;
     }
 
     EGLBoolean DestroyContext(EGLDisplay dpy, EGLContext ctx) {
-        return EGL_TRUE;
+        auto* state = GetState();
+        if (!state) {
+            return EGL_FALSE;
+        }
+        return state->DestroyContext(dpy, ctx) ? EGL_TRUE : EGL_FALSE;
     }
 
     EGLBoolean DestroySurface(EGLDisplay dpy, EGLSurface surface) {
-        return EGL_TRUE;
+        auto* state = GetState();
+        if (!state) {
+            return EGL_FALSE;
+        }
+        return state->DestroySurface(dpy, surface) ? EGL_TRUE : EGL_FALSE;
     }
 
     EGLBoolean Terminate(EGLDisplay dpy) {
-        return EGL_TRUE;
+        auto* state = GetState();
+        if (!state) {
+            return EGL_FALSE;
+        }
+        return state->TerminateDisplay(dpy) ? EGL_TRUE : EGL_FALSE;
     }
 
     EGLBoolean ReleaseThread() {
+        auto* state = GetState();
+        if (!state) {
+            return EGL_FALSE;
+        }
+        state->ReleaseThread();
         return EGL_TRUE;
     }
 
     EGLContext GetCurrentContext() {
-        return (EGLContext)1;
+        auto* state = GetState();
+        if (!state) {
+            return EGL_NO_CONTEXT;
+        }
+        return state->GetCurrentContext();
     }
 
     EGLBoolean GetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint* value) {
-        if (attribute == EGL_NATIVE_VISUAL_ID) {
-#if defined(ANDROID)
-            *value = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
+        auto* state = GetState();
+        if (!state) {
+            return EGL_FALSE;
+        }
+        return state->GetConfigAttrib(dpy, config, attribute, value) ? EGL_TRUE : EGL_FALSE;
+    }
+
+    EGLBoolean BindAPI(EGLenum api) {
+        auto* state = GetState();
+        if (!state) {
+            return EGL_FALSE;
+        }
+        switch (api) {
+        case EGL_OPENGL_API:
+        case EGL_OPENGL_ES_API:
+        case EGL_OPENVG_API:
+            state->SetBoundAPI(api);
             return EGL_TRUE;
-#elif defined(__linux__)
-            *value = 0;
-            return EGL_TRUE;
-#elif defined(_WIN32)
-            *value = 0;
-            return EGL_TRUE;
-#else
-            *value = 0;
+        default:
+            state->SetError(EGL_BAD_PARAMETER);
+            return EGL_FALSE;
+        }
+    }
+
+    EGLSurface GetCurrentSurface(EGLint readdraw) {
+        auto* state = GetState();
+        if (!state) {
+            return EGL_NO_SURFACE;
+        }
+        return state->GetCurrentSurface(readdraw);
+    }
+
+    EGLBoolean QuerySurface(EGLDisplay display, EGLSurface surface, EGLint attribute, EGLint* value) {
+        auto* state = GetState();
+        if (!state) {
+            return EGL_FALSE;
+        }
+        return state->QuerySurface(display, surface, attribute, value) ? EGL_TRUE : EGL_FALSE;
+    }
+
+    char const* QueryString(EGLDisplay display, EGLint name) {
+        auto* state = GetState();
+        if (!state) {
+            return nullptr;
+        }
+
+        if (display != EGL_NO_DISPLAY && !state->ValidateDisplay(display)) {
+            state->SetError(EGL_BAD_DISPLAY);
+            return nullptr;
+        }
+
+        switch (name) {
+        case EGL_VENDOR:
+            return "MobileGL";
+        case EGL_VERSION:
+            return "1.5 MobileGL";
+        case EGL_CLIENT_APIS:
+            return "OpenGL OpenGL_ES";
+        case EGL_EXTENSIONS:
+            return "";
+        default:
+            state->SetError(EGL_BAD_PARAMETER);
+            return nullptr;
+        }
+    }
+
+    EGLBoolean SwapInterval(EGLDisplay dpy, EGLint interval) {
+        auto* state = GetState();
+        if (!state) {
+            return EGL_FALSE;
+        }
+        return state->SwapInterval(dpy, interval) ? EGL_TRUE : EGL_FALSE;
+    }
+
+    EGLSurface CreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint* attrib_list) {
+        auto* state = GetState();
+        if (!state) {
+            return EGL_NO_SURFACE;
+        }
+        return state->CreatePbufferSurface(dpy, config, attrib_list);
+    }
+
+    EGLBoolean BindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) {
+        auto* state = GetState();
+        if (!state) {
+            return EGL_FALSE;
+        }
+        if (!state->ValidateSurfaceOnDisplay(dpy, surface)) {
+            state->SetError(EGL_BAD_SURFACE);
+            return EGL_FALSE;
+        }
+        if (buffer != EGL_BACK_BUFFER) {
+            state->SetError(EGL_BAD_PARAMETER);
             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) {
+        auto* state = GetState();
+        if (!state) {
+            return EGL_FALSE;
+        }
+        if (!state->ValidateSurfaceOnDisplay(dpy, surface)) {
+            state->SetError(EGL_BAD_SURFACE);
+            return EGL_FALSE;
+        }
+        if (buffer != EGL_BACK_BUFFER) {
+            state->SetError(EGL_BAD_PARAMETER);
+            return EGL_FALSE;
+        }
         return EGL_TRUE;
     }
 
     EGLBoolean CopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target) {
+        auto* state = GetState();
+        if (!state) {
+            return EGL_FALSE;
+        }
+        if (!state->ValidateSurfaceOnDisplay(dpy, surface)) {
+            state->SetError(EGL_BAD_SURFACE);
+            return EGL_FALSE;
+        }
+        if (IsNullNativeHandle(target)) {
+            state->SetError(EGL_BAD_NATIVE_PIXMAP);
+            return EGL_FALSE;
+        }
         return EGL_TRUE;
     }
 
     EGLSurface CreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config,
                                              const EGLint* attrib_list) {
-        return (EGLSurface)1;
+        auto* state = GetState();
+        if (!state) {
+            return EGL_NO_SURFACE;
+        }
+        return state->CreatePbufferFromClientBuffer(dpy, buftype, buffer, config, attrib_list);
     }
 
     EGLSurface CreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap,
                                    const EGLint* attrib_list) {
-        return (EGLSurface)1;
+        auto* state = GetState();
+        if (!state) {
+            return EGL_NO_SURFACE;
+        }
+        return state->CreatePixmapSurface(dpy, config, pixmap, attrib_list);
     }
 
     EGLBoolean GetConfigs(EGLDisplay dpy, EGLConfig* configs, EGLint config_size, EGLint* num_config) {
-        if (num_config) {
-            *num_config = 1;
+        auto* state = GetState();
+        if (!state) {
+            return EGL_FALSE;
         }
-        if (configs && config_size > 0) {
-            configs[0] = (EGLConfig)1;
-        }
-        return EGL_TRUE;
+        return state->GetConfigs(dpy, configs, config_size, num_config) ? EGL_TRUE : EGL_FALSE;
     }
 
     EGLDisplay GetCurrentDisplay() {
-        return (EGLDisplay)1;
+        auto* state = GetState();
+        if (!state) {
+            return EGL_NO_DISPLAY;
+        }
+        return state->GetCurrentDisplay();
     }
 
     EGLenum QueryAPI() {
-        return EGL_OPENGL_API;
+        auto* state = GetState();
+        if (!state) {
+            return EGL_OPENGL_API;
+        }
+        return state->GetBoundAPI();
     }
 
     EGLBoolean QueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint* value) {
-        if (value) {
-            *value = 1;
+        auto* state = GetState();
+        if (!state) {
+            return EGL_FALSE;
         }
-        return EGL_TRUE;
+        return state->QueryContext(dpy, ctx, attribute, value) ? EGL_TRUE : EGL_FALSE;
     }
 
     EGLBoolean SurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value) {
-        return EGL_TRUE;
+        (void)value;
+
+        auto* state = GetState();
+        if (!state) {
+            return EGL_FALSE;
+        }
+        if (!state->ValidateSurfaceOnDisplay(dpy, surface)) {
+            state->SetError(EGL_BAD_SURFACE);
+            return EGL_FALSE;
+        }
+
+        switch (attribute) {
+        case EGL_MIPMAP_LEVEL:
+        case EGL_SWAP_BEHAVIOR:
+        case EGL_TEXTURE_FORMAT:
+        case EGL_TEXTURE_TARGET:
+        case EGL_MIPMAP_TEXTURE:
+            return EGL_TRUE;
+        default:
+            state->SetError(EGL_BAD_ATTRIBUTE);
+            return EGL_FALSE;
+        }
     }
 
     EGLBoolean WaitClient() {
@@ -191,60 +465,132 @@ namespace MobileGL::MG_Impl::EGLImpl {
     }
 
     EGLBoolean WaitNative(EGLint engine) {
+        (void)engine;
         return EGL_TRUE;
     }
 
     EGLSync CreateSync(EGLDisplay dpy, EGLenum type, const EGLAttrib* attrib_list) {
-        return reinterpret_cast<EGLSync>(0x1);
+        auto* state = GetState();
+        if (!state) {
+            return EGL_NO_SYNC;
+        }
+        return state->CreateSync(dpy, type, attrib_list);
     }
 
-    EGLBoolean DestroySync(void* dpy, void* sync) {
-        return EGL_TRUE;
+    EGLBoolean DestroySync(EGLDisplay dpy, EGLSync sync) {
+        auto* state = GetState();
+        if (!state) {
+            return EGL_FALSE;
+        }
+        return state->DestroySync(dpy, sync) ? EGL_TRUE : EGL_FALSE;
     }
 
     EGLint ClientWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout) {
-        return EGL_CONDITION_SATISFIED;
+        auto* state = GetState();
+        if (!state) {
+            return EGL_FALSE;
+        }
+        return state->ClientWaitSync(dpy, sync, flags, timeout);
     }
 
     EGLBoolean GetSyncAttrib(EGLDisplay dpy, EGLSync sync, EGLint attribute, EGLAttrib* value) {
-        if (value) {
-            *value = 1;
+        auto* state = GetState();
+        if (!state) {
+            return EGL_FALSE;
         }
-        return EGL_TRUE;
+        return state->GetSyncAttrib(dpy, sync, attribute, value) ? EGL_TRUE : EGL_FALSE;
     }
 
     EGLImage CreateImage(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer,
                          const EGLAttrib* attrib_list) {
-        return reinterpret_cast<EGLImage>(0x1);
+        auto* state = GetState();
+        if (!state) {
+            return EGL_NO_IMAGE;
+        }
+        return state->CreateImage(dpy, ctx, target, buffer, attrib_list);
     }
 
     EGLBoolean DestroyImage(EGLDisplay dpy, EGLImage image) {
-        return EGL_TRUE;
+        auto* state = GetState();
+        if (!state) {
+            return EGL_FALSE;
+        }
+        return state->DestroyImage(dpy, image) ? EGL_TRUE : EGL_FALSE;
     }
 
     EGLDisplay GetPlatformDisplay(EGLenum platform, void* native_display, const EGLAttrib* attrib_list) {
-        return reinterpret_cast<EGLDisplay>(0x1);
+        (void)attrib_list;
+
+        auto* state = GetState();
+        if (!state) {
+            return EGL_NO_DISPLAY;
+        }
+        return state->GetPlatformDisplay(platform, native_display);
     }
 
     EGLSurface CreatePlatformWindowSurface(EGLDisplay dpy, EGLConfig config, void* native_window,
                                            const EGLAttrib* attrib_list) {
-        return reinterpret_cast<EGLSurface>(0x1);
+        auto* state = GetState();
+        if (!state) {
+            return EGL_NO_SURFACE;
+        }
+        if (native_window == nullptr) {
+            state->SetError(EGL_BAD_NATIVE_WINDOW);
+            return EGL_NO_SURFACE;
+        }
+        if (!state->IsDisplayInitialized(dpy)) {
+            state->SetError(EGL_NOT_INITIALIZED);
+            return EGL_NO_SURFACE;
+        }
+        if (!state->ValidateConfigOnDisplay(dpy, config)) {
+            state->SetError(EGL_BAD_CONFIG);
+            return EGL_NO_SURFACE;
+        }
+
+        auto* backendObject = GetBackendObject(state);
+        if (!backendObject) {
+            MGLOG_E("activeBackendObject not initialized!");
+            return EGL_NO_SURFACE;
+        }
+
+        const MG_Backend::WindowHandle windowHandle = {
+            .Backend = DetectWindowBackend(),
+            .Handle = native_window,
+        };
+        if (!backendObject->CreateEGLWindowSurface(windowHandle)) {
+            state->SetError(EGL_BAD_NATIVE_WINDOW);
+            return EGL_NO_SURFACE;
+        }
+
+        return state->CreatePlatformWindowSurface(dpy, config, native_window, attrib_list);
     }
 
     EGLSurface CreatePlatformPixmapSurface(EGLDisplay dpy, EGLConfig config, void* native_pixmap,
                                            const EGLAttrib* attrib_list) {
-        return reinterpret_cast<EGLSurface>(0x1);
+        auto* state = GetState();
+        if (!state) {
+            return EGL_NO_SURFACE;
+        }
+        return state->CreatePlatformPixmapSurface(dpy, config, native_pixmap, attrib_list);
     }
 
-    EGLBoolean WaitSync(void* dpy, void* sync, int flags) {
-        return EGL_TRUE;
+    EGLBoolean WaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags) {
+        auto* state = GetState();
+        if (!state) {
+            return EGL_FALSE;
+        }
+        return state->WaitSync(dpy, sync, flags) ? EGL_TRUE : EGL_FALSE;
     }
 
     __eglMustCastToProperFunctionPointerType GetProcAddress(const char* name) {
+        if (!name) {
+            return nullptr;
+        }
+
         MGLOG_D("eglGetProcAddress(%s)", name);
         void* proc = MG_Impl::GetProcAddress(name);
         if (!proc) {
-            MGLOG_W("Failed to get function: %s", (const char*)name);
+            MGLOG_W("Failed to get function: %s", name);
             return nullptr;
         }
         return (__eglMustCastToProperFunctionPointerType)proc;

MobileGL/MG_Impl/EGLImpl/EGLImpl.h

@@ -48,7 +48,7 @@ namespace MobileGL::MG_Impl::EGLImpl {
     EGLBoolean WaitGL();
     EGLBoolean WaitNative(EGLint engine);
     EGLSync CreateSync(EGLDisplay dpy, EGLenum type, const EGLAttrib* attrib_list);
-    EGLBoolean DestroySync(void* dpy, void* sync);
+    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,
@@ -59,6 +59,6 @@ namespace MobileGL::MG_Impl::EGLImpl {
                                            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);
+    EGLBoolean WaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags);
     __eglMustCastToProperFunctionPointerType GetProcAddress(const char* name);
 } // namespace MobileGL::MG_Impl::EGLImpl

MobileGL/MG_Impl/GLImpl/Buffer/GL_Buffer.h

@@ -9,24 +9,22 @@
 #pragma once
 #include <Includes.h>
 
-namespace MobileGL {
-    namespace MG_Impl::GLImpl {
-        /* @INSERTION_POINT:FUNCTION_DECLARATION@ */
-        void GetBufferParameteriv(GLenum target, GLenum pname, GLint* params);
-        GLboolean IsBuffer(GLuint buffer);
-        void DeleteBuffers(GLsizei n, const GLuint* buffers);
-        void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length);
-        GLboolean UnmapBuffer(GLenum target);
-        void* MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
-        void* MapBuffer(GLenum target, GLenum access);
-        void CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset,
-                               GLsizeiptr size);
-        void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data);
-        void BufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage);
-        void BindBuffer(GLenum target, GLuint buffer);
-        void GenBuffers(GLsizei n, GLuint* buffers);
-        void BindBufferBase(GLenum target, GLuint index, GLuint buffer);
-        void BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
+namespace MobileGL::MG_Impl::GLImpl {
+    /* @INSERTION_POINT:FUNCTION_DECLARATION@ */
+    void GetBufferParameteriv(GLenum target, GLenum pname, GLint* params);
+    GLboolean IsBuffer(GLuint buffer);
+    void DeleteBuffers(GLsizei n, const GLuint* buffers);
+    void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length);
+    GLboolean UnmapBuffer(GLenum target);
+    void* MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
+    void* MapBuffer(GLenum target, GLenum access);
+    void CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset,
+                           GLsizeiptr size);
+    void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data);
+    void BufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage);
+    void BindBuffer(GLenum target, GLuint buffer);
+    void GenBuffers(GLsizei n, GLuint* buffers);
+    void BindBufferBase(GLenum target, GLuint index, GLuint buffer);
+    void BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
 
-    } // namespace MG_Impl::GLImpl
-} // namespace MobileGL
+} // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/Buffer/Validators.cpp

@@ -13,105 +13,100 @@
 #include <MG_Util/Converters/MGToGL/BufferEnumConverter.h>
 #include <MG_Util/Converters/MGToStr/BufferEnumConverter.h>
 
-namespace MobileGL::MG_Impl::GLImpl {
-    namespace BufferImpl {
-        Bool ValidateBufferTarget(BufferTarget target) {
-            if (target == BufferTarget::Unknown) {
-                using namespace MG_Util;
-                String bufferTargetStr = ConvertBufferTargetToString(target);
-                String glTargetStr = ConvertGLEnumToString(ConvertBufferTargetToGLEnum(target));
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidEnum,
-                    MakeShared<GenericErrorInfo>(
-                        "MG_Impl/GLImpl/BufferImpl", "ValidateBufferTarget",
-                        std::format("Target {} ({}) is not valid.", bufferTargetStr, glTargetStr)));
-                return false;
-            }
-
-            if (target == BufferTarget::Index && MG_State::pGLContext->GetBoundVertexArray() == nullptr) {
-                MG_State::pGLContext->RecordError(ErrorCode::InvalidOperation,
-                                                  MakeShared<GenericErrorInfo>("MG_Impl/GLImpl/BufferImpl",
-                                                                               "ValidateBufferTarget",
-                                                                               "No vertex array object is bound."));
-                return false;
-            }
-
-            return true;
-        }
-
-        Bool ValidateBufferBindingPointTarget(BufferTarget target) {
-            if (target != BufferTarget::Uniform && target != BufferTarget::AtomicCounter &&
-                target != BufferTarget::TransformFeedback && target != BufferTarget::ShaderStorage) {
-                using namespace MG_Util;
-                String bufferTargetStr = ConvertBufferTargetToString(target);
-                String glTargetStr = ConvertGLEnumToString(ConvertBufferTargetToGLEnum(target));
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidEnum,
-                    MakeShared<GenericErrorInfo>(
-                        "MG_Impl/GLImpl/BufferImpl", "ValidateBufferTarget",
-                        std::format("Target {} ({}) is not valid.", bufferTargetStr, glTargetStr)));
-                return false;
-            }
-            return true;
-        }
-
-        Bool ValidateBufferName(Uint index, Bool allowZero) {
-            if (index == 0) {
-                if (allowZero) return true;
-
-                MG_State::pGLContext->RecordError(ErrorCode::InvalidValue,
-                                                  MakeShared<GenericErrorInfo>("MG_Impl/GLImpl/BufferImpl",
-                                                                               "ValidateBufferName",
-                                                                               "Buffer name 0 is not valid."));
-                return false;
-            }
-            Bool isValid = MG_State::pGLContext->ValidateBufferName(index);
-            if (isValid) return true;
+namespace MobileGL::MG_Impl::GLImpl::BufferImpl {
+    Bool ValidateBufferTarget(BufferTarget target) {
+        if (target == BufferTarget::Unknown) {
+            using namespace MG_Util;
+            String bufferTargetStr = ConvertBufferTargetToString(target);
+            String glTargetStr = ConvertGLEnumToString(ConvertBufferTargetToGLEnum(target));
             MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeShared<GenericErrorInfo>("MG_Impl/GLImpl/BufferImpl", "ValidateBufferName",
-                                             std::format("Buffer name {} is not valid.", index)));
+                ErrorCode::InvalidEnum, MakeUnique<GenericErrorInfo>(
+                                            "MG_Impl/GLImpl/BufferImpl", "ValidateBufferTarget",
+                                            std::format("Target {} ({}) is not valid.", bufferTargetStr, glTargetStr)));
             return false;
         }
 
-        Bool ValidateBufferUsage(BufferUsage usage) {
-            if (usage != BufferUsage::Unknown) {
-                return true;
-            }
+        if (target == BufferTarget::Index && MG_State::pGLContext->GetBoundVertexArray() == nullptr) {
+            MG_State::pGLContext->RecordError(ErrorCode::InvalidOperation,
+                                              MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl/BufferImpl",
+                                                                           "ValidateBufferTarget",
+                                                                           "No vertex array object is bound."));
+            return false;
+        }
+
+        return true;
+    }
+
+    Bool ValidateBufferBindingPointTarget(BufferTarget target) {
+        if (target != BufferTarget::Uniform && target != BufferTarget::AtomicCounter &&
+            target != BufferTarget::TransformFeedback && target != BufferTarget::ShaderStorage) {
             using namespace MG_Util;
-            String bufferUsageStr = ConvertBufferUsageToString(usage);
-            String glUsageStr = ConvertGLEnumToString(ConvertBufferUsageToGLEnum(usage));
+            String bufferTargetStr = ConvertBufferTargetToString(target);
+            String glTargetStr = ConvertGLEnumToString(ConvertBufferTargetToGLEnum(target));
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidEnum, MakeUnique<GenericErrorInfo>(
+                                            "MG_Impl/GLImpl/BufferImpl", "ValidateBufferTarget",
+                                            std::format("Target {} ({}) is not valid.", bufferTargetStr, glTargetStr)));
+            return false;
+        }
+        return true;
+    }
+
+    Bool ValidateBufferName(Uint index, Bool allowZero) {
+        if (index == 0) {
+            if (allowZero) return true;
+
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidValue, MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl/BufferImpl", "ValidateBufferName",
+                                                                      "Buffer name 0 is not valid."));
+            return false;
+        }
+        Bool isValid = MG_State::pGLContext->ValidateBufferName(index);
+        if (isValid) return true;
+        MG_State::pGLContext->RecordError(
+            ErrorCode::InvalidOperation,
+            MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl/BufferImpl", "ValidateBufferName",
+                                         std::format("Buffer name {} is not valid.", index)));
+        return false;
+    }
+
+    Bool ValidateBufferUsage(BufferUsage usage) {
+        if (usage != BufferUsage::Unknown) {
+            return true;
+        }
+        using namespace MG_Util;
+        String bufferUsageStr = ConvertBufferUsageToString(usage);
+        String glUsageStr = ConvertGLEnumToString(ConvertBufferUsageToGLEnum(usage));
+        MG_State::pGLContext->RecordError(
+            ErrorCode::InvalidEnum,
+            MakeUnique<GenericErrorInfo>(
+                "MG_Impl/GLImpl/BufferImpl", "ValidateBufferUsage",
+                std::format("Usage {} ({}) is not one of the allowable values.", bufferUsageStr, glUsageStr)));
+        return false;
+    }
+
+    Bool ValidateBufferMappingAccess(Flags<BufferMappingAccessBit> accessBits) {
+        if (accessBits == BufferMappingAccessBit::Null) {
+            MG_State::pGLContext->RecordError(ErrorCode::InvalidEnum,
+                                              MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl/BufferImpl",
+                                                                           "ValidateBufferMappingAccess",
+                                                                           "Access bits cannot be null."));
+            return false;
+        }
+
+        const auto validBits = BufferMappingAccessBit::Read | BufferMappingAccessBit::Write |
+                               BufferMappingAccessBit::InvalidateRange | BufferMappingAccessBit::InvalidateBuffer |
+                               BufferMappingAccessBit::FlushExplicit | BufferMappingAccessBit::Unsynchronized |
+                               BufferMappingAccessBit::Persistent | BufferMappingAccessBit::Coherent;
+
+        if ((accessBits & validBits) != accessBits) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidEnum,
-                MakeShared<GenericErrorInfo>(
-                    "MG_Impl/GLImpl/BufferImpl", "ValidateBufferUsage",
-                    std::format("Usage {} ({}) is not one of the allowable values.", bufferUsageStr, glUsageStr)));
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl/BufferImpl", "ValidateBufferMappingAccess",
+                                             "Access bits cannot contain invalid flags."));
             return false;
         }
 
-        Bool ValidateBufferMappingAccess(Flags<BufferMappingAccessBit> accessBits) {
-            if (accessBits == BufferMappingAccessBit::Null) {
-                MG_State::pGLContext->RecordError(ErrorCode::InvalidEnum,
-                                                  MakeShared<GenericErrorInfo>("MG_Impl/GLImpl/BufferImpl",
-                                                                               "ValidateBufferMappingAccess",
-                                                                               "Access bits cannot be null."));
-                return false;
-            }
-
-            const auto validBits = BufferMappingAccessBit::Read | BufferMappingAccessBit::Write |
-                                   BufferMappingAccessBit::InvalidateRange | BufferMappingAccessBit::InvalidateBuffer |
-                                   BufferMappingAccessBit::FlushExplicit | BufferMappingAccessBit::Unsynchronized |
-                                   BufferMappingAccessBit::Persistent | BufferMappingAccessBit::Coherent;
-
-            if ((accessBits & validBits) != accessBits) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidEnum,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl/BufferImpl", "ValidateBufferMappingAccess",
-                                                 "Access bits cannot contain invalid flags."));
-                return false;
-            }
-
-            return true;
-        }
-    } // namespace BufferImpl
-} // namespace MobileGL::MG_Impl::GLImpl
+        return true;
+    }
+} // namespace MobileGL::MG_Impl::GLImpl::BufferImpl

MobileGL/MG_Impl/GLImpl/Buffer/Validators.h

@@ -10,12 +10,10 @@
 #include <Includes.h>
 #include <MG_State/GLState/BufferState/BufferObject.h>
 
-namespace MobileGL::MG_Impl::GLImpl {
-    namespace BufferImpl {
-        Bool ValidateBufferTarget(BufferTarget target);
-        Bool ValidateBufferName(Uint index, Bool allowZero = false);
-        Bool ValidateBufferUsage(BufferUsage usage);
-        Bool ValidateBufferMappingAccess(Flags<BufferMappingAccessBit> accessBits);
-        Bool ValidateBufferBindingPointTarget(BufferTarget target);
-    } // namespace BufferImpl
-} // namespace MobileGL::MG_Impl::GLImpl
+namespace MobileGL::MG_Impl::GLImpl::BufferImpl {
+    Bool ValidateBufferTarget(BufferTarget target);
+    Bool ValidateBufferName(Uint index, Bool allowZero = false);
+    Bool ValidateBufferUsage(BufferUsage usage);
+    Bool ValidateBufferMappingAccess(Flags<BufferMappingAccessBit> accessBits);
+    Bool ValidateBufferBindingPointTarget(BufferTarget target);
+} // namespace MobileGL::MG_Impl::GLImpl::BufferImpl

MobileGL/MG_Impl/GLImpl/Drawing/GL_Drawing.h

@@ -9,34 +9,31 @@
 #pragma once
 #include <Includes.h>
 
-namespace MobileGL {
-    namespace MG_Impl::GLImpl {
-        /* @INSERTION_POINT:FUNCTION_DECLARATION@ */
-        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 DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const void* indices, GLint basevertex);
-        void DrawArrays(GLenum mode, GLint first, GLsizei count);
-        void MultiDrawElements(GLenum mode, const GLsizei* count, GLenum type, const void* const* indices,
-                               GLsizei drawcount);
-        void MultiDrawElementsBaseVertex(GLenum mode, const GLsizei* count, GLenum type, const void* const* indices,
-                                         GLsizei drawcount, const GLint* basevertex);
-        void Clear(GLbitfield mask);
-        void DrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices);
-    } // namespace MG_Impl::GLImpl
-} // namespace MobileGL
+namespace MobileGL::MG_Impl::GLImpl {
+    /* @INSERTION_POINT:FUNCTION_DECLARATION@ */
+    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 DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const void* indices, GLint basevertex);
+    void DrawArrays(GLenum mode, GLint first, GLsizei count);
+    void MultiDrawElements(GLenum mode, const GLsizei* count, GLenum type, const void* const* indices,
+                           GLsizei drawcount);
+    void MultiDrawElementsBaseVertex(GLenum mode, const GLsizei* count, GLenum type, const void* const* indices,
+                                     GLsizei drawcount, const GLint* basevertex);
+    void Clear(GLbitfield mask);
+    void DrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices);
+} // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/Framebuffer/GL_Framebuffer.cpp

@@ -38,11 +38,11 @@ namespace MobileGL::MG_Impl::GLImpl {
         RenderbufferTarget rbTarget = MG_Util::ConvertGLEnumToRenderbufferTarget(target);
         if (!FramebufferImpl::ValidateRenderbufferTarget(rbTarget)) return;
         auto& bindingSlot = MG_State::pGLContext->GetRenderbufferBindingSlot(rbTarget);
-        auto renderbufferObject = bindingSlot.GetBoundObject();
+        auto& renderbufferObject = bindingSlot.GetBoundObject();
         if (!renderbufferObject) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidOperation,
-                MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "RenderbufferStorage_State",
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "RenderbufferStorage_State",
                                              "Renderbuffer target is bound to no renderbuffer object."));
             return;
         }
@@ -50,7 +50,7 @@ namespace MobileGL::MG_Impl::GLImpl {
         if (!TextureImpl::ValidateTextureInternalFormat(format)) return;
         if (width < 0 || height < 0) {
             MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "RenderbufferStorage_State",
+                ErrorCode::InvalidValue, MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "RenderbufferStorage_State",
                                                                       "Width and height must be non-negative."));
             return;
         }
@@ -74,10 +74,11 @@ namespace MobileGL::MG_Impl::GLImpl {
         if (n < 0) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidValue,
-                MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "GenRenderbuffers_State", "n must be non-negative"));
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "GenRenderbuffers_State", "n must be non-negative"));
             return;
         }
-        auto renderbufferNames = MG_State::pGLContext->GenRenderbufferNames(n);
+        static thread_local Vector<GLuint> renderbufferNames;
+        MG_State::pGLContext->GenRenderbufferNames(n, renderbufferNames);
         Memcpy(renderbuffers, renderbufferNames.data(), sizeof(GLuint) * static_cast<SizeT>(n));
     }
 
@@ -85,10 +86,11 @@ namespace MobileGL::MG_Impl::GLImpl {
         if (n < 0) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidValue,
-                MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "GenFramebuffers_State", "n must be non-negative"));
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "GenFramebuffers_State", "n must be non-negative"));
             return;
         }
-        auto framebuffersNames = MG_State::pGLContext->GenFramebufferNames(n);
+        static thread_local Vector<GLuint> framebuffersNames;
+        MG_State::pGLContext->GenFramebufferNames(n, framebuffersNames);
         Memcpy(framebuffers, framebuffersNames.data(), sizeof(GLuint) * static_cast<SizeT>(n));
     }
 
@@ -119,11 +121,11 @@ namespace MobileGL::MG_Impl::GLImpl {
         if (!TextureImpl::ValidateTextureName(texture, true)) return;
 
         auto& bindingSlot = MG_State::pGLContext->GetFramebufferBindingSlot(framebufferTarget);
-        auto framebufferObject = bindingSlot.GetBoundObject();
+        auto& framebufferObject = bindingSlot.GetBoundObject();
         if (!framebufferObject) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidOperation,
-                MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "FramebufferTexture2D_State",
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "FramebufferTexture2D_State",
                                              "Framebuffer target is bound to no framebuffer object."));
             return;
         }
@@ -133,11 +135,11 @@ namespace MobileGL::MG_Impl::GLImpl {
             return;
         }
 
-        auto textureObject = MG_State::pGLContext->GetTextureObject(texture);
+        auto& textureObject = MG_State::pGLContext->GetTextureObject(texture);
         if (!textureObject) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidOperation,
-                MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "FramebufferTexture2D_State",
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "FramebufferTexture2D_State",
                                              std::format("Texture object {} is not valid.", texture)));
             return;
         }
@@ -166,11 +168,11 @@ namespace MobileGL::MG_Impl::GLImpl {
         if (!FramebufferImpl::ValidateFramebufferTarget(framebufferTarget)) return;
         if (!FramebufferImpl::ValidateRenderbufferName(renderbuffer)) return;
         auto& bindingSlot = MG_State::pGLContext->GetFramebufferBindingSlot(framebufferTarget);
-        auto framebufferObject = bindingSlot.GetBoundObject();
+        auto& framebufferObject = bindingSlot.GetBoundObject();
         if (!framebufferObject) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidOperation,
-                MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "FramebufferRenderbuffer_State",
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "FramebufferRenderbuffer_State",
                                              "Framebuffer target is bound to no framebuffer object."));
             return;
         }
@@ -180,11 +182,11 @@ namespace MobileGL::MG_Impl::GLImpl {
             return;
         }
 
-        auto renderbufferObject = MG_State::pGLContext->GetRenderbufferObject(renderbuffer);
+        auto& renderbufferObject = MG_State::pGLContext->GetRenderbufferObject(renderbuffer);
         if (!renderbufferObject) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidOperation,
-                MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "FramebufferRenderbuffer_State",
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "FramebufferRenderbuffer_State",
                                              std::format("Renderbuffer object {} is not valid.", renderbuffer)));
             return;
         }
@@ -196,18 +198,18 @@ namespace MobileGL::MG_Impl::GLImpl {
         if (n < 0) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidValue,
-                MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "`n` is less than 0."));
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "`n` is less than 0."));
             return;
         } else if (n > MG_State::GLState::FramebufferObject::MAX_DRAW_BUFFERS) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidValue,
-                MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "`n` is greater than `GL_MAX_DRAW_BUFFERS`."));
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "`n` is greater than `GL_MAX_DRAW_BUFFERS`."));
             return;
         }
 
         // Get bound framebuffer
         auto& bindingSlot = MG_State::pGLContext->GetFramebufferBindingSlot(FramebufferTarget::Draw);
-        auto fbo = bindingSlot.GetBoundObject();
+        auto& fbo = bindingSlot.GetBoundObject();
         bool isDefaultFBO = (fbo == FramebufferImpl::pDefaultFramebufferInfo->defaultFBO);
 
         static int existenceMap[(SizeT)FramebufferAttachmentType::FramebufferAttachmentTypeCount] = {-1};
@@ -220,7 +222,7 @@ namespace MobileGL::MG_Impl::GLImpl {
             if (attType == FramebufferAttachmentType::Unknown) {
                 MG_State::pGLContext->RecordError(
                     ErrorCode::InvalidEnum,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
+                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
                                                  std::format("bufs[{}] = {} is not an accepted value.", i,
                                                              MG_Util::ConvertGLEnumToString(bufs[i]))));
                 return;
@@ -230,7 +232,7 @@ namespace MobileGL::MG_Impl::GLImpl {
                 attType <= FramebufferAttachmentType::Color31) {
                 MG_State::pGLContext->RecordError(
                     ErrorCode::InvalidEnum,
-                    MakeShared<GenericErrorInfo>(
+                    MakeUnique<GenericErrorInfo>(
                         "MG_Impl/GLImpl", __func__,
                         std::format(
                             "FBO is default FBO, but bufs[{}] = {} is one of the `GL_COLOR_ATTACHMENTn` tokens.", i,
@@ -242,7 +244,7 @@ namespace MobileGL::MG_Impl::GLImpl {
                 attType <= FramebufferAttachmentType::BackRight) {
                 MG_State::pGLContext->RecordError(
                     ErrorCode::InvalidEnum,
-                    MakeShared<GenericErrorInfo>(
+                    MakeUnique<GenericErrorInfo>(
                         "MG_Impl/GLImpl", __func__,
                         std::format("FBO is not default FBO, but bufs[{}] = {} is anything other than `GL_NONE` or "
                                     "one of the `GL_COLOR_ATTACHMENTn` tokens.",
@@ -253,7 +255,7 @@ namespace MobileGL::MG_Impl::GLImpl {
             if (attType != FramebufferAttachmentType::None && existenceMap[(SizeT)attType] >= 0) {
                 MG_State::pGLContext->RecordError(
                     ErrorCode::InvalidOperation,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
+                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
                                                  std::format("a symbolic constant other than `GL_NONE` appears "
                                                              "more than once in bufs. bufs[{}] == bufs[{}] == {}.",
                                                              i, existenceMap[(SizeT)attType],
@@ -267,7 +269,7 @@ namespace MobileGL::MG_Impl::GLImpl {
                 (SizeT)FramebufferAttachmentType::Color0 + MG_State::GLState::FramebufferObject::MAX_DRAW_BUFFERS) {
                 MG_State::pGLContext->RecordError(
                     ErrorCode::InvalidOperation,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
+                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
                                                  std::format("bufs[{}] == {} indicates a color buffer that does "
                                                              "not exist in the current GL context.",
                                                              i, MG_Util::ConvertGLEnumToString(bufs[i]))));
@@ -297,7 +299,7 @@ namespace MobileGL::MG_Impl::GLImpl {
         if (attType == FramebufferAttachmentType::Unknown) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidEnum,
-                MakeShared<GenericErrorInfo>(
+                MakeUnique<GenericErrorInfo>(
                     "MG_Impl/GLImpl", __func__,
                     std::format("`mode` = {} is not an accepted value.", MG_Util::ConvertGLEnumToString(mode))));
             return;
@@ -305,7 +307,7 @@ namespace MobileGL::MG_Impl::GLImpl {
 
         // Get bound framebuffer
         auto& bindingSlot = MG_State::pGLContext->GetFramebufferBindingSlot(FramebufferTarget::Read);
-        auto fbo = bindingSlot.GetBoundObject();
+        auto& fbo = bindingSlot.GetBoundObject();
         fbo->SetReadBuffer(attType);
     }
 
@@ -313,13 +315,13 @@ namespace MobileGL::MG_Impl::GLImpl {
         if (n < 0) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidValue,
-                MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "DeleteRenderbuffers_State", "n must be non-negative."));
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "DeleteRenderbuffers_State", "n must be non-negative."));
             return;
         }
 
         if (!renderbuffers) {
             MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "DeleteRenderbuffers_State",
+                ErrorCode::InvalidValue, MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "DeleteRenderbuffers_State",
                                                                       "Renderbuffer names array cannot be null."));
             return;
         }
@@ -336,13 +338,13 @@ namespace MobileGL::MG_Impl::GLImpl {
         if (n < 0) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidValue,
-                MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "DeleteFramebuffers_State", "n must be non-negative."));
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "DeleteFramebuffers_State", "n must be non-negative."));
             return;
         }
 
         if (!framebuffers) {
             MG_State::pGLContext->RecordError(ErrorCode::InvalidValue,
-                                              MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "DeleteFramebuffers_State",
+                                              MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "DeleteFramebuffers_State",
                                                                            "Framebuffer names array cannot be null."));
             return;
         }
@@ -360,11 +362,11 @@ namespace MobileGL::MG_Impl::GLImpl {
         if (!FramebufferImpl::ValidateFramebufferTarget(framebufferTarget)) return GL_FRAMEBUFFER_UNDEFINED;
 
         auto& bindingSlot = MG_State::pGLContext->GetFramebufferBindingSlot(framebufferTarget);
-        auto framebufferObject = bindingSlot.GetBoundObject();
+        auto& framebufferObject = bindingSlot.GetBoundObject();
         if (!framebufferObject) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidOperation,
-                MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "CheckFramebufferStatus_State",
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "CheckFramebufferStatus_State",
                                              "Framebuffer target is bound to no framebuffer object."));
             return GL_FRAMEBUFFER_UNDEFINED;
         }
@@ -382,11 +384,11 @@ namespace MobileGL::MG_Impl::GLImpl {
         RenderbufferTarget renderbufferTarget = MG_Util::ConvertGLEnumToRenderbufferTarget(target);
         if (!FramebufferImpl::ValidateRenderbufferTarget(renderbufferTarget)) return;
 
-        auto renderbufferObject = MG_State::pGLContext->GetRenderbufferObject(renderbuffer);
-        if (!renderbufferObject) {
+        Bool doesRenderbufferCreated = MG_State::pGLContext->ValidateRenderbufferObject(renderbuffer);
+        if (!doesRenderbufferCreated) {
             MG_State::pGLContext->CreateRenderbufferObject(renderbuffer);
-            renderbufferObject = MG_State::pGLContext->GetRenderbufferObject(renderbuffer);
         }
+        auto& renderbufferObject = MG_State::pGLContext->GetRenderbufferObject(renderbuffer);
 
         auto& bindingSlot = MG_State::pGLContext->GetRenderbufferBindingSlot(renderbufferTarget);
         bindingSlot.Bind(renderbufferObject);
@@ -403,11 +405,11 @@ namespace MobileGL::MG_Impl::GLImpl {
         FramebufferTarget framebufferTarget = MG_Util::ConvertGLEnumToFramebufferTarget(target);
         if (!FramebufferImpl::ValidateFramebufferTarget(framebufferTarget)) return;
 
-        auto framebufferObject = MG_State::pGLContext->GetFramebufferObject(framebuffer);
-        if (!framebufferObject) {
+        Bool doesFramebufferCreated = MG_State::pGLContext->ValidateFramebufferObject(framebuffer);
+        if (!doesFramebufferCreated) {
             MG_State::pGLContext->CreateFramebufferObject(framebuffer);
-            framebufferObject = MG_State::pGLContext->GetFramebufferObject(framebuffer);
         }
+        auto& framebufferObject = MG_State::pGLContext->GetFramebufferObject(framebuffer);
 
         auto& bindingSlot = MG_State::pGLContext->GetFramebufferBindingSlot(framebufferTarget);
         bindingSlot.Bind(framebufferObject);
@@ -419,11 +421,11 @@ namespace MobileGL::MG_Impl::GLImpl {
         RenderbufferTarget renderbufferTarget = MG_Util::ConvertGLEnumToRenderbufferTarget(target);
         if (!FramebufferImpl::ValidateRenderbufferTarget(renderbufferTarget)) return;
         auto& bindingSlot = MG_State::pGLContext->GetRenderbufferBindingSlot(renderbufferTarget);
-        auto renderbufferObject = bindingSlot.GetBoundObject();
+        auto& renderbufferObject = bindingSlot.GetBoundObject();
         if (!renderbufferObject) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidOperation,
-                MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "GetRenderbufferParameteriv_State",
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "GetRenderbufferParameteriv_State",
                                              "Renderbuffer target is bound to no renderbuffer object."));
             return;
         }
@@ -462,7 +464,7 @@ namespace MobileGL::MG_Impl::GLImpl {
         default:
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidEnum,
-                MakeShared<GenericErrorInfo>(
+                MakeUnique<GenericErrorInfo>(
                     "MG_Impl/GLImpl", "GetRenderbufferParameteriv_State",
                     std::format("pname {} is not an accepted value.", MG_Util::ConvertGLEnumToString(pname))));
             return;
@@ -492,7 +494,7 @@ namespace MobileGL::MG_Impl::GLImpl {
         // Check width/height
         if (width < 0 || height < 0) {
             MG_State::pGLContext->RecordError(ErrorCode::InvalidValue,
-                                              MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ReadPixels_State",
+                                              MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ReadPixels_State",
                                                                            "Width and height must be non-negative"));
             return;
         }
@@ -501,7 +503,7 @@ namespace MobileGL::MG_Impl::GLImpl {
         if (!TextureImpl::ValidateTextureInputFormat(textureInputFormat)) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidEnum,
-                MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ReadPixels_State", "Invalid format"));
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ReadPixels_State", "Invalid format"));
             return;
         }
 
@@ -509,17 +511,17 @@ namespace MobileGL::MG_Impl::GLImpl {
         if (!TextureImpl::ValidateTexturePixelDataType(texturePixelDataType)) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidEnum,
-                MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ReadPixels_State", "Invalid pixel data type"));
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ReadPixels_State", "Invalid pixel data type"));
             return;
         }
 
         // Get bound framebuffer
         auto& bindingSlot = MG_State::pGLContext->GetFramebufferBindingSlot(FramebufferTarget::Read);
-        auto framebufferObject = bindingSlot.GetBoundObject();
+        auto& framebufferObject = bindingSlot.GetBoundObject();
 
         if (!framebufferObject) {
             MG_State::pGLContext->RecordError(ErrorCode::InvalidOperation,
-                                              MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ReadPixels_State",
+                                              MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ReadPixels_State",
                                                                            "No framebuffer bound to read target"));
             return;
         }
@@ -528,7 +530,7 @@ namespace MobileGL::MG_Impl::GLImpl {
         if (!framebufferObject->CheckCompleteness()) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidFramebufferOperation,
-                MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ReadPixels_State", "Framebuffer is incomplete"));
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ReadPixels_State", "Framebuffer is incomplete"));
             return;
         }
 
@@ -537,7 +539,7 @@ namespace MobileGL::MG_Impl::GLImpl {
             if (!framebufferObject->GetAttachment(FramebufferAttachmentType::Stencil).IsValid()) {
                 MG_State::pGLContext->RecordError(
                     ErrorCode::InvalidOperation,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ReadPixels_State",
+                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ReadPixels_State",
                                                  "No stencil buffer for stencil index format"));
                 return;
             }
@@ -545,7 +547,7 @@ namespace MobileGL::MG_Impl::GLImpl {
             if (!framebufferObject->GetAttachment(FramebufferAttachmentType::Depth).IsValid()) {
                 MG_State::pGLContext->RecordError(
                     ErrorCode::InvalidOperation,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ReadPixels_State",
+                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ReadPixels_State",
                                                  "No depth buffer for depth component format"));
                 return;
             }
@@ -554,7 +556,7 @@ namespace MobileGL::MG_Impl::GLImpl {
                 !framebufferObject->GetAttachment(FramebufferAttachmentType::Stencil).IsValid()) {
                 MG_State::pGLContext->RecordError(
                     ErrorCode::InvalidOperation,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ReadPixels_State",
+                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ReadPixels_State",
                                                  "No depth/stencil buffer for depth-stencil format"));
                 return;
             }
@@ -563,7 +565,7 @@ namespace MobileGL::MG_Impl::GLImpl {
             if (texturePixelDataType != TexturePixelDataType::UnsignedInt248 &&
                 texturePixelDataType != TexturePixelDataType::Float32UnsignedInt248Rev) {
                 MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidEnum, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ReadPixels_State",
+                    ErrorCode::InvalidEnum, MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ReadPixels_State",
                                                                          "Invalid type for depth-stencil format"));
                 return;
             }
@@ -577,7 +579,7 @@ namespace MobileGL::MG_Impl::GLImpl {
             // Check if PBO is mapped
             if (pixelPackBufferObject->IsMapped()) {
                 MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidOperation, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ReadPixels_State",
+                    ErrorCode::InvalidOperation, MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ReadPixels_State",
                                                                               "Pixel pack buffer is currently mapped"));
                 return;
             }
@@ -587,7 +589,7 @@ namespace MobileGL::MG_Impl::GLImpl {
             if (reinterpret_cast<uintptr_t>(pixels) % typeSize != 0) {
                 MG_State::pGLContext->RecordError(
                     ErrorCode::InvalidOperation,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ReadPixels_State",
+                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ReadPixels_State",
                                                  "Pixel data not aligned for pixel pack buffer"));
                 return;
             }
@@ -595,11 +597,11 @@ namespace MobileGL::MG_Impl::GLImpl {
 
         // Check multisampling
         if (framebufferObject->GetAttachment(FramebufferAttachmentType::Color0).IsRenderbuffer()) {
-            auto rbo = framebufferObject->GetAttachment(FramebufferAttachmentType::Color0).GetRenderbuffer();
+            auto& rbo = framebufferObject->GetAttachment(FramebufferAttachmentType::Color0).GetRenderbuffer();
             if (rbo && rbo->GetSamples() > 1) {
                 MG_State::pGLContext->RecordError(
                     ErrorCode::InvalidOperation,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ReadPixels_State",
+                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ReadPixels_State",
                                                  "ReadPixels not supported for multisampled framebuffers"));
                 return;
             }
@@ -732,6 +734,6 @@ namespace MobileGL::MG_Impl::GLImpl {
     }
 
     namespace FramebufferImpl {
-        DefaultFramebufferInfo* pDefaultFramebufferInfo;
+        UniquePtr<DefaultFramebufferInfo> pDefaultFramebufferInfo;
     } // namespace FramebufferImpl
 } // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/Framebuffer/GL_Framebuffer.h

@@ -11,51 +11,49 @@
 #include <Includes.h>
 #include <MG_State/GLState/Core.h>
 
-namespace MobileGL {
-    namespace MG_Impl::GLImpl {
-        /* @INSERTION_POINT:FUNCTION_DECLARATION@ */
-        void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels);
-        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 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);
-        void GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params);
-        void GenRenderbuffers(GLsizei n, GLuint* renderbuffers);
-        void FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
-        void DeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers);
-        void BindRenderbuffer(GLenum target, GLuint renderbuffer);
-        void SampleMaski(GLuint maskNumber, GLbitfield mask);
-        GLboolean IsFramebuffer(GLuint framebuffer);
-        void GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params);
-        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,
-                                  GLint zoffset);
-        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 DrawBuffer(GLenum buf);
-        void DrawBuffers(GLsizei n, const GLenum* bufs);
-        void ReadBuffer(GLenum src);
-        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 BindFramebuffer(GLenum target, GLuint framebuffer);
+namespace MobileGL::MG_Impl::GLImpl {
+    /* @INSERTION_POINT:FUNCTION_DECLARATION@ */
+    void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels);
+    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 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);
+    void GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params);
+    void GenRenderbuffers(GLsizei n, GLuint* renderbuffers);
+    void FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
+    void DeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers);
+    void BindRenderbuffer(GLenum target, GLuint renderbuffer);
+    void SampleMaski(GLuint maskNumber, GLbitfield mask);
+    GLboolean IsFramebuffer(GLuint framebuffer);
+    void GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params);
+    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,
+                              GLint zoffset);
+    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 DrawBuffer(GLenum buf);
+    void DrawBuffers(GLsizei n, const GLenum* bufs);
+    void ReadBuffer(GLenum src);
+    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 BindFramebuffer(GLenum target, GLuint framebuffer);
 
-        namespace FramebufferImpl {
-            struct DefaultFramebufferInfo {
-                SharedPtr<MG_State::GLState::FramebufferObject> defaultFBO;
-                SharedPtr<MG_State::GLState::ITextureObject> colorAttachment;
-                SharedPtr<MG_State::GLState::ITextureObject> depthAttachment;
-                SharedPtr<MG_State::GLState::ITextureObject> stencilAttachment;
-            };
+    namespace FramebufferImpl {
+        struct DefaultFramebufferInfo {
+            SharedPtr<MG_State::GLState::FramebufferObject> defaultFBO;
+            SharedPtr<MG_State::GLState::ITextureObject> colorAttachment;
+            SharedPtr<MG_State::GLState::ITextureObject> depthAttachment;
+            SharedPtr<MG_State::GLState::ITextureObject> stencilAttachment;
+        };
 
-            extern DefaultFramebufferInfo* pDefaultFramebufferInfo;
-        } // namespace FramebufferImpl
-    } // namespace MG_Impl::GLImpl
-} // namespace MobileGL
+        extern UniquePtr<DefaultFramebufferInfo> pDefaultFramebufferInfo;
+    } // namespace FramebufferImpl
+} // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/Framebuffer/Validators.cpp

@@ -13,85 +13,82 @@
 #include <MG_Util/Converters/MGToGL/FramebufferEnumConverter.h>
 #include <MG_Util/Converters/MGToStr/FramebufferEnumConverter.h>
 
-namespace MobileGL::MG_Impl::GLImpl {
-    namespace FramebufferImpl {
-        Bool ValidateFramebufferTarget(FramebufferTarget target) {
-            if (target == FramebufferTarget::Unknown) {
-                using namespace MG_Util;
-                String bufferTargetStr = ConvertFramebufferTargetToString(target);
-                String glTargetStr = ConvertGLEnumToString(ConvertFramebufferTargetToGLEnum(target));
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidEnum,
-                    MakeShared<GenericErrorInfo>(
-                        "MG_Impl/GLImpl/FramebufferImpl", "ValidateFramebufferTarget",
-                        std::format("Target {} ({}) is not valid.", bufferTargetStr, glTargetStr)));
-                return false;
-            }
-            return true;
-        }
-
-        Bool ValidateFramebufferName(Uint index, Bool allowZero) {
-            if (index == 0 && !allowZero) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl/FramebufferImpl", "ValidateFramebufferName",
-                                                 "Framebuffer name 0 is not valid in this situation."));
-                return false;
-            }
-            Bool isValid = MG_State::pGLContext->ValidateFramebufferName(index);
-            if (isValid) return true;
+namespace MobileGL::MG_Impl::GLImpl::FramebufferImpl {
+    Bool ValidateFramebufferTarget(FramebufferTarget target) {
+        if (target == FramebufferTarget::Unknown) {
+            using namespace MG_Util;
+            String bufferTargetStr = ConvertFramebufferTargetToString(target);
+            String glTargetStr = ConvertGLEnumToString(ConvertFramebufferTargetToGLEnum(target));
             MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeShared<GenericErrorInfo>("MG_Impl/GLImpl/FramebufferImpl", "ValidateFramebufferName",
-                                             std::format("Framebuffer name {} is not valid.", index)));
+                ErrorCode::InvalidEnum, MakeUnique<GenericErrorInfo>(
+                                            "MG_Impl/GLImpl/FramebufferImpl", "ValidateFramebufferTarget",
+                                            std::format("Target {} ({}) is not valid.", bufferTargetStr, glTargetStr)));
             return false;
         }
+        return true;
+    }
 
-        Bool ValidateFramebufferAttachmentType(FramebufferAttachmentType attachment) {
-            if (attachment == FramebufferAttachmentType::Unknown) {
-                using namespace MG_Util;
-                String attachmentStr = ConvertFramebufferAttachmentTypeToString(attachment);
-                String glAttachmentStr = ConvertGLEnumToString(ConvertFramebufferAttachmentTypeToGLEnum(attachment));
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidEnum,
-                    MakeShared<GenericErrorInfo>(
-                        "MG_Impl/GLImpl/FramebufferImpl", "ValidateFramebufferAttachmentType",
-                        std::format("Attachment type {} ({}) is not valid.", attachmentStr, glAttachmentStr)));
-                return false;
-            }
-            return true;
-        }
-
-        Bool ValidateRenderbufferTarget(RenderbufferTarget target) {
-            if (target == RenderbufferTarget::Unknown) {
-                using namespace MG_Util;
-                String renderbufferTargetStr = ConvertRenderbufferTargetToString(target);
-                String glTargetStr = ConvertGLEnumToString(ConvertRenderbufferTargetToGLEnum(target));
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidEnum,
-                    MakeShared<GenericErrorInfo>(
-                        "MG_Impl/GLImpl/FramebufferImpl", "ValidateRenderbufferTarget",
-                        std::format("Target {} ({}) is not valid.", renderbufferTargetStr, glTargetStr)));
-                return false;
-            }
-            return true;
-        }
-
-        Bool ValidateRenderbufferName(Uint index, Bool allowZero) {
-            if (index == 0 && !allowZero) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl/FramebufferImpl", "ValidateRenderbufferName",
-                                                 "Renderbuffer name 0 is not valid in this situation."));
-                return false;
-            }
-            Bool isValid = MG_State::pGLContext->ValidateRenderbufferName(index);
-            if (isValid) return true;
+    Bool ValidateFramebufferName(Uint index, Bool allowZero) {
+        if (index == 0 && !allowZero) {
             MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeShared<GenericErrorInfo>("MG_Impl/GLImpl/FramebufferImpl", "ValidateRenderbufferName",
-                                             std::format("Renderbuffer name {} is not valid.", index)));
+                ErrorCode::InvalidValue,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl/FramebufferImpl", "ValidateFramebufferName",
+                                             "Framebuffer name 0 is not valid in this situation."));
             return false;
         }
-    } // namespace FramebufferImpl
-} // namespace MobileGL::MG_Impl::GLImpl
+        Bool isValid = MG_State::pGLContext->ValidateFramebufferName(index);
+        if (isValid) return true;
+        MG_State::pGLContext->RecordError(
+            ErrorCode::InvalidOperation,
+            MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl/FramebufferImpl", "ValidateFramebufferName",
+                                         std::format("Framebuffer name {} is not valid.", index)));
+        return false;
+    }
+
+    Bool ValidateFramebufferAttachmentType(FramebufferAttachmentType attachment) {
+        if (attachment == FramebufferAttachmentType::Unknown) {
+            using namespace MG_Util;
+            String attachmentStr = ConvertFramebufferAttachmentTypeToString(attachment);
+            String glAttachmentStr = ConvertGLEnumToString(ConvertFramebufferAttachmentTypeToGLEnum(attachment));
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidEnum,
+                MakeUnique<GenericErrorInfo>(
+                    "MG_Impl/GLImpl/FramebufferImpl", "ValidateFramebufferAttachmentType",
+                    std::format("Attachment type {} ({}) is not valid.", attachmentStr, glAttachmentStr)));
+            return false;
+        }
+        return true;
+    }
+
+    Bool ValidateRenderbufferTarget(RenderbufferTarget target) {
+        if (target == RenderbufferTarget::Unknown) {
+            using namespace MG_Util;
+            String renderbufferTargetStr = ConvertRenderbufferTargetToString(target);
+            String glTargetStr = ConvertGLEnumToString(ConvertRenderbufferTargetToGLEnum(target));
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidEnum,
+                MakeUnique<GenericErrorInfo>(
+                    "MG_Impl/GLImpl/FramebufferImpl", "ValidateRenderbufferTarget",
+                    std::format("Target {} ({}) is not valid.", renderbufferTargetStr, glTargetStr)));
+            return false;
+        }
+        return true;
+    }
+
+    Bool ValidateRenderbufferName(Uint index, Bool allowZero) {
+        if (index == 0 && !allowZero) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidValue,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl/FramebufferImpl", "ValidateRenderbufferName",
+                                             "Renderbuffer name 0 is not valid in this situation."));
+            return false;
+        }
+        Bool isValid = MG_State::pGLContext->ValidateRenderbufferName(index);
+        if (isValid) return true;
+        MG_State::pGLContext->RecordError(
+            ErrorCode::InvalidOperation,
+            MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl/FramebufferImpl", "ValidateRenderbufferName",
+                                         std::format("Renderbuffer name {} is not valid.", index)));
+        return false;
+    }
+} // namespace MobileGL::MG_Impl::GLImpl::FramebufferImpl

MobileGL/MG_Impl/GLImpl/Framebuffer/Validators.h

@@ -10,12 +10,10 @@
 #include <Includes.h>
 #include <MG_State/GLState/FramebufferState/FramebufferObject.h>
 
-namespace MobileGL::MG_Impl::GLImpl {
-    namespace FramebufferImpl {
-        Bool ValidateFramebufferTarget(FramebufferTarget target);
-        Bool ValidateFramebufferName(Uint index, Bool allowZero = true);
-        Bool ValidateFramebufferAttachmentType(FramebufferAttachmentType attachment);
-        Bool ValidateRenderbufferTarget(RenderbufferTarget target);
-        Bool ValidateRenderbufferName(Uint index, Bool allowZero = true);
-    } // namespace FramebufferImpl
-} // namespace MobileGL::MG_Impl::GLImpl
+namespace MobileGL::MG_Impl::GLImpl::FramebufferImpl {
+    Bool ValidateFramebufferTarget(FramebufferTarget target);
+    Bool ValidateFramebufferName(Uint index, Bool allowZero = true);
+    Bool ValidateFramebufferAttachmentType(FramebufferAttachmentType attachment);
+    Bool ValidateRenderbufferTarget(RenderbufferTarget target);
+    Bool ValidateRenderbufferName(Uint index, Bool allowZero = true);
+} // namespace MobileGL::MG_Impl::GLImpl::FramebufferImpl

MobileGL/MG_Impl/GLImpl/Getter/GL_Getter.cpp

@@ -7,8 +7,6 @@
 // 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>
@@ -127,7 +125,7 @@ namespace MobileGL::MG_Impl::GLImpl {
         if (!params) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidValue,
-                MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "GetIntegerv", "params pointer cannot be null"));
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "GetIntegerv", "params pointer cannot be null"));
             return;
         }
 
@@ -146,9 +144,9 @@ namespace MobileGL::MG_Impl::GLImpl {
             *params = 0; // TODO
             break;
         case GL_ARRAY_BUFFER_BINDING: {
-            auto obj = MG_State::pGLContext->GetBufferBindingSlot(BufferTarget::Vertex).GetBoundObject();
+            auto& obj = MG_State::pGLContext->GetBufferBindingSlot(BufferTarget::Vertex).GetBoundObject();
             if (obj)
-                *params = obj->GetExternalIndex();
+                *params = (GLint)obj->GetExternalIndex();
             else
                 *params = 0;
             break;
@@ -256,14 +254,14 @@ namespace MobileGL::MG_Impl::GLImpl {
             break;
         case GL_CURRENT_PROGRAM: {
             const auto& currentProgram = MG_State::pGLContext->GetCurrentProgram();
-            *params = currentProgram ? currentProgram->GetExternalIndex() : 0;
+            *params = currentProgram ? (GLint)currentProgram->GetExternalIndex() : 0;
             break;
         }
         case GL_DEPTH_CLEAR_VALUE:
-            *params = MG_State::pGLContext->GetClearDepth();
+            *params = (GLint)MG_State::pGLContext->GetClearDepth();
             break;
         case GL_DEPTH_FUNC:
-            *params = MG_Util::ConvertDepthTestFuncToGLEnum(MG_State::pGLContext->GetDepthFunc());
+            *params = (GLint)MG_Util::ConvertDepthTestFuncToGLEnum(MG_State::pGLContext->GetDepthFunc());
             break;
         case GL_DEPTH_RANGE:
             *params = 0; // TODO
@@ -288,12 +286,12 @@ namespace MobileGL::MG_Impl::GLImpl {
             break;
         case GL_DRAW_FRAMEBUFFER_BINDING: {
             const auto& FBO = MG_State::pGLContext->GetFramebufferBindingSlot(FramebufferTarget::Draw).GetBoundObject();
-            *params = FBO ? FBO->GetExternalIndex() : 0;
+            *params = FBO ? (GLint)FBO->GetExternalIndex() : 0;
             break;
         }
         case GL_READ_FRAMEBUFFER_BINDING: {
             const auto& FBO = MG_State::pGLContext->GetFramebufferBindingSlot(FramebufferTarget::Read).GetBoundObject();
-            *params = FBO ? FBO->GetExternalIndex() : 0;
+            *params = FBO ? (GLint)FBO->GetExternalIndex() : 0;
             break;
         }
         case GL_ELEMENT_ARRAY_BUFFER_BINDING: {
@@ -302,7 +300,7 @@ namespace MobileGL::MG_Impl::GLImpl {
                 break;
             }
             const auto& bufferObject = MG_State::pGLContext->GetBufferBindingSlot(BufferTarget::Index).GetBoundObject();
-            *params = bufferObject ? bufferObject->GetExternalIndex() : 0;
+            *params = bufferObject ? (GLint)bufferObject->GetExternalIndex() : 0;
             break;
         }
         case GL_FRAGMENT_SHADER_DERIVATIVE_HINT:
@@ -886,7 +884,7 @@ namespace MobileGL::MG_Impl::GLImpl {
         default:
             MGLOG_E("glGetIntegerv: Invalid enum %s (0x%X)", MG_Util::ConvertGLEnumToString(pname).c_str(), pname);
             MG_State::pGLContext->RecordError(ErrorCode::InvalidEnum,
-                                              MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "GetIntegerv",
+                                              MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "GetIntegerv",
                                                                            std::format("Invalid enum: 0x{:X}", pname)));
 
             break;
@@ -894,7 +892,10 @@ namespace MobileGL::MG_Impl::GLImpl {
     }
 
     GLenum GetError() {
-        ErrorCode errorCode = MG_State::pGLContext->PopGLError().value_or(Error{ErrorCode::NoError, nullptr}).code;
-        return MG_Util::ConvertErrorCodeToGLEnum(errorCode);
+        auto error = MG_State::pGLContext->PopGLError();
+        if (!error || !error->get()) {
+            return GL_NO_ERROR;
+        }
+        return MG_Util::ConvertErrorCodeToGLEnum(error->get()->code);
     }
 } // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/Program/GL_Program.h

@@ -9,61 +9,59 @@
 #pragma once
 #include <Includes.h>
 
-namespace MobileGL {
-    namespace MG_Impl::GLImpl {
-        void AttachShader(GLuint program, GLuint shader);
-        void BindAttribLocation(GLuint program, GLuint index, const GLchar* name);
-        void CompileShader(GLuint shader);
-        GLuint CreateProgram(void);
-        GLuint CreateShader(GLenum type);
-        void DeleteProgram(GLuint program);
-        void DeleteShader(GLuint shader);
-        void DetachShader(GLuint program, GLuint shader);
-        void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* type,
-                             GLchar* name);
-        void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* type,
-                              GLchar* name);
-        void GetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei* count, GLuint* shaders);
-        GLint GetAttribLocation(GLuint program, const GLchar* name);
-        void GetProgramiv(GLuint program, GLenum pname, GLint* params);
-        void GetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog);
-        void GetShaderiv(GLuint shader, GLenum pname, GLint* params);
-        void GetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog);
-        void GetShaderSource(GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source);
-        GLint GetUniformLocation(GLuint program, const GLchar* name);
-        void GetUniformfv(GLuint program, GLint location, GLfloat* params);
-        void GetUniformiv(GLuint program, GLint location, GLint* params);
-        GLboolean IsProgram(GLuint program);
-        GLboolean IsShader(GLuint shader);
-        void LinkProgram(GLuint program);
-        void ShaderSource(GLuint shader, GLsizei count, const GLchar* const* string, const GLint* length);
-        void UseProgram(GLuint program);
-        void Uniform1f(GLint location, GLfloat v0);
-        void Uniform2f(GLint location, GLfloat v0, GLfloat v1);
-        void Uniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-        void Uniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-        void Uniform1i(GLint location, GLint v0);
-        void Uniform2i(GLint location, GLint v0, GLint v1);
-        void Uniform3i(GLint location, GLint v0, GLint v1, GLint v2);
-        void Uniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-        void Uniform1fv(GLint location, GLsizei count, const GLfloat* value);
-        void Uniform2fv(GLint location, GLsizei count, const GLfloat* value);
-        void Uniform3fv(GLint location, GLsizei count, const GLfloat* value);
-        void Uniform4fv(GLint location, GLsizei count, const GLfloat* value);
-        void Uniform1iv(GLint location, GLsizei count, const GLint* value);
-        void Uniform2iv(GLint location, GLsizei count, const GLint* value);
-        void Uniform3iv(GLint location, GLsizei count, const GLint* value);
-        void Uniform4iv(GLint location, GLsizei count, const GLint* value);
-        void UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
-        void UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
-        void UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
-        GLuint GetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName);
-        void UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
-        void GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params);
-        void GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length,
-                                       GLchar* uniformBlockName);
-        void BindFragDataLocation(GLuint program, GLuint colorNumber, const char* name);
-        GLint GetFragDataLocation(GLuint program, const char* name);
-        void ValidateProgram(GLuint program);
-    } // namespace MG_Impl::GLImpl
-} // namespace MobileGL
+namespace MobileGL::MG_Impl::GLImpl {
+    void AttachShader(GLuint program, GLuint shader);
+    void BindAttribLocation(GLuint program, GLuint index, const GLchar* name);
+    void CompileShader(GLuint shader);
+    GLuint CreateProgram(void);
+    GLuint CreateShader(GLenum type);
+    void DeleteProgram(GLuint program);
+    void DeleteShader(GLuint shader);
+    void DetachShader(GLuint program, GLuint shader);
+    void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* type,
+                         GLchar* name);
+    void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* type,
+                          GLchar* name);
+    void GetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei* count, GLuint* shaders);
+    GLint GetAttribLocation(GLuint program, const GLchar* name);
+    void GetProgramiv(GLuint program, GLenum pname, GLint* params);
+    void GetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog);
+    void GetShaderiv(GLuint shader, GLenum pname, GLint* params);
+    void GetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog);
+    void GetShaderSource(GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source);
+    GLint GetUniformLocation(GLuint program, const GLchar* name);
+    void GetUniformfv(GLuint program, GLint location, GLfloat* params);
+    void GetUniformiv(GLuint program, GLint location, GLint* params);
+    GLboolean IsProgram(GLuint program);
+    GLboolean IsShader(GLuint shader);
+    void LinkProgram(GLuint program);
+    void ShaderSource(GLuint shader, GLsizei count, const GLchar* const* string, const GLint* length);
+    void UseProgram(GLuint program);
+    void Uniform1f(GLint location, GLfloat v0);
+    void Uniform2f(GLint location, GLfloat v0, GLfloat v1);
+    void Uniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+    void Uniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+    void Uniform1i(GLint location, GLint v0);
+    void Uniform2i(GLint location, GLint v0, GLint v1);
+    void Uniform3i(GLint location, GLint v0, GLint v1, GLint v2);
+    void Uniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
+    void Uniform1fv(GLint location, GLsizei count, const GLfloat* value);
+    void Uniform2fv(GLint location, GLsizei count, const GLfloat* value);
+    void Uniform3fv(GLint location, GLsizei count, const GLfloat* value);
+    void Uniform4fv(GLint location, GLsizei count, const GLfloat* value);
+    void Uniform1iv(GLint location, GLsizei count, const GLint* value);
+    void Uniform2iv(GLint location, GLsizei count, const GLint* value);
+    void Uniform3iv(GLint location, GLsizei count, const GLint* value);
+    void Uniform4iv(GLint location, GLsizei count, const GLint* value);
+    void UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+    void UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+    void UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+    GLuint GetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName);
+    void UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
+    void GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params);
+    void GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length,
+                                   GLchar* uniformBlockName);
+    void BindFragDataLocation(GLuint program, GLuint colorNumber, const char* name);
+    GLint GetFragDataLocation(GLuint program, const char* name);
+    void ValidateProgram(GLuint program);
+} // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/RenderState/GL_RenderState.cpp

@@ -7,474 +7,467 @@
 // End of Source File Header
 
 #include "GL_RenderState.h"
-#include "MG_State/GLState/RenderState/RenderState.h"
-#include "MG_Util/Converters/GLToStr/GLEnumConverter.h"
 #include <MG_State/GLState/Core.h>
+#include <MG_Util/Converters/GLToStr/GLEnumConverter.h>
 #include <MG_Util/Converters/GLToMG/RenderStateEnumConverter.h>
 #include <MG_Util/Converters/MGToGL/RenderStateEnumConverter.h>
 #include <MG_Util/Converters/MGToStr/RenderStateEnumConverter.h>
 
-namespace MobileGL {
-    namespace MG_Impl::GLImpl {
-        void Viewport_State(GLint x, GLint y, GLsizei width, GLsizei height) {
-            if (width < 0 || height < 0) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "Viewport_State",
-                                                                          "Width abd height must be non-negative."));
-                return;
-            }
-
-            MG_State::pGLContext->SetViewport(IntVec4(x, y, width, height));
-        }
-
-        void StencilOpSeparate_State(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) {
-            // TODO: implement
-        }
-
-        void StencilOp_State(GLenum fail, GLenum zfail, GLenum zpass) {
-            // TODO: implement
-        }
-
-        void StencilMaskSeparate_State(GLenum face, GLuint mask) {
-            // TODO: implement
-        }
-
-        void StencilMask_State(GLuint mask) {
-            // TODO: implement
-        }
-
-        void StencilFuncSeparate_State(GLenum face, GLenum func, GLint ref, GLuint mask) {
-            // TODO: implement
-        }
-
-        void StencilFunc_State(GLenum func, GLint ref, GLuint mask) {
-            // TODO: implement
-        }
-
-        void Scissor_State(GLint x, GLint y, GLsizei width, GLsizei height) {
-            if (width < 0 || height < 0) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "Scissor_State",
-                                                                          "Width abd height must be non-negative."));
-                return;
-            }
-
-            MG_State::pGLContext->SetScissorBox(IntVec4(x, y, width, height));
-        }
-
-        void SampleCoverage_State(GLfloat value, GLboolean invert) {
-            // TODO: implement
-        }
-
-        void PolygonOffset_State(GLfloat factor, GLfloat units) {
-            // TODO: implement
-        }
-
-        void PolygonMode_State(GLenum face, GLenum mode) {
-            // TODO: implement
-        }
-
-        void PointSize_State(GLfloat size) {
-            // TODO: implement
-        }
-
-        void PointParameterf_State(GLenum pname, GLfloat param) {
-            // TODO: implement
-        }
-
-        void PointParameteri_State(GLenum pname, GLint param) {
-            // TODO: implement
-        }
-
-        void PixelStorei_State(GLenum pname, GLint param) {
-            MGLOG_D("%s: %s = %d", __func__, MG_Util::ConvertGLEnumToString(pname).c_str(), param);
-            PixelStoreParam pixelStoreParam = MG_Util::ConvertGLEnumToPixelStoreParam(pname);
-            if (pixelStoreParam == PixelStoreParam::Unknown) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidEnum,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "PixelStorei_State",
-                                                 "Pixel store param enum " +
-                                                     MG_Util::ConvertPixelStoreParamToString(pixelStoreParam) + "(" +
-                                                     MG_Util::ConvertGLEnumToString(pname) + ") is not supported."));
-                return;
-            }
-
-            MG_State::pGLContext->SetPixelStoreParam(pixelStoreParam, param);
-        }
-
-        void LogicOp_State(GLenum opcode) {
-            // TODO: implement
-        }
-
-        void LineWidth_State(GLfloat width) {
-            // TODO: implement
-        }
-
-        GLboolean IsEnabledi_State(GLenum target, GLuint index) {
-            CapabilityInput capInput = MG_Util::ConvertGLEnumToCapabilityInput(target);
-            if (capInput == CapabilityInput::Unknown) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidEnum,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "IsEnabledi_State",
-                                                 "Capability enum " +
-                                                     MG_Util::ConvertCapabilityInputToString(capInput) + "(" +
-                                                     MG_Util::ConvertGLEnumToString(target) + ") is not supported."));
-                return GL_FALSE;
-            }
-
-            return MG_State::pGLContext->IsCapabilityEnabledIndexed(capInput, index) ? GL_TRUE : GL_FALSE;
-        }
-
-        GLboolean IsEnabled_State(GLenum cap) {
-            CapabilityInput capInput = MG_Util::ConvertGLEnumToCapabilityInput(cap);
-            if (capInput == CapabilityInput::Unknown) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidEnum, MakeShared<GenericErrorInfo>(
-                                                "MG_Impl/GLImpl", "IsEnabled_State",
-                                                "Capability enum " + MG_Util::ConvertCapabilityInputToString(capInput) +
-                                                    "(" + MG_Util::ConvertGLEnumToString(cap) + ") is not supported."));
-                return GL_FALSE;
-            }
-
-            return MG_State::pGLContext->IsCapabilityEnabled(capInput) ? GL_TRUE : GL_FALSE;
-        }
-
-        void Hint_State(GLenum target, GLenum mode) {
-            // TODO: implement
-        }
-
-        void FrontFace_State(GLenum mode) {
-            // TODO: implement
-        }
-
-        void Enable_State(GLenum cap) {
-            CapabilityInput capInput = MG_Util::ConvertGLEnumToCapabilityInput(cap);
-            if (capInput == CapabilityInput::Unknown) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidEnum, MakeShared<GenericErrorInfo>(
-                                                "MG_Impl/GLImpl", "Enable_State",
-                                                "Capability enum " + MG_Util::ConvertCapabilityInputToString(capInput) +
-                                                    "(" + MG_Util::ConvertGLEnumToString(cap) + ") is not supported."));
-                return;
-            }
-
-            MG_State::pGLContext->SetCapability(capInput, true);
-        }
-
-        void Disable_State(GLenum cap) {
-            CapabilityInput capInput = MG_Util::ConvertGLEnumToCapabilityInput(cap);
-            if (capInput == CapabilityInput::Unknown) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidEnum, MakeShared<GenericErrorInfo>(
-                                                "MG_Impl/GLImpl", "Disable_State",
-                                                "Capability enum " + MG_Util::ConvertCapabilityInputToString(capInput) +
-                                                    "(" + MG_Util::ConvertGLEnumToString(cap) + ") is not supported."));
-                return;
-            }
-
-            MG_State::pGLContext->SetCapability(capInput, false);
-        }
-
-        void DepthRange_State(GLclampd near_val, GLclampd far_val) {
-            // TODO: implement
-        }
-
-        void DepthMask_State(GLboolean flag) {
-            MG_State::pGLContext->SetDepthMask(flag == GL_TRUE);
-        }
-
-        void DepthFunc_State(GLenum func) {
-            DepthTestFunc depthFunc = MG_Util::ConvertGLEnumToDepthTestFunc(func);
-            if (depthFunc == DepthTestFunc::Unknown) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidEnum,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "DepthFunc_State",
-                                                 "Depth function enum " +
-                                                     MG_Util::ConvertDepthTestFuncToString(depthFunc) + "(" +
-                                                     MG_Util::ConvertGLEnumToString(func) + ") is not supported."));
-                return;
-            }
-
-            MG_State::pGLContext->SetDepthFunc(depthFunc);
-        }
-
-        void CullFace_State(GLenum mode) {
-            CullFaceMode cullFaceMode = MG_Util::ConvertGLEnumToCullFaceMode(mode);
-            if (cullFaceMode == CullFaceMode::Unknown) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidEnum,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "CullFace_State",
-                                                 "Cull face mode enum " +
-                                                     MG_Util::ConvertCullFaceModeToString(cullFaceMode) + "(" +
-                                                     MG_Util::ConvertGLEnumToString(mode) + ") is not supported."));
-                return;
-            }
-
-            MG_State::pGLContext->SetCullFaceMode(cullFaceMode);
-        }
-
-        void ColorMask_State(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {
-            MG_State::pGLContext->SetColorMask(
-                BoolVec4(red == GL_TRUE, green == GL_TRUE, blue == GL_TRUE, alpha == GL_TRUE));
-        }
-
-        void ClampColor_State(GLenum target, GLenum clamp) {
-            // TODO: implement
-        }
-
-        void BlendFuncSeparate_State(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) {
-            BlendFactor srcRGB = MG_Util::ConvertGLEnumToBlendFactor(sfactorRGB);
-            BlendFactor dstRGB = MG_Util::ConvertGLEnumToBlendFactor(dfactorRGB);
-            BlendFactor srcAlpha = MG_Util::ConvertGLEnumToBlendFactor(sfactorAlpha);
-            BlendFactor dstAlpha = MG_Util::ConvertGLEnumToBlendFactor(dfactorAlpha);
-
-            if (srcRGB == BlendFactor::Unknown || dstRGB == BlendFactor::Unknown || srcAlpha == BlendFactor::Unknown ||
-                dstAlpha == BlendFactor::Unknown) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidEnum,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "BlendFuncSeparate_State",
-                                                 "One of the blend factor enums is not supported: srcRGB " +
-                                                     MG_Util::ConvertBlendFactorToString(srcRGB) + "(" +
-                                                     MG_Util::ConvertGLEnumToString(sfactorRGB) + "), dstRGB " +
-                                                     MG_Util::ConvertBlendFactorToString(dstRGB) + "(" +
-                                                     MG_Util::ConvertGLEnumToString(dfactorRGB) + "), srcAlpha " +
-                                                     MG_Util::ConvertBlendFactorToString(srcAlpha) + "(" +
-                                                     MG_Util::ConvertGLEnumToString(sfactorAlpha) + "), dstAlpha " +
-                                                     MG_Util::ConvertBlendFactorToString(dstAlpha) + "(" +
-                                                     MG_Util::ConvertGLEnumToString(dfactorAlpha) + ")."));
-                return;
-            }
-
-            MG_State::pGLContext->SetBlendFunc(srcRGB, dstRGB, srcAlpha, dstAlpha);
-        }
-
-        void BlendFunc_State(GLenum sfactor, GLenum dfactor) {
-            BlendFuncSeparate_State(sfactor, dfactor, sfactor, dfactor);
-        }
-
-        void BlendEquation_State(GLenum mode) {
-            // TODO: implement
-        }
-
-        void BlendColor_State(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
-            // TODO: implement
-        }
-
-        void ClearStencil_State(GLint s) {
-            MG_State::pGLContext->SetClearStencil(static_cast<Int>(s));
-        }
-
-        void ClearDepth_State(GLclampd depth) {
-            MG_State::pGLContext->SetClearDepth(static_cast<Float>(depth));
-        }
+namespace MobileGL::MG_Impl::GLImpl {
+    void Viewport_State(GLint x, GLint y, GLsizei width, GLsizei height) {
+        if (width < 0 || height < 0) {
+            MG_State::pGLContext->RecordError(ErrorCode::InvalidValue,
+                                              MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "Viewport_State",
+                                                                           "Width abd height must be non-negative."));
+            return;
+        }
+
+        MG_State::pGLContext->SetViewport(IntVec4(x, y, width, height));
+    }
+
+    void StencilOpSeparate_State(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) {
+        // TODO: implement
+    }
+
+    void StencilOp_State(GLenum fail, GLenum zfail, GLenum zpass) {
+        // TODO: implement
+    }
+
+    void StencilMaskSeparate_State(GLenum face, GLuint mask) {
+        // TODO: implement
+    }
+
+    void StencilMask_State(GLuint mask) {
+        // TODO: implement
+    }
+
+    void StencilFuncSeparate_State(GLenum face, GLenum func, GLint ref, GLuint mask) {
+        // TODO: implement
+    }
+
+    void StencilFunc_State(GLenum func, GLint ref, GLuint mask) {
+        // TODO: implement
+    }
+
+    void Scissor_State(GLint x, GLint y, GLsizei width, GLsizei height) {
+        if (width < 0 || height < 0) {
+            MG_State::pGLContext->RecordError(ErrorCode::InvalidValue,
+                                              MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "Scissor_State",
+                                                                           "Width abd height must be non-negative."));
+            return;
+        }
+
+        MG_State::pGLContext->SetScissorBox(IntVec4(x, y, width, height));
+    }
+
+    void SampleCoverage_State(GLfloat value, GLboolean invert) {
+        // TODO: implement
+    }
+
+    void PolygonOffset_State(GLfloat factor, GLfloat units) {
+        // TODO: implement
+    }
+
+    void PolygonMode_State(GLenum face, GLenum mode) {
+        // TODO: implement
+    }
+
+    void PointSize_State(GLfloat size) {
+        // TODO: implement
+    }
+
+    void PointParameterf_State(GLenum pname, GLfloat param) {
+        // TODO: implement
+    }
+
+    void PointParameteri_State(GLenum pname, GLint param) {
+        // TODO: implement
+    }
+
+    void PixelStorei_State(GLenum pname, GLint param) {
+        MGLOG_D("%s: %s = %d", __func__, MG_Util::ConvertGLEnumToString(pname).c_str(), param);
+        PixelStoreParam pixelStoreParam = MG_Util::ConvertGLEnumToPixelStoreParam(pname);
+        if (pixelStoreParam == PixelStoreParam::Unknown) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidEnum,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "PixelStorei_State",
+                                             "Pixel store param enum " +
+                                                 MG_Util::ConvertPixelStoreParamToString(pixelStoreParam) + "(" +
+                                                 MG_Util::ConvertGLEnumToString(pname) + ") is not supported."));
+            return;
+        }
+
+        MG_State::pGLContext->SetPixelStoreParam(pixelStoreParam, param);
+    }
+
+    void LogicOp_State(GLenum opcode) {
+        // TODO: implement
+    }
+
+    void LineWidth_State(GLfloat width) {
+        // TODO: implement
+    }
+
+    GLboolean IsEnabledi_State(GLenum target, GLuint index) {
+        CapabilityInput capInput = MG_Util::ConvertGLEnumToCapabilityInput(target);
+        if (capInput == CapabilityInput::Unknown) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidEnum,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "IsEnabledi_State",
+                                             "Capability enum " + MG_Util::ConvertCapabilityInputToString(capInput) +
+                                                 "(" + MG_Util::ConvertGLEnumToString(target) + ") is not supported."));
+            return GL_FALSE;
+        }
+
+        return MG_State::pGLContext->IsCapabilityEnabledIndexed(capInput, index) ? GL_TRUE : GL_FALSE;
+    }
+
+    GLboolean IsEnabled_State(GLenum cap) {
+        CapabilityInput capInput = MG_Util::ConvertGLEnumToCapabilityInput(cap);
+        if (capInput == CapabilityInput::Unknown) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidEnum,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "IsEnabled_State",
+                                             "Capability enum " + MG_Util::ConvertCapabilityInputToString(capInput) +
+                                                 "(" + MG_Util::ConvertGLEnumToString(cap) + ") is not supported."));
+            return GL_FALSE;
+        }
+
+        return MG_State::pGLContext->IsCapabilityEnabled(capInput) ? GL_TRUE : GL_FALSE;
+    }
+
+    void Hint_State(GLenum target, GLenum mode) {
+        // TODO: implement
+    }
+
+    void FrontFace_State(GLenum mode) {
+        // TODO: implement
+    }
+
+    void Enable_State(GLenum cap) {
+        CapabilityInput capInput = MG_Util::ConvertGLEnumToCapabilityInput(cap);
+        if (capInput == CapabilityInput::Unknown) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidEnum,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "Enable_State",
+                                             "Capability enum " + MG_Util::ConvertCapabilityInputToString(capInput) +
+                                                 "(" + MG_Util::ConvertGLEnumToString(cap) + ") is not supported."));
+            return;
+        }
+
+        MG_State::pGLContext->SetCapability(capInput, true);
+    }
+
+    void Disable_State(GLenum cap) {
+        CapabilityInput capInput = MG_Util::ConvertGLEnumToCapabilityInput(cap);
+        if (capInput == CapabilityInput::Unknown) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidEnum,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "Disable_State",
+                                             "Capability enum " + MG_Util::ConvertCapabilityInputToString(capInput) +
+                                                 "(" + MG_Util::ConvertGLEnumToString(cap) + ") is not supported."));
+            return;
+        }
+
+        MG_State::pGLContext->SetCapability(capInput, false);
+    }
+
+    void DepthRange_State(GLclampd near_val, GLclampd far_val) {
+        // TODO: implement
+    }
+
+    void DepthMask_State(GLboolean flag) {
+        MG_State::pGLContext->SetDepthMask(flag == GL_TRUE);
+    }
+
+    void DepthFunc_State(GLenum func) {
+        DepthTestFunc depthFunc = MG_Util::ConvertGLEnumToDepthTestFunc(func);
+        if (depthFunc == DepthTestFunc::Unknown) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidEnum,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "DepthFunc_State",
+                                             "Depth function enum " + MG_Util::ConvertDepthTestFuncToString(depthFunc) +
+                                                 "(" + MG_Util::ConvertGLEnumToString(func) + ") is not supported."));
+            return;
+        }
+
+        MG_State::pGLContext->SetDepthFunc(depthFunc);
+    }
+
+    void CullFace_State(GLenum mode) {
+        CullFaceMode cullFaceMode = MG_Util::ConvertGLEnumToCullFaceMode(mode);
+        if (cullFaceMode == CullFaceMode::Unknown) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidEnum,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "CullFace_State",
+                                             "Cull face mode enum " +
+                                                 MG_Util::ConvertCullFaceModeToString(cullFaceMode) + "(" +
+                                                 MG_Util::ConvertGLEnumToString(mode) + ") is not supported."));
+            return;
+        }
+
+        MG_State::pGLContext->SetCullFaceMode(cullFaceMode);
+    }
+
+    void ColorMask_State(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {
+        MG_State::pGLContext->SetColorMask(
+            BoolVec4(red == GL_TRUE, green == GL_TRUE, blue == GL_TRUE, alpha == GL_TRUE));
+    }
+
+    void ClampColor_State(GLenum target, GLenum clamp) {
+        // TODO: implement
+    }
+
+    void BlendFuncSeparate_State(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) {
+        BlendFactor srcRGB = MG_Util::ConvertGLEnumToBlendFactor(sfactorRGB);
+        BlendFactor dstRGB = MG_Util::ConvertGLEnumToBlendFactor(dfactorRGB);
+        BlendFactor srcAlpha = MG_Util::ConvertGLEnumToBlendFactor(sfactorAlpha);
+        BlendFactor dstAlpha = MG_Util::ConvertGLEnumToBlendFactor(dfactorAlpha);
+
+        if (srcRGB == BlendFactor::Unknown || dstRGB == BlendFactor::Unknown || srcAlpha == BlendFactor::Unknown ||
+            dstAlpha == BlendFactor::Unknown) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidEnum,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "BlendFuncSeparate_State",
+                                             "One of the blend factor enums is not supported: srcRGB " +
+                                                 MG_Util::ConvertBlendFactorToString(srcRGB) + "(" +
+                                                 MG_Util::ConvertGLEnumToString(sfactorRGB) + "), dstRGB " +
+                                                 MG_Util::ConvertBlendFactorToString(dstRGB) + "(" +
+                                                 MG_Util::ConvertGLEnumToString(dfactorRGB) + "), srcAlpha " +
+                                                 MG_Util::ConvertBlendFactorToString(srcAlpha) + "(" +
+                                                 MG_Util::ConvertGLEnumToString(sfactorAlpha) + "), dstAlpha " +
+                                                 MG_Util::ConvertBlendFactorToString(dstAlpha) + "(" +
+                                                 MG_Util::ConvertGLEnumToString(dfactorAlpha) + ")."));
+            return;
+        }
+
+        MG_State::pGLContext->SetBlendFunc(srcRGB, dstRGB, srcAlpha, dstAlpha);
+    }
+
+    void BlendFunc_State(GLenum sfactor, GLenum dfactor) {
+        BlendFuncSeparate_State(sfactor, dfactor, sfactor, dfactor);
+    }
+
+    void BlendEquation_State(GLenum mode) {
+        // TODO: implement
+    }
+
+    void BlendColor_State(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
+        // TODO: implement
+    }
+
+    void ClearStencil_State(GLint s) {
+        MG_State::pGLContext->SetClearStencil(static_cast<Int>(s));
+    }
+
+    void ClearDepth_State(GLclampd depth) {
+        MG_State::pGLContext->SetClearDepth(static_cast<Float>(depth));
+    }
+
+    void ClearColor_State(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
+        MG_State::pGLContext->SetClearColor(FloatVec4(red, green, blue, alpha));
+    }
+
+    void BlendFuncSeparatei_State(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) {
+        if (buf >= MG_State::GLState::FramebufferObject::MAX_DRAW_BUFFERS) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidValue,
+                MakeUnique<GenericErrorInfo>(
+                    "MG_Impl/GLImpl", "BlendFuncSeparatei_State",
+                    "Buffer index " + std::to_string(buf) + " is out of range. Max supported is " +
+                        std::to_string(MG_State::GLState::FramebufferObject::MAX_DRAW_BUFFERS - 1) + "."));
+            return;
+        }
+
+        BlendFactor srcRGBM = MG_Util::ConvertGLEnumToBlendFactor(srcRGB);
+        BlendFactor dstRGBM = MG_Util::ConvertGLEnumToBlendFactor(dstRGB);
+        BlendFactor srcAlphaM = MG_Util::ConvertGLEnumToBlendFactor(srcAlpha);
+        BlendFactor dstAlphaM = MG_Util::ConvertGLEnumToBlendFactor(dstAlpha);
+        MG_State::pGLContext->SetBlendFuncIndexed(buf, srcRGBM, dstRGBM, srcAlphaM, dstAlphaM);
+    }
+
+    void Disablei_State(GLenum target, GLuint index) {
+        auto capInput = MG_Util::ConvertGLEnumToCapabilityInput(target);
+        if (capInput == CapabilityInput::Unknown) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidEnum,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "Disablei_State",
+                                             "Capability enum " + MG_Util::ConvertCapabilityInputToString(capInput) +
+                                                 "(" + MG_Util::ConvertGLEnumToString(target) + ") is not supported."));
+            return;
+        }
+
+        MG_State::pGLContext->SetCapabilityIndexed(capInput, index, false);
+    }
+
+    void Enablei_State(GLenum target, GLuint index) {
+        auto capInput = MG_Util::ConvertGLEnumToCapabilityInput(target);
+        if (capInput == CapabilityInput::Unknown) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidEnum,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "Enablei_State",
+                                             "Capability enum " + MG_Util::ConvertCapabilityInputToString(capInput) +
+                                                 "(" + MG_Util::ConvertGLEnumToString(target) + ") is not supported."));
+            return;
+        }
+
+        MG_State::pGLContext->SetCapabilityIndexed(capInput, index, true);
+    }
+
+    /* @INSERTION_POINT:FUNCTION_IMPLEMENTATION@ */
+    void BlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) {
+        BlendFuncSeparatei_State(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
+    }
+
+    void Disablei(GLenum target, GLuint index) {
+        Disablei_State(target, index);
+    }
+
+    void Enablei(GLenum target, GLuint index) {
+        Enablei_State(target, index);
+    }
+
+    void BlendFunc(GLenum sfactor, GLenum dfactor) {
+        BlendFunc_State(sfactor, dfactor);
+    }
+
+    void Viewport(GLint x, GLint y, GLsizei width, GLsizei height) {
+        Viewport_State(x, y, width, height);
+    }
+
+    void StencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) {
+        StencilOpSeparate_State(face, sfail, dpfail, dppass);
+    }
+
+    void StencilOp(GLenum fail, GLenum zfail, GLenum zpass) {
+        StencilOp_State(fail, zfail, zpass);
+    }
+
+    void StencilMaskSeparate(GLenum face, GLuint mask) {
+        StencilMaskSeparate_State(face, mask);
+    }
+
+    void StencilMask(GLuint mask) {
+        StencilMask_State(mask);
+    }
+
+    void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) {
+        StencilFuncSeparate_State(face, func, ref, mask);
+    }
+
+    void StencilFunc(GLenum func, GLint ref, GLuint mask) {
+        StencilFunc_State(func, ref, mask);
+    }
+
+    void Scissor(GLint x, GLint y, GLsizei width, GLsizei height) {
+        Scissor_State(x, y, width, height);
+    }
+
+    void SampleCoverage(GLfloat value, GLboolean invert) {
+        SampleCoverage_State(value, invert);
+    }
+
+    void PolygonOffset(GLfloat factor, GLfloat units) {
+        PolygonOffset_State(factor, units);
+    }
+
+    void PolygonMode(GLenum face, GLenum mode) {
+        PolygonMode_State(face, mode);
+    }
+
+    void PointSize(GLfloat size) {
+        PointSize_State(size);
+    }
+
+    void PointParameterf(GLenum pname, GLfloat param) {
+        PointParameterf_State(pname, param);
+    }
+
+    void PointParameteri(GLenum pname, GLint param) {
+        PointParameteri_State(pname, param);
+    }
+
+    void PixelStorei(GLenum pname, GLint param) {
+        PixelStorei_State(pname, param);
+    }
+
+    void LogicOp(GLenum opcode) {
+        LogicOp_State(opcode);
+    }
 
-        void ClearColor_State(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
-            MG_State::pGLContext->SetClearColor(FloatVec4(red, green, blue, alpha));
-        }
-
-        void BlendFuncSeparatei_State(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) {
-            if (buf >= MG_State::GLState::FramebufferObject::MAX_DRAW_BUFFERS) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue,
-                    MakeShared<GenericErrorInfo>(
-                        "MG_Impl/GLImpl", "BlendFuncSeparatei_State",
-                        "Buffer index " + std::to_string(buf) + " is out of range. Max supported is " +
-                            std::to_string(MG_State::GLState::FramebufferObject::MAX_DRAW_BUFFERS - 1) + "."));
-                return;
-            }
-
-            BlendFactor srcRGBM = MG_Util::ConvertGLEnumToBlendFactor(srcRGB);
-            BlendFactor dstRGBM = MG_Util::ConvertGLEnumToBlendFactor(dstRGB);
-            BlendFactor srcAlphaM = MG_Util::ConvertGLEnumToBlendFactor(srcAlpha);
-            BlendFactor dstAlphaM = MG_Util::ConvertGLEnumToBlendFactor(dstAlpha);
-            MG_State::pGLContext->SetBlendFuncIndexed(buf, srcRGBM, dstRGBM, srcAlphaM, dstAlphaM);
-        }
-
-        void Disablei_State(GLenum target, GLuint index) {
-            auto capInput = MG_Util::ConvertGLEnumToCapabilityInput(target);
-            if (capInput == CapabilityInput::Unknown) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidEnum,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "Disablei_State",
-                                                 "Capability enum " +
-                                                     MG_Util::ConvertCapabilityInputToString(capInput) + "(" +
-                                                     MG_Util::ConvertGLEnumToString(target) + ") is not supported."));
-                return;
-            }
-
-            MG_State::pGLContext->SetCapabilityIndexed(capInput, index, false);
-        }
-
-        void Enablei_State(GLenum target, GLuint index) {
-            auto capInput = MG_Util::ConvertGLEnumToCapabilityInput(target);
-            if (capInput == CapabilityInput::Unknown) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidEnum,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "Enablei_State",
-                                                 "Capability enum " +
-                                                     MG_Util::ConvertCapabilityInputToString(capInput) + "(" +
-                                                     MG_Util::ConvertGLEnumToString(target) + ") is not supported."));
-                return;
-            }
-
-            MG_State::pGLContext->SetCapabilityIndexed(capInput, index, true);
-        }
-
-        /* @INSERTION_POINT:FUNCTION_IMPLEMENTATION@ */
-        void BlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) {
-            BlendFuncSeparatei_State(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
-        }
-
-        void Disablei(GLenum target, GLuint index) {
-            Disablei_State(target, index);
-        }
-
-        void Enablei(GLenum target, GLuint index) {
-            Enablei_State(target, index);
-        }
-
-        void BlendFunc(GLenum sfactor, GLenum dfactor) {
-            BlendFunc_State(sfactor, dfactor);
-        }
-
-        void Viewport(GLint x, GLint y, GLsizei width, GLsizei height) {
-            Viewport_State(x, y, width, height);
-        }
-
-        void StencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) {
-            StencilOpSeparate_State(face, sfail, dpfail, dppass);
-        }
-
-        void StencilOp(GLenum fail, GLenum zfail, GLenum zpass) {
-            StencilOp_State(fail, zfail, zpass);
-        }
-
-        void StencilMaskSeparate(GLenum face, GLuint mask) {
-            StencilMaskSeparate_State(face, mask);
-        }
-
-        void StencilMask(GLuint mask) {
-            StencilMask_State(mask);
-        }
-
-        void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) {
-            StencilFuncSeparate_State(face, func, ref, mask);
-        }
-
-        void StencilFunc(GLenum func, GLint ref, GLuint mask) {
-            StencilFunc_State(func, ref, mask);
-        }
-
-        void Scissor(GLint x, GLint y, GLsizei width, GLsizei height) {
-            Scissor_State(x, y, width, height);
-        }
-
-        void SampleCoverage(GLfloat value, GLboolean invert) {
-            SampleCoverage_State(value, invert);
-        }
-
-        void PolygonOffset(GLfloat factor, GLfloat units) {
-            PolygonOffset_State(factor, units);
-        }
+    void LineWidth(GLfloat width) {
+        LineWidth_State(width);
+    }
+
+    GLboolean IsEnabledi(GLenum target, GLuint index) {
+        return IsEnabledi_State(target, index);
+    }
+
+    GLboolean IsEnabled(GLenum cap) {
+        return IsEnabled_State(cap);
+    }
 
-        void PolygonMode(GLenum face, GLenum mode) {
-            PolygonMode_State(face, mode);
-        }
+    void Hint(GLenum target, GLenum mode) {
+        Hint_State(target, mode);
+    }
 
-        void PointSize(GLfloat size) {
-            PointSize_State(size);
-        }
+    void FrontFace(GLenum mode) {
+        FrontFace_State(mode);
+    }
+
+    void Enable(GLenum cap) {
+        Enable_State(cap);
+    }
 
-        void PointParameterf(GLenum pname, GLfloat param) {
-            PointParameterf_State(pname, param);
-        }
+    void Disable(GLenum cap) {
+        Disable_State(cap);
+    }
 
-        void PointParameteri(GLenum pname, GLint param) {
-            PointParameteri_State(pname, param);
-        }
+    void DepthRange(GLclampd near_val, GLclampd far_val) {
+        DepthRange_State(near_val, far_val);
+    }
 
-        void PixelStorei(GLenum pname, GLint param) {
-            PixelStorei_State(pname, param);
-        }
-
-        void LogicOp(GLenum opcode) {
-            LogicOp_State(opcode);
-        }
-
-        void LineWidth(GLfloat width) {
-            LineWidth_State(width);
-        }
+    void DepthMask(GLboolean flag) {
+        DepthMask_State(flag);
+    }
 
-        GLboolean IsEnabledi(GLenum target, GLuint index) {
-            return IsEnabledi_State(target, index);
-        }
+    void DepthFunc(GLenum func) {
+        DepthFunc_State(func);
+    }
 
-        GLboolean IsEnabled(GLenum cap) {
-            return IsEnabled_State(cap);
-        }
+    void CullFace(GLenum mode) {
+        CullFace_State(mode);
+    }
 
-        void Hint(GLenum target, GLenum mode) {
-            Hint_State(target, mode);
-        }
+    void ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {
+        ColorMask_State(red, green, blue, alpha);
+    }
 
-        void FrontFace(GLenum mode) {
-            FrontFace_State(mode);
-        }
+    void ClampColor(GLenum target, GLenum clamp) {
+        ClampColor_State(target, clamp);
+    }
 
-        void Enable(GLenum cap) {
-            Enable_State(cap);
-        }
+    void BlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) {
+        BlendFuncSeparate_State(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+    }
 
-        void Disable(GLenum cap) {
-            Disable_State(cap);
-        }
+    void BlendEquation(GLenum mode) {
+        BlendEquation_State(mode);
+    }
 
-        void DepthRange(GLclampd near_val, GLclampd far_val) {
-            DepthRange_State(near_val, far_val);
-        }
+    void BlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
+        BlendColor_State(red, green, blue, alpha);
+    }
 
-        void DepthMask(GLboolean flag) {
-            DepthMask_State(flag);
-        }
+    void ClearStencil(GLint s) {
+        ClearStencil_State(s);
+    }
 
-        void DepthFunc(GLenum func) {
-            DepthFunc_State(func);
-        }
+    void ClearDepth(GLclampd depth) {
+        ClearDepth_State(depth);
+    }
 
-        void CullFace(GLenum mode) {
-            CullFace_State(mode);
-        }
-
-        void ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {
-            ColorMask_State(red, green, blue, alpha);
-        }
-
-        void ClampColor(GLenum target, GLenum clamp) {
-            ClampColor_State(target, clamp);
-        }
-
-        void BlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) {
-            BlendFuncSeparate_State(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
-        }
-
-        void BlendEquation(GLenum mode) {
-            BlendEquation_State(mode);
-        }
-
-        void BlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
-            BlendColor_State(red, green, blue, alpha);
-        }
-
-        void ClearStencil(GLint s) {
-            ClearStencil_State(s);
-        }
-
-        void ClearDepth(GLclampd depth) {
-            ClearDepth_State(depth);
-        }
-
-        void ClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
-            ClearColor_State(red, green, blue, alpha);
-        }
-    } // namespace MG_Impl::GLImpl
-} // namespace MobileGL
+    void ClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
+        ClearColor_State(red, green, blue, alpha);
+    }
+} // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/RenderState/GL_RenderState.h

@@ -9,47 +9,45 @@
 #pragma once
 #include <Includes.h>
 
-namespace MobileGL {
-    namespace MG_Impl::GLImpl {
-        /* @INSERTION_POINT:FUNCTION_DECLARATION@ */
-        void BlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
-        void Disablei(GLenum target, GLuint index);
-        void Enablei(GLenum target, GLuint index);
-        void BlendFunc(GLenum sfactor, GLenum dfactor);
-        void Viewport(GLint x, GLint y, GLsizei width, GLsizei height);
-        void StencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
-        void StencilOp(GLenum fail, GLenum zfail, GLenum zpass);
-        void StencilMaskSeparate(GLenum face, GLuint mask);
-        void StencilMask(GLuint mask);
-        void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
-        void StencilFunc(GLenum func, GLint ref, GLuint mask);
-        void Scissor(GLint x, GLint y, GLsizei width, GLsizei height);
-        void SampleCoverage(GLfloat value, GLboolean invert);
-        void PolygonOffset(GLfloat factor, GLfloat units);
-        void PolygonMode(GLenum face, GLenum mode);
-        void PointSize(GLfloat size);
-        void PointParameterf(GLenum pname, GLfloat param);
-        void PointParameteri(GLenum pname, GLint param);
-        void PixelStorei(GLenum pname, GLint param);
-        void LogicOp(GLenum opcode);
-        void LineWidth(GLfloat width);
-        GLboolean IsEnabledi(GLenum target, GLuint index);
-        GLboolean IsEnabled(GLenum cap);
-        void Hint(GLenum target, GLenum mode);
-        void FrontFace(GLenum mode);
-        void Enable(GLenum cap);
-        void Disable(GLenum cap);
-        void DepthRange(GLclampd near_val, GLclampd far_val);
-        void DepthMask(GLboolean flag);
-        void DepthFunc(GLenum func);
-        void CullFace(GLenum mode);
-        void ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-        void ClampColor(GLenum target, GLenum clamp);
-        void BlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
-        void BlendEquation(GLenum mode);
-        void BlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-        void ClearStencil(GLint s);
-        void ClearDepth(GLclampd depth);
-        void ClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    } // namespace MG_Impl::GLImpl
-} // namespace MobileGL
+namespace MobileGL::MG_Impl::GLImpl {
+    /* @INSERTION_POINT:FUNCTION_DECLARATION@ */
+    void BlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
+    void Disablei(GLenum target, GLuint index);
+    void Enablei(GLenum target, GLuint index);
+    void BlendFunc(GLenum sfactor, GLenum dfactor);
+    void Viewport(GLint x, GLint y, GLsizei width, GLsizei height);
+    void StencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
+    void StencilOp(GLenum fail, GLenum zfail, GLenum zpass);
+    void StencilMaskSeparate(GLenum face, GLuint mask);
+    void StencilMask(GLuint mask);
+    void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
+    void StencilFunc(GLenum func, GLint ref, GLuint mask);
+    void Scissor(GLint x, GLint y, GLsizei width, GLsizei height);
+    void SampleCoverage(GLfloat value, GLboolean invert);
+    void PolygonOffset(GLfloat factor, GLfloat units);
+    void PolygonMode(GLenum face, GLenum mode);
+    void PointSize(GLfloat size);
+    void PointParameterf(GLenum pname, GLfloat param);
+    void PointParameteri(GLenum pname, GLint param);
+    void PixelStorei(GLenum pname, GLint param);
+    void LogicOp(GLenum opcode);
+    void LineWidth(GLfloat width);
+    GLboolean IsEnabledi(GLenum target, GLuint index);
+    GLboolean IsEnabled(GLenum cap);
+    void Hint(GLenum target, GLenum mode);
+    void FrontFace(GLenum mode);
+    void Enable(GLenum cap);
+    void Disable(GLenum cap);
+    void DepthRange(GLclampd near_val, GLclampd far_val);
+    void DepthMask(GLboolean flag);
+    void DepthFunc(GLenum func);
+    void CullFace(GLenum mode);
+    void ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+    void ClampColor(GLenum target, GLenum clamp);
+    void BlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+    void BlendEquation(GLenum mode);
+    void BlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+    void ClearStencil(GLint s);
+    void ClearDepth(GLclampd depth);
+    void ClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+} // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/Sampler/GL_Sampler.cpp

@@ -12,254 +12,258 @@
 #include <MG_Util/Converters/GLToMG/TextureEnumConverter.h>
 #include <MG_Util/Converters/MGToGL/TextureEnumConverter.h>
 
-namespace MobileGL {
-    namespace MG_Impl::GLImpl {
-        void SetSamplerParam_State(GLuint sampler, GLenum pname, const void* param, bool isFloat, bool isInteger) {
+namespace MobileGL::MG_Impl::GLImpl {
+    void SetSamplerParam_State(GLuint sampler, GLenum pname, const void* param, bool isFloat, bool isInteger) {
+        if (!SamplerImpl::ValidateSamplerName(sampler)) return;
+
+        Bool doesSamplerObjectCreated = MG_State::pGLContext->ValidateSamplerObject(sampler);
+        if (!doesSamplerObjectCreated) {
+            // Create one for compatibility
+            MG_State::pGLContext->CreateSamplerObject(sampler);
+        }
+        auto& samplerObj = MG_State::pGLContext->GetSamplerObject(sampler);
+        if (!SamplerImpl::ValidateSamplerObject(sampler)) return;
+
+        using namespace MG_Util;
+        switch (pname) {
+        case GL_TEXTURE_WRAP_S:
+            samplerObj->SetWrapS(MG_Util::ConvertGLEnumToSamplerWrapMode(*(const GLint*)param));
+            break;
+        case GL_TEXTURE_WRAP_T:
+            samplerObj->SetWrapT(MG_Util::ConvertGLEnumToSamplerWrapMode(*(const GLint*)param));
+            break;
+        case GL_TEXTURE_WRAP_R:
+            samplerObj->SetWrapR(MG_Util::ConvertGLEnumToSamplerWrapMode(*(const GLint*)param));
+            break;
+        case GL_TEXTURE_MIN_FILTER:
+            samplerObj->SetMinFilter(MG_Util::ConvertGLEnumToSamplerFilterMode(*(const GLint*)param));
+            samplerObj->SetMipmapMode(MG_Util::ConvertGLEnumToSamplerMipmapMode(*(const GLint*)param));
+            break;
+        case GL_TEXTURE_MAG_FILTER:
+            samplerObj->SetMagFilter(MG_Util::ConvertGLEnumToSamplerFilterMode(*(const GLint*)param));
+            break;
+        case GL_TEXTURE_MIN_LOD:
+            samplerObj->SetLodRange(*(const GLfloat*)param, samplerObj->GetMaxLod());
+            break;
+        case GL_TEXTURE_MAX_LOD:
+            samplerObj->SetLodRange(samplerObj->GetMinLod(), *(const GLfloat*)param);
+            break;
+        case GL_TEXTURE_LOD_BIAS:
+            samplerObj->SetLodBias(*(const GLfloat*)param);
+            break;
+        case GL_TEXTURE_COMPARE_MODE:
+            samplerObj->SetCompareMode(MG_Util::ConvertGLEnumToSamplerCompareMode(*(const GLint*)param));
+            break;
+        case GL_TEXTURE_COMPARE_FUNC:
+            samplerObj->SetSamplerCompareFunc(MG_Util::ConvertGLEnumToSamplerCompareFunc(*(const GLint*)param));
+            break;
+        default:
+            MG_State::pGLContext->RecordError(ErrorCode::InvalidEnum,
+                                              MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "SetSamplerParam_State",
+                                                                           "Invalid pname for sampler parameter"));
+        }
+    }
+
+    void GetSamplerParam_State(GLuint sampler, GLenum pname, void* params, bool isFloat, bool isInteger) {
+        if (!SamplerImpl::ValidateSamplerName(sampler)) return;
+
+        Bool doesSamplerObjectCreated = MG_State::pGLContext->ValidateSamplerObject(sampler);
+        if (!doesSamplerObjectCreated) {
+            // Create one for compatibility
+            MG_State::pGLContext->CreateSamplerObject(sampler);
+        }
+        auto& samplerObj = MG_State::pGLContext->GetSamplerObject(sampler);
+        if (!SamplerImpl::ValidateSamplerObject(sampler)) return;
+
+        using namespace MG_Util;
+        switch (pname) {
+        case GL_TEXTURE_WRAP_S:
+            *(GLuint*)params = MG_Util::ConvertSamplerWrapModeToGLEnum(samplerObj->GetWrapS());
+            break;
+        case GL_TEXTURE_WRAP_T:
+            *(GLuint*)params = MG_Util::ConvertSamplerWrapModeToGLEnum(samplerObj->GetWrapT());
+            break;
+        case GL_TEXTURE_WRAP_R:
+            *(GLuint*)params = MG_Util::ConvertSamplerWrapModeToGLEnum(samplerObj->GetWrapR());
+            break;
+        case GL_TEXTURE_MIN_FILTER:
+            *(GLuint*)params =
+                MG_Util::ConvertSamplerFilterModeToGLEnum(samplerObj->GetMinFilter(), samplerObj->GetMipmapMode());
+            break;
+        case GL_TEXTURE_MAG_FILTER:
+            *(GLuint*)params =
+                MG_Util::ConvertSamplerFilterModeToGLEnum(samplerObj->GetMagFilter(), SamplerMipmapMode::None);
+            break;
+        case GL_TEXTURE_MIN_LOD:
+            *(GLfloat*)params = samplerObj->GetMinLod();
+            break;
+        case GL_TEXTURE_MAX_LOD:
+            *(GLfloat*)params = samplerObj->GetMaxLod();
+            break;
+        case GL_TEXTURE_LOD_BIAS:
+            *(GLfloat*)params = samplerObj->GetLodBias();
+            break;
+        case GL_TEXTURE_COMPARE_MODE:
+            *(GLuint*)params = MG_Util::ConvertSamplerCompareModeToGLEnum(samplerObj->GetCompareMode());
+            break;
+        case GL_TEXTURE_COMPARE_FUNC:
+            *(GLuint*)params = MG_Util::ConvertSamplerCompareFuncToGLEnum(samplerObj->GetSamplerCompareFunc());
+            break;
+        default:
+            MG_State::pGLContext->RecordError(ErrorCode::InvalidEnum,
+                                              MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "GetSamplerParam_State",
+                                                                           "Invalid pname for sampler parameter"));
+        }
+    }
+
+    GLboolean IsSampler_State(GLuint sampler) {
+        return MG_State::pGLContext->ValidateSamplerObject(sampler) ? GL_TRUE : GL_FALSE;
+    }
+
+    // migrate below functions without "_State" into this section
+    void GenSamplers_State(GLsizei count, GLuint* samplers) {
+        if (count < 0) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidValue,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "GenSamplers", "count must be non-negative"));
+            return;
+        }
+
+        static thread_local Vector<GLuint> names;
+        MG_State::pGLContext->GenSamplerNames(count, names);
+        Memcpy(samplers, names.data(), count * sizeof(GLuint));
+    }
+
+    void DeleteSamplers_State(GLsizei count, const GLuint* samplers) {
+        if (count < 0) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidValue,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "DeleteSamplers", "count must be non-negative"));
+            return;
+        }
+
+        for (GLsizei i = 0; i < count; ++i) {
+            if (samplers[i] != 0) {
+                MG_State::pGLContext->MarkSamplerObjectForDeletion(samplers[i]);
+            }
+        }
+    }
+
+    void CreateSamplers_State(GLsizei n, GLuint* samplers) {
+        if (n < 0) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidValue,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "GenSamplers", "count must be non-negative"));
+            return;
+        }
+
+        static thread_local Vector<GLuint> names;
+        MG_State::pGLContext->GenSamplerNames(n, names);
+        Memcpy(samplers, names.data(), n * sizeof(GLuint));
+        for (GLsizei i = 0; i < n; ++i) {
+            samplers[i] = names[i];
+            MG_State::pGLContext->CreateSamplerObject(names[i]);
+        }
+    }
+
+    void BindSampler_State(GLuint unit, GLuint sampler) {
+        if (unit >= MG_State::GLState::TextureState::MAX_TEXTURE_IMAGE_UNITS) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidValue,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "BindSampler", "texture unit out of range"));
+            return;
+        }
+
+        auto& textureUnit = MG_State::pGLContext->GetTextureUnitObject((Int)unit);
+        if (sampler == 0) {
+            textureUnit.SetSamplerObject(nullptr);
+        } else {
             if (!SamplerImpl::ValidateSamplerName(sampler)) return;
-
-            auto samplerObj = MG_State::pGLContext->GetSamplerObject(sampler);
-            if (!samplerObj) {
-                samplerObj = MG_State::pGLContext->CreateSamplerObject(sampler); // for compatibility
+            Bool doesSamplerObjectCreated = MG_State::pGLContext->ValidateSamplerObject(sampler);
+            if (!doesSamplerObjectCreated) {
+                MG_State::pGLContext->CreateSamplerObject(sampler);
             }
-            if (!SamplerImpl::ValidateSamplerObject(sampler)) return;
+            auto& samplerObject = MG_State::pGLContext->GetSamplerObject(sampler);
 
-            using namespace MG_Util;
-            switch (pname) {
-            case GL_TEXTURE_WRAP_S:
-                samplerObj->SetWrapS(MG_Util::ConvertGLEnumToSamplerWrapMode(*(const GLint*)param));
-                break;
-            case GL_TEXTURE_WRAP_T:
-                samplerObj->SetWrapT(MG_Util::ConvertGLEnumToSamplerWrapMode(*(const GLint*)param));
-                break;
-            case GL_TEXTURE_WRAP_R:
-                samplerObj->SetWrapR(MG_Util::ConvertGLEnumToSamplerWrapMode(*(const GLint*)param));
-                break;
-            case GL_TEXTURE_MIN_FILTER:
-                samplerObj->SetMinFilter(MG_Util::ConvertGLEnumToSamplerFilterMode(*(const GLint*)param));
-                samplerObj->SetMipmapMode(MG_Util::ConvertGLEnumToSamplerMipmapMode(*(const GLint*)param));
-                break;
-            case GL_TEXTURE_MAG_FILTER:
-                samplerObj->SetMagFilter(MG_Util::ConvertGLEnumToSamplerFilterMode(*(const GLint*)param));
-                break;
-            case GL_TEXTURE_MIN_LOD:
-                samplerObj->SetLodRange(*(const GLfloat*)param, samplerObj->GetMaxLod());
-                break;
-            case GL_TEXTURE_MAX_LOD:
-                samplerObj->SetLodRange(samplerObj->GetMinLod(), *(const GLfloat*)param);
-                break;
-            case GL_TEXTURE_LOD_BIAS:
-                samplerObj->SetLodBias(*(const GLfloat*)param);
-                break;
-            case GL_TEXTURE_COMPARE_MODE:
-                samplerObj->SetCompareMode(MG_Util::ConvertGLEnumToSamplerCompareMode(*(const GLint*)param));
-                break;
-            case GL_TEXTURE_COMPARE_FUNC:
-                samplerObj->SetSamplerCompareFunc(MG_Util::ConvertGLEnumToSamplerCompareFunc(*(const GLint*)param));
-                break;
-            default:
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidEnum, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "SetSamplerParam_State",
-                                                                         "Invalid pname for sampler parameter"));
-            }
+            textureUnit.SetSamplerObject(MG_State::pGLContext->GetSamplerObject(sampler));
+        }
+    }
+
+    void BindSamplers_State(GLuint first, GLsizei count, const GLuint* samplers) {
+        if (count < 0) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidValue,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "BindSamplers", "count must be non-negative"));
+            return;
         }
 
-        void GetSamplerParam_State(GLuint sampler, GLenum pname, void* params, bool isFloat, bool isInteger) {
-            if (!SamplerImpl::ValidateSamplerName(sampler)) return;
-
-            auto samplerObj = MG_State::pGLContext->GetSamplerObject(sampler);
-            if (!samplerObj) {
-                samplerObj = MG_State::pGLContext->CreateSamplerObject(sampler); // for compatibility
-            }
-            if (!SamplerImpl::ValidateSamplerObject(sampler)) return;
-
-            using namespace MG_Util;
-            switch (pname) {
-            case GL_TEXTURE_WRAP_S:
-                *(GLint*)params = MG_Util::ConvertSamplerWrapModeToGLEnum(samplerObj->GetWrapS());
-                break;
-            case GL_TEXTURE_WRAP_T:
-                *(GLint*)params = MG_Util::ConvertSamplerWrapModeToGLEnum(samplerObj->GetWrapT());
-                break;
-            case GL_TEXTURE_WRAP_R:
-                *(GLint*)params = MG_Util::ConvertSamplerWrapModeToGLEnum(samplerObj->GetWrapR());
-                break;
-            case GL_TEXTURE_MIN_FILTER:
-                *(GLint*)params =
-                    MG_Util::ConvertSamplerFilterModeToGLEnum(samplerObj->GetMinFilter(), samplerObj->GetMipmapMode());
-                break;
-            case GL_TEXTURE_MAG_FILTER:
-                *(GLint*)params =
-                    MG_Util::ConvertSamplerFilterModeToGLEnum(samplerObj->GetMagFilter(), SamplerMipmapMode::None);
-                break;
-            case GL_TEXTURE_MIN_LOD:
-                *(GLfloat*)params = samplerObj->GetMinLod();
-                break;
-            case GL_TEXTURE_MAX_LOD:
-                *(GLfloat*)params = samplerObj->GetMaxLod();
-                break;
-            case GL_TEXTURE_LOD_BIAS:
-                *(GLfloat*)params = samplerObj->GetLodBias();
-                break;
-            case GL_TEXTURE_COMPARE_MODE:
-                *(GLint*)params = MG_Util::ConvertSamplerCompareModeToGLEnum(samplerObj->GetCompareMode());
-                break;
-            case GL_TEXTURE_COMPARE_FUNC:
-                *(GLint*)params = MG_Util::ConvertSamplerCompareFuncToGLEnum(samplerObj->GetSamplerCompareFunc());
-                break;
-            default:
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidEnum, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "GetSamplerParam_State",
-                                                                         "Invalid pname for sampler parameter"));
-            }
+        for (GLsizei i = 0; i < count; ++i) {
+            BindSampler_State(first + i, samplers ? samplers[i] : 0);
         }
+    }
 
-        GLboolean IsSampler_State(GLuint sampler) {
-            return MG_State::pGLContext->ValidateSamplerObject(sampler) ? GL_TRUE : GL_FALSE;
-        }
+    /* @INSERTION_POINT:FUNCTION_IMPLEMENTATION@ */
+    void GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params) {
+        GetSamplerParam_State(sampler, pname, params, false, false);
+    }
 
-        // migrate below functions without "_State" into this section
-        void GenSamplers_State(GLsizei count, GLuint* samplers) {
-            if (count < 0) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "GenSamplers", "count must be non-negative"));
-                return;
-            }
+    void SamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint* param) {
+        SetSamplerParam_State(sampler, pname, param, false, true);
+    }
 
-            auto names = MG_State::pGLContext->GenSamplerNames(count);
-            for (GLsizei i = 0; i < count; ++i) {
-                samplers[i] = names[i];
-            }
-        }
+    void SamplerParameterIiv(GLuint sampler, GLenum pname, const GLint* param) {
+        SetSamplerParam_State(sampler, pname, param, false, true);
+    }
 
-        void DeleteSamplers_State(GLsizei count, const GLuint* samplers) {
-            if (count < 0) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "DeleteSamplers", "count must be non-negative"));
-                return;
-            }
+    void SamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param) {
+        SetSamplerParam_State(sampler, pname, param, false, false);
+    }
 
-            for (GLsizei i = 0; i < count; ++i) {
-                if (samplers[i] != 0) {
-                    MG_State::pGLContext->MarkSamplerObjectForDeletion(samplers[i]);
-                }
-            }
-        }
+    void SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param) {
+        SetSamplerParam_State(sampler, pname, param, true, false);
+    }
 
-        void CreateSamplers_State(GLsizei n, GLuint* samplers) {
-            if (n < 0) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "GenSamplers", "count must be non-negative"));
-                return;
-            }
+    void SamplerParameteri(GLuint sampler, GLenum pname, GLint param) {
+        SamplerParameteriv(sampler, pname, &param);
+    }
 
-            auto names = MG_State::pGLContext->GenSamplerNames(n);
-            for (GLsizei i = 0; i < n; ++i) {
-                samplers[i] = names[i];
-                MG_State::pGLContext->CreateSamplerObject(names[i]);
-            }
-        }
+    void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) {
+        SamplerParameterfv(sampler, pname, &param);
+    }
 
-        void BindSampler_State(GLuint unit, GLuint sampler) {
-            if (unit >= MG_State::GLState::TextureState::MAX_TEXTURE_IMAGE_UNITS) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "BindSampler", "texture unit out of range"));
-                return;
-            }
+    GLboolean IsSampler(GLuint sampler) {
+        return IsSampler_State(sampler);
+    }
 
-            auto& textureUnit = MG_State::pGLContext->GetTextureUnitObject(unit);
-            if (sampler == 0) {
-                textureUnit.SetSamplerObject(nullptr);
-            } else {
-                if (!SamplerImpl::ValidateSamplerName(sampler)) return;
-                auto samplerObject = MG_State::pGLContext->GetSamplerObject(sampler);
-                if (!samplerObject) {
-                    samplerObject = MG_State::pGLContext->CreateSamplerObject(sampler);
-                }
+    void GetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint* params) {
+        GetSamplerParam_State(sampler, pname, params, false, true);
+    }
 
-                textureUnit.SetSamplerObject(MG_State::pGLContext->GetSamplerObject(sampler));
-            }
-        }
+    void GetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint* params) {
+        GetSamplerParam_State(sampler, pname, params, false, true);
+    }
 
-        void BindSamplers_State(GLuint first, GLsizei count, const GLuint* samplers) {
-            if (count < 0) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "BindSamplers", "count must be non-negative"));
-                return;
-            }
+    void GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params) {
+        GetSamplerParam_State(sampler, pname, params, true, false);
+    }
 
-            for (GLsizei i = 0; i < count; ++i) {
-                BindSampler_State(first + i, samplers ? samplers[i] : 0);
-            }
-        }
+    void GenSamplers(GLsizei count, GLuint* samplers) {
+        GenSamplers_State(count, samplers);
+    }
 
-        /* @INSERTION_POINT:FUNCTION_IMPLEMENTATION@ */
-        void GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params) {
-            GetSamplerParam_State(sampler, pname, params, false, false);
-        }
+    void DeleteSamplers(GLsizei count, const GLuint* samplers) {
+        DeleteSamplers_State(count, samplers);
+    }
 
-        void SamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint* param) {
-            SetSamplerParam_State(sampler, pname, param, false, true);
-        }
+    void CreateSamplers(GLsizei n, GLuint* samplers) {
+        CreateSamplers_State(n, samplers);
+    }
 
-        void SamplerParameterIiv(GLuint sampler, GLenum pname, const GLint* param) {
-            SetSamplerParam_State(sampler, pname, param, false, true);
-        }
+    void BindSamplers(GLuint first, GLsizei count, const GLuint* samplers) {
+        BindSamplers_State(first, count, samplers);
+    }
 
-        void SamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param) {
-            SetSamplerParam_State(sampler, pname, param, false, false);
-        }
-
-        void SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param) {
-            SetSamplerParam_State(sampler, pname, param, true, false);
-        }
-
-        void SamplerParameteri(GLuint sampler, GLenum pname, GLint param) {
-            SamplerParameteriv(sampler, pname, &param);
-        }
-
-        void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) {
-            SamplerParameterfv(sampler, pname, &param);
-        }
-
-        GLboolean IsSampler(GLuint sampler) {
-            return IsSampler_State(sampler);
-        }
-
-        void GetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint* params) {
-            GetSamplerParam_State(sampler, pname, params, false, true);
-        }
-
-        void GetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint* params) {
-            GetSamplerParam_State(sampler, pname, params, false, true);
-        }
-
-        void GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params) {
-            GetSamplerParam_State(sampler, pname, params, true, false);
-        }
-
-        void GenSamplers(GLsizei count, GLuint* samplers) {
-            GenSamplers_State(count, samplers);
-        }
-
-        void DeleteSamplers(GLsizei count, const GLuint* samplers) {
-            DeleteSamplers_State(count, samplers);
-        }
-
-        void CreateSamplers(GLsizei n, GLuint* samplers) {
-            CreateSamplers_State(n, samplers);
-        }
-
-        void BindSamplers(GLuint first, GLsizei count, const GLuint* samplers) {
-            BindSamplers_State(first, count, samplers);
-        }
-
-        void BindSampler(GLuint unit, GLuint sampler) {
-            BindSampler_State(unit, sampler);
-        }
-    } // namespace MG_Impl::GLImpl
-} // namespace MobileGL
+    void BindSampler(GLuint unit, GLuint sampler) {
+        BindSampler_State(unit, sampler);
+    }
+} // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/Sampler/GL_Sampler.h

@@ -9,24 +9,22 @@
 #pragma once
 #include <Includes.h>
 
-namespace MobileGL {
-    namespace MG_Impl::GLImpl {
-        /* @INSERTION_POINT:FUNCTION_DECLARATION@ */
-        void GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params);
-        void SamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint* param);
-        void SamplerParameterIiv(GLuint sampler, GLenum pname, const GLint* param);
-        void SamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param);
-        void SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param);
-        void SamplerParameteri(GLuint sampler, GLenum pname, GLint param);
-        void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param);
-        GLboolean IsSampler(GLuint sampler);
-        void GetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint* params);
-        void GetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint* params);
-        void GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params);
-        void GenSamplers(GLsizei count, GLuint* samplers);
-        void DeleteSamplers(GLsizei count, const GLuint* samplers);
-        void CreateSamplers(GLsizei n, GLuint* samplers);
-        void BindSamplers(GLuint first, GLsizei count, const GLuint* samplers);
-        void BindSampler(GLuint unit, GLuint sampler);
-    } // namespace MG_Impl::GLImpl
-} // namespace MobileGL
+namespace MobileGL::MG_Impl::GLImpl {
+    /* @INSERTION_POINT:FUNCTION_DECLARATION@ */
+    void GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params);
+    void SamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint* param);
+    void SamplerParameterIiv(GLuint sampler, GLenum pname, const GLint* param);
+    void SamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param);
+    void SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param);
+    void SamplerParameteri(GLuint sampler, GLenum pname, GLint param);
+    void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param);
+    GLboolean IsSampler(GLuint sampler);
+    void GetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint* params);
+    void GetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint* params);
+    void GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params);
+    void GenSamplers(GLsizei count, GLuint* samplers);
+    void DeleteSamplers(GLsizei count, const GLuint* samplers);
+    void CreateSamplers(GLsizei n, GLuint* samplers);
+    void BindSamplers(GLuint first, GLsizei count, const GLuint* samplers);
+    void BindSampler(GLuint unit, GLuint sampler);
+} // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/Sampler/Validators.cpp

@@ -11,126 +11,122 @@
 #include <MG_State/GLState/ErrorState/Error.h>
 #include <MG_Util/Converters/GLToMG/TextureEnumConverter.h>
 
-namespace MobileGL::MG_Impl::GLImpl {
-    namespace SamplerImpl {
-        Bool ValidateSamplerName(GLuint sampler) {
-            if (!MG_State::pGLContext->ValidateSamplerName(sampler)) {
+namespace MobileGL::MG_Impl::GLImpl::SamplerImpl {
+    Bool ValidateSamplerName(GLuint sampler) {
+        if (!MG_State::pGLContext->ValidateSamplerName(sampler)) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidValue, MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateSamplerName",
+                                                                      std::format("Invalid sampler name {}", sampler)));
+            return false;
+        }
+        return true;
+    }
+
+    Bool ValidateSamplerObject(GLuint sampler) {
+        if (!MG_State::pGLContext->ValidateSamplerObject(sampler)) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidOperation,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateSamplerObject",
+                                             std::format("Sampler object {} does not exist", sampler)));
+            return false;
+        }
+        return true;
+    }
+
+    Bool ValidateSamplerParam(GLenum pname, GLenum param) {
+        using namespace MG_Util;
+        switch (pname) {
+        case GL_TEXTURE_WRAP_S:
+        case GL_TEXTURE_WRAP_T:
+        case GL_TEXTURE_WRAP_R:
+            if (MG_Util::ConvertGLEnumToSamplerWrapMode(param) == SamplerWrapMode::Unknown) {
+                MG_State::pGLContext->RecordError(ErrorCode::InvalidEnum,
+                                                  MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateSamplerParam",
+                                                                               "Invalid wrap mode parameter"));
+                return false;
+            }
+            break;
+
+        case GL_TEXTURE_MIN_FILTER:
+            if (MG_Util::ConvertGLEnumToSamplerFilterMode(param) == SamplerFilterMode::Unknown) {
+                MG_State::pGLContext->RecordError(ErrorCode::InvalidEnum,
+                                                  MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateSamplerParam",
+                                                                               "Invalid min filter parameter"));
+                return false;
+            }
+            break;
+
+        case GL_TEXTURE_MAG_FILTER:
+            if (param != GL_NEAREST && param != GL_LINEAR) {
+                MG_State::pGLContext->RecordError(ErrorCode::InvalidEnum,
+                                                  MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateSamplerParam",
+                                                                               "Invalid mag filter parameter"));
+                return false;
+            }
+            break;
+
+        case GL_TEXTURE_COMPARE_MODE:
+            if (param != GL_NONE && param != GL_COMPARE_REF_TO_TEXTURE) {
+                MG_State::pGLContext->RecordError(ErrorCode::InvalidEnum,
+                                                  MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateSamplerParam",
+                                                                               "Invalid compare mode parameter"));
+                return false;
+            }
+            break;
+
+        case GL_TEXTURE_COMPARE_FUNC:
+            if (param < GL_LEQUAL || param > GL_ALWAYS) {
+                MG_State::pGLContext->RecordError(ErrorCode::InvalidEnum,
+                                                  MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateSamplerParam",
+                                                                               "Invalid compare function parameter"));
+                return false;
+            }
+            break;
+
+        default:
+            MG_State::pGLContext->RecordError(ErrorCode::InvalidEnum,
+                                              MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateSamplerParam",
+                                                                           "Invalid pname for sampler parameter"));
+            return false;
+        }
+        return true;
+    }
+
+    Bool ValidateSamplerFloatParam(GLenum pname, GLfloat param) {
+        switch (pname) {
+        case GL_TEXTURE_MIN_LOD:
+        case GL_TEXTURE_MAX_LOD:
+        case GL_TEXTURE_LOD_BIAS:
+            return true;
+
+        case GL_TEXTURE_BORDER_COLOR:
+            if (param < 0.0f || param > 1.0f) {
+                MG_State::pGLContext->RecordError(
+                    ErrorCode::InvalidValue, MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateSamplerFloatParam",
+                                                                          "Border color component out of [0,1] range"));
+                return false;
+            }
+            return true;
+
+        default:
+            return ValidateSamplerParam(pname, static_cast<GLenum>(param));
+        }
+    }
+
+    Bool ValidateSamplerIntParam(GLenum pname, GLint param) {
+        switch (pname) {
+        case GL_TEXTURE_BORDER_COLOR:
+            if (param < 0 || param > 255) {
                 MG_State::pGLContext->RecordError(
                     ErrorCode::InvalidValue,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateSamplerName",
-                                                 std::format("Invalid sampler name {}", sampler)));
+                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateSamplerIntParam",
+                                                 "Border color component out of [0,255] range"));
                 return false;
             }
             return true;
+
+        default:
+            return ValidateSamplerParam(pname, static_cast<GLenum>(param));
         }
-
-        Bool ValidateSamplerObject(GLuint sampler) {
-            if (!MG_State::pGLContext->ValidateSamplerObject(sampler)) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidOperation,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateSamplerObject",
-                                                 std::format("Sampler object {} does not exist", sampler)));
-                return false;
-            }
-            return true;
-        }
-
-        Bool ValidateSamplerParam(GLenum pname, GLenum param) {
-            using namespace MG_Util;
-            switch (pname) {
-            case GL_TEXTURE_WRAP_S:
-            case GL_TEXTURE_WRAP_T:
-            case GL_TEXTURE_WRAP_R:
-                if (MG_Util::ConvertGLEnumToSamplerWrapMode(param) == SamplerWrapMode::Unknown) {
-                    MG_State::pGLContext->RecordError(
-                        ErrorCode::InvalidEnum, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateSamplerParam",
-                                                                             "Invalid wrap mode parameter"));
-                    return false;
-                }
-                break;
-
-            case GL_TEXTURE_MIN_FILTER:
-                if (MG_Util::ConvertGLEnumToSamplerFilterMode(param) == SamplerFilterMode::Unknown) {
-                    MG_State::pGLContext->RecordError(
-                        ErrorCode::InvalidEnum, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateSamplerParam",
-                                                                             "Invalid min filter parameter"));
-                    return false;
-                }
-                break;
-
-            case GL_TEXTURE_MAG_FILTER:
-                if (param != GL_NEAREST && param != GL_LINEAR) {
-                    MG_State::pGLContext->RecordError(
-                        ErrorCode::InvalidEnum, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateSamplerParam",
-                                                                             "Invalid mag filter parameter"));
-                    return false;
-                }
-                break;
-
-            case GL_TEXTURE_COMPARE_MODE:
-                if (param != GL_NONE && param != GL_COMPARE_REF_TO_TEXTURE) {
-                    MG_State::pGLContext->RecordError(
-                        ErrorCode::InvalidEnum, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateSamplerParam",
-                                                                             "Invalid compare mode parameter"));
-                    return false;
-                }
-                break;
-
-            case GL_TEXTURE_COMPARE_FUNC:
-                if (param < GL_LEQUAL || param > GL_ALWAYS) {
-                    MG_State::pGLContext->RecordError(
-                        ErrorCode::InvalidEnum, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateSamplerParam",
-                                                                             "Invalid compare function parameter"));
-                    return false;
-                }
-                break;
-
-            default:
-                MG_State::pGLContext->RecordError(ErrorCode::InvalidEnum,
-                                                  MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateSamplerParam",
-                                                                               "Invalid pname for sampler parameter"));
-                return false;
-            }
-            return true;
-        }
-
-        Bool ValidateSamplerFloatParam(GLenum pname, GLfloat param) {
-            switch (pname) {
-            case GL_TEXTURE_MIN_LOD:
-            case GL_TEXTURE_MAX_LOD:
-            case GL_TEXTURE_LOD_BIAS:
-                return true;
-
-            case GL_TEXTURE_BORDER_COLOR:
-                if (param < 0.0f || param > 1.0f) {
-                    MG_State::pGLContext->RecordError(
-                        ErrorCode::InvalidValue,
-                        MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateSamplerFloatParam",
-                                                     "Border color component out of [0,1] range"));
-                    return false;
-                }
-                return true;
-
-            default:
-                return ValidateSamplerParam(pname, static_cast<GLenum>(param));
-            }
-        }
-
-        Bool ValidateSamplerIntParam(GLenum pname, GLint param) {
-            switch (pname) {
-            case GL_TEXTURE_BORDER_COLOR:
-                if (param < 0 || param > 255) {
-                    MG_State::pGLContext->RecordError(
-                        ErrorCode::InvalidValue,
-                        MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateSamplerIntParam",
-                                                     "Border color component out of [0,255] range"));
-                    return false;
-                }
-                return true;
-
-            default:
-                return ValidateSamplerParam(pname, static_cast<GLenum>(param));
-            }
-        }
-    } // namespace SamplerImpl
-} // namespace MobileGL::MG_Impl::GLImpl
+    }
+} // namespace MobileGL::MG_Impl::GLImpl::SamplerImpl

MobileGL/MG_Impl/GLImpl/Sampler/Validators.h

@@ -10,12 +10,10 @@
 #include <Includes.h>
 #include <MG_State/GLState/SamplerState/SamplerObject.h>
 
-namespace MobileGL::MG_Impl::GLImpl {
-    namespace SamplerImpl {
-        Bool ValidateSamplerName(GLuint sampler);
-        Bool ValidateSamplerObject(GLuint sampler);
-        Bool ValidateSamplerParam(GLenum pname, GLenum param);
-        Bool ValidateSamplerFloatParam(GLenum pname, GLfloat param);
-        Bool ValidateSamplerIntParam(GLenum pname, GLint param);
-    } // namespace SamplerImpl
-} // namespace MobileGL::MG_Impl::GLImpl
+namespace MobileGL::MG_Impl::GLImpl::SamplerImpl {
+    Bool ValidateSamplerName(GLuint sampler);
+    Bool ValidateSamplerObject(GLuint sampler);
+    Bool ValidateSamplerParam(GLenum pname, GLenum param);
+    Bool ValidateSamplerFloatParam(GLenum pname, GLfloat param);
+    Bool ValidateSamplerIntParam(GLenum pname, GLint param);
+} // namespace MobileGL::MG_Impl::GLImpl::SamplerImpl

MobileGL/MG_Impl/GLImpl/Sync/GL_Sync.cpp

@@ -10,36 +10,34 @@
 
 #include "MG_State/GLState/Core.h"
 
-namespace MobileGL {
-    namespace MG_Impl::GLImpl {
-        GLsync FenceSync_Backend(GLenum condition, GLbitfield flags) {
-            return 0;
-        }
+namespace MobileGL::MG_Impl::GLImpl {
+    GLsync FenceSync_Backend(GLenum condition, GLbitfield flags) {
+        return 0;
+    }
 
-        GLenum ClientWaitSync_Backend(GLsync sync, GLbitfield flags, GLuint64 timeout) {
-            return 0;
-        }
+    GLenum ClientWaitSync_Backend(GLsync sync, GLbitfield flags, GLuint64 timeout) {
+        return 0;
+    }
 
-        void DeleteSync_Backend(GLsync sync) {}
+    void DeleteSync_Backend(GLsync sync) {}
 
-        GLsync FenceSync_State(GLenum condition, GLbitfield flags) {
-            return 0;
-        }
+    GLsync FenceSync_State(GLenum condition, GLbitfield flags) {
+        return 0;
+    }
 
-        GLenum ClientWaitSync_State(GLsync sync, GLbitfield flags, GLuint64 timeout) {
-            return 0;
-        }
+    GLenum ClientWaitSync_State(GLsync sync, GLbitfield flags, GLuint64 timeout) {
+        return 0;
+    }
 
-        void DeleteSync_State(GLsync sync) {}
+    void DeleteSync_State(GLsync sync) {}
 
-        GLsync FenceSync(GLenum condition, GLbitfield flags) {
-            return 0;
-        }
+    GLsync FenceSync(GLenum condition, GLbitfield flags) {
+        return 0;
+    }
 
-        GLenum ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) {
-            return 0;
-        }
+    GLenum ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) {
+        return 0;
+    }
 
-        void DeleteSync(GLsync sync) {}
-    } // namespace MG_Impl::GLImpl
-} // namespace MobileGL
+    void DeleteSync(GLsync sync) {}
+} // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/Sync/GL_Sync.h

@@ -9,10 +9,8 @@
 #pragma once
 #include <Includes.h>
 
-namespace MobileGL {
-    namespace MG_Impl::GLImpl {
-        GLsync FenceSync(GLenum condition, GLbitfield flags);
-        GLenum ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
-        void DeleteSync(GLsync sync);
-    } // namespace MG_Impl::GLImpl
-} // namespace MobileGL
+namespace MobileGL::MG_Impl::GLImpl {
+    GLsync FenceSync(GLenum condition, GLbitfield flags);
+    GLenum ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
+    void DeleteSync(GLsync sync);
+} // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/Texture/ProxyTexture.cpp

@@ -7,48 +7,47 @@
 // End of Source File Header
 
 #include "ProxyTexture.h"
-#include "MG_State/GLState/TextureState/TextureObject2D.h"
-#include "MG_Util/Types.h"
+#include <MG_State/GLState/TextureState/TextureObject2D.h>
 
-namespace MobileGL::MG_Impl::GLImpl {
-    namespace TextureImpl {
-        ProxyTextureManager* pProxyTextureManager;
+namespace MobileGL::MG_Impl::GLImpl::TextureImpl {
+    UniquePtr<ProxyTextureManager> pProxyTextureManager;
 
-        Bool IsProxyTextureTarget(TextureUploadTarget target) {
-            switch (target) {
-            case TextureUploadTarget::ProxyCubeMap:
-            case TextureUploadTarget::ProxyTexture1DArray:
-            case TextureUploadTarget::ProxyTexture2DArray:
-            case TextureUploadTarget::ProxyTexture1D:
-            case TextureUploadTarget::ProxyTexture2D:
-            case TextureUploadTarget::ProxyTexture3D:
-            case TextureUploadTarget::ProxyTexture2DMultisample:
-            case TextureUploadTarget::ProxyTexture2DMultisampleArray:
-            case TextureUploadTarget::ProxyTextureRectangle:
-            case TextureUploadTarget::ProxyCubeMapArray:
-                return true;
-            default:
-                return false;
-            }
+    Bool IsProxyTextureTarget(TextureUploadTarget target) {
+        switch (target) {
+        case TextureUploadTarget::ProxyCubeMap:
+        case TextureUploadTarget::ProxyTexture1DArray:
+        case TextureUploadTarget::ProxyTexture2DArray:
+        case TextureUploadTarget::ProxyTexture1D:
+        case TextureUploadTarget::ProxyTexture2D:
+        case TextureUploadTarget::ProxyTexture3D:
+        case TextureUploadTarget::ProxyTexture2DMultisample:
+        case TextureUploadTarget::ProxyTexture2DMultisampleArray:
+        case TextureUploadTarget::ProxyTextureRectangle:
+        case TextureUploadTarget::ProxyCubeMapArray:
+            return true;
+        default:
+            return false;
         }
+    }
 
-        SharedPtr<MG_State::GLState::ITextureObject> ProxyTextureManager::CreateOrReplaceProxyTextureObject(
-            TextureUploadTarget target) {
-            auto it = m_proxyTexturesMap.find(target);
-            if (it != m_proxyTexturesMap.end()) {
-                m_proxyTexturesMap.erase(it);
-            }
-            m_proxyTexturesMap[target] = MakeShared<MG_State::GLState::TextureObject2D>(0);
-            return m_proxyTexturesMap[target];
+    const SharedPtr<MG_State::GLState::ITextureObject>& ProxyTextureManager::CreateOrReplaceProxyTextureObject(
+        TextureUploadTarget target) {
+        auto it = m_proxyTexturesMap.find(target);
+        if (it != m_proxyTexturesMap.end()) {
+            m_proxyTexturesMap.erase(it);
         }
+        auto& obj = m_proxyTexturesMap[target];
+        obj = MakeShared<MG_State::GLState::TextureObject2D>(0);
+        return obj;
+    }
 
-        SharedPtr<MG_State::GLState::ITextureObject> ProxyTextureManager::GetProxyTextureObject(
-            TextureUploadTarget target) {
-            auto it = m_proxyTexturesMap.find(target);
-            if (it != m_proxyTexturesMap.end()) {
-                return it->second;
-            }
-            return nullptr;
+    const SharedPtr<MG_State::GLState::ITextureObject>& ProxyTextureManager::GetProxyTextureObject(
+        TextureUploadTarget target) {
+        auto it = m_proxyTexturesMap.find(target);
+        if (it != m_proxyTexturesMap.end()) {
+            return it->second;
         }
-    } // namespace TextureImpl
-} // namespace MobileGL::MG_Impl::GLImpl
+        static SharedPtr<MG_State::GLState::ITextureObject> nullTextureObject = nullptr;
+        return nullTextureObject;
+    }
+} // namespace MobileGL::MG_Impl::GLImpl::TextureImpl

MobileGL/MG_Impl/GLImpl/Texture/ProxyTexture.h

@@ -10,19 +10,18 @@
 #include <Includes.h>
 #include <MG_State/GLState/Core.h>
 
-namespace MobileGL::MG_Impl::GLImpl {
-    namespace TextureImpl {
-        Bool IsProxyTextureTarget(TextureUploadTarget target);
+namespace MobileGL::MG_Impl::GLImpl::TextureImpl {
+    Bool IsProxyTextureTarget(TextureUploadTarget target);
 
-        class ProxyTextureManager {
-        public:
-            SharedPtr<MG_State::GLState::ITextureObject> CreateOrReplaceProxyTextureObject(TextureUploadTarget target);
-            SharedPtr<MG_State::GLState::ITextureObject> GetProxyTextureObject(TextureUploadTarget target);
+    class ProxyTextureManager {
+    public:
+        const SharedPtr<MG_State::GLState::ITextureObject>& CreateOrReplaceProxyTextureObject(
+            TextureUploadTarget target);
+        const SharedPtr<MG_State::GLState::ITextureObject>& GetProxyTextureObject(TextureUploadTarget target);
 
-        private:
-            UnorderedMap<TextureUploadTarget, SharedPtr<MG_State::GLState::ITextureObject>> m_proxyTexturesMap;
-        };
+    private:
+        UnorderedMap<TextureUploadTarget, SharedPtr<MG_State::GLState::ITextureObject>> m_proxyTexturesMap;
+    };
 
-        extern ProxyTextureManager* pProxyTextureManager;
-    } // namespace TextureImpl
-} // namespace MobileGL::MG_Impl::GLImpl
+    extern UniquePtr<ProxyTextureManager> pProxyTextureManager;
+} // namespace MobileGL::MG_Impl::GLImpl::TextureImpl

MobileGL/MG_Impl/GLImpl/Texture/Validators.cpp

@@ -15,309 +15,295 @@
 #include <MG_Util/Converters/MGToMG/TextureEnumConverter.h>
 #include <MG_Util/Converters/MGToStr/TextureEnumConverter.h>
 
-namespace MobileGL::MG_Impl::GLImpl {
-    namespace TextureImpl {
-        Bool ValidateTextureTarget(TextureTarget target) {
-            if (target == TextureTarget::Unknown) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidEnum,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureTarget", "Invalid texture target"));
-                return false;
-            }
-            return true;
+namespace MobileGL::MG_Impl::GLImpl::TextureImpl {
+    Bool ValidateTextureTarget(TextureTarget target) {
+        if (target == TextureTarget::Unknown) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidEnum,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureTarget", "Invalid texture target"));
+            return false;
+        }
+        return true;
+    }
+
+    Bool ValidateTextureUploadTarget(TextureUploadTarget textureUploadTarget) {
+        if (textureUploadTarget == TextureUploadTarget::Unknown) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidEnum, MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureUploadTarget",
+                                                                     "Invalid texture upload target"));
+            return false;
+        }
+        return true;
+    }
+
+    Bool ValidateTextureName(Uint texture, Bool allowZero) {
+        if (texture == 0) {
+            if (allowZero) return true;
+
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidValue,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureName", "Texture name cannot be zero"));
+            return false;
         }
 
-        Bool ValidateTextureUploadTarget(TextureUploadTarget textureUploadTarget) {
-            if (textureUploadTarget == TextureUploadTarget::Unknown) {
-                MG_State::pGLContext->RecordError(ErrorCode::InvalidEnum,
-                                                  MakeShared<GenericErrorInfo>("MG_Impl/GLImpl",
-                                                                               "ValidateTextureUploadTarget",
-                                                                               "Invalid texture upload target"));
-                return false;
-            }
-            return true;
+        if (!MG_State::pGLContext->ValidateTextureName(texture)) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidValue,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureName", "Invalid texture name"));
+            return false;
+        }
+        return true;
+    }
+
+    Bool ValidateTextureInputFormat(TextureInputFormat format) {
+        if (format == TextureInputFormat::Unknown) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidEnum, MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureInputFormat",
+                                                                     "Invalid texture input format"));
+            return false;
+        }
+        return true;
+    }
+
+    Bool ValidateTexturePixelDataType(TexturePixelDataType texturePixelDataType) {
+        if (texturePixelDataType == TexturePixelDataType::Unknown) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidEnum, MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTexturePixelDataType",
+                                                                     "Invalid texture pixel data type"));
+            return false;
+        }
+        return true;
+    }
+
+    Bool ValidateTextureLevelNumber(GLint level) {
+        if (level < 0) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidValue, MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureLevelNumber",
+                                                                      "Texture level must be non-negative"));
+            return false;
         }
 
-        Bool ValidateTextureName(Uint texture, Bool allowZero) {
-            if (texture == 0) {
-                if (allowZero) return true;
+        // TODO: GL_INVALID_VALUE may be generated if level is greater than log2(max), where max is the returned
+        // value of GL_MAX_TEXTURE_SIZE.
 
-                MG_State::pGLContext->RecordError(ErrorCode::InvalidValue,
-                                                  MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureName",
-                                                                               "Texture name cannot be zero"));
-                return false;
-            }
+        return true;
+    }
 
-            if (!MG_State::pGLContext->ValidateTextureName(texture)) {
+    Bool ValidateTextureSizeWithTextureUploadTarget(TextureUploadTarget target, GLsizei width, GLsizei height) {
+        if (target == TextureUploadTarget::CubeMapPositiveX || target == TextureUploadTarget::CubeMapNegativeX ||
+            target == TextureUploadTarget::CubeMapPositiveY || target == TextureUploadTarget::CubeMapNegativeY ||
+            target == TextureUploadTarget::CubeMapPositiveZ || target == TextureUploadTarget::CubeMapNegativeZ) {
+            if (width != height) {
                 MG_State::pGLContext->RecordError(
                     ErrorCode::InvalidValue,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureName", "Invalid texture name"));
+                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureSizeWithTarget",
+                                                 "Width and height must be equal for cube map textures"));
                 return false;
             }
-            return true;
         }
 
-        Bool ValidateTextureInputFormat(TextureInputFormat format) {
-            if (format == TextureInputFormat::Unknown) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidEnum, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureInputFormat",
-                                                                         "Invalid texture input format"));
-                return false;
-            }
-            return true;
-        }
-
-        Bool ValidateTexturePixelDataType(TexturePixelDataType texturePixelDataType) {
-            if (texturePixelDataType == TexturePixelDataType::Unknown) {
-                MG_State::pGLContext->RecordError(ErrorCode::InvalidEnum,
-                                                  MakeShared<GenericErrorInfo>("MG_Impl/GLImpl",
-                                                                               "ValidateTexturePixelDataType",
-                                                                               "Invalid texture pixel data type"));
-                return false;
-            }
-            return true;
-        }
-
-        Bool ValidateTextureLevelNumber(GLint level) {
-            if (level < 0) {
-                MG_State::pGLContext->RecordError(ErrorCode::InvalidValue,
-                                                  MakeShared<GenericErrorInfo>("MG_Impl/GLImpl",
-                                                                               "ValidateTextureLevelNumber",
-                                                                               "Texture level must be non-negative"));
-                return false;
-            }
-
-            // TODO: GL_INVALID_VALUE may be generated if level is greater than log2(max), where max is the returned
-            // value of GL_MAX_TEXTURE_SIZE.
-
-            return true;
-        }
-
-        Bool ValidateTextureSizeWithTextureUploadTarget(TextureUploadTarget target, GLsizei width, GLsizei height) {
-            if (target == TextureUploadTarget::CubeMapPositiveX || target == TextureUploadTarget::CubeMapNegativeX ||
-                target == TextureUploadTarget::CubeMapPositiveY || target == TextureUploadTarget::CubeMapNegativeY ||
-                target == TextureUploadTarget::CubeMapPositiveZ || target == TextureUploadTarget::CubeMapNegativeZ) {
-                if (width != height) {
-                    MG_State::pGLContext->RecordError(
-                        ErrorCode::InvalidValue,
-                        MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureSizeWithTarget",
-                                                     "Width and height must be equal for cube map textures"));
-                    return false;
-                }
-            }
-
-            if (!(target == TextureUploadTarget::Texture1DArray ||
-                  target == TextureUploadTarget::ProxyTexture1DArray)) {
-                if (height < 0) {
-                    MG_State::pGLContext->RecordError(
-                        ErrorCode::InvalidValue,
-                        MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureSizeWithTarget",
-                                                     "Height must be greater than or equal to zero"));
-                    return false;
-                }
-                // TODO: GL_INVALID_VALUE is generated if target is not GL_TEXTURE_1D_ARRAY or GL_PROXY_TEXTURE_1D_ARRAY
-                // and height is greater than GL_MAX_TEXTURE_SIZE.
-            }
-
-            if (target == TextureUploadTarget::Texture1DArray || target == TextureUploadTarget::ProxyTexture1DArray) {
-                if (height < 0) {
-                    MG_State::pGLContext->RecordError(
-                        ErrorCode::InvalidValue,
-                        MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureSizeWithTarget",
-                                                     "Height must be greater than or equal to zero"));
-                    return false;
-                }
-                // TODO: GL_INVALID_VALUE is generated if target is GL_TEXTURE_1D_ARRAY or GL_PROXY_TEXTURE_1D_ARRAY and
-                // height is greater than GL_MAX_ARRAY_TEXTURE_LAYERS.
-            }
-
-            return true;
-        }
-
-        Bool ValidateTextureSizeRange(SizeT width, SizeT height, SizeT depth) {
-            if (width < 0 || height < 0 || depth < 0) {
+        if (!(target == TextureUploadTarget::Texture1DArray || target == TextureUploadTarget::ProxyTexture1DArray)) {
+            if (height < 0) {
                 MG_State::pGLContext->RecordError(
                     ErrorCode::InvalidValue,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureSizeRange",
-                                                 "Width and height must be greater than zero"));
+                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureSizeWithTarget",
+                                                 "Height must be greater than or equal to zero"));
                 return false;
             }
-
-            // TODO: GL_INVALID_VALUE is generated if width is greater than GL_MAX_TEXTURE_SIZE.
-
-            return true;
+            // TODO: GL_INVALID_VALUE is generated if target is not GL_TEXTURE_1D_ARRAY or GL_PROXY_TEXTURE_1D_ARRAY
+            // and height is greater than GL_MAX_TEXTURE_SIZE.
         }
 
-        Bool ValidateTextureInternalFormat(TextureInternalFormat format) {
-            if (format == TextureInternalFormat::Unknown) {
+        if (target == TextureUploadTarget::Texture1DArray || target == TextureUploadTarget::ProxyTexture1DArray) {
+            if (height < 0) {
                 MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidEnum,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureInternalFormat",
-                                                 "Invalid texture sized internal format"));
+                    ErrorCode::InvalidValue,
+                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureSizeWithTarget",
+                                                 "Height must be greater than or equal to zero"));
                 return false;
             }
-            return true;
+            // TODO: GL_INVALID_VALUE is generated if target is GL_TEXTURE_1D_ARRAY or GL_PROXY_TEXTURE_1D_ARRAY and
+            // height is greater than GL_MAX_ARRAY_TEXTURE_LAYERS.
         }
 
-        Bool ValidateTextureBorderNumber(Int border) {
-            if (border != 0) {
-                MG_State::pGLContext->RecordError(ErrorCode::InvalidValue,
-                                                  MakeShared<GenericErrorInfo>("MG_Impl/GLImpl",
-                                                                               "ValidateTextureBorderNumber",
-                                                                               "Border must be zero"));
-                return false;
-            }
-            return true;
+        return true;
+    }
+
+    Bool ValidateTextureSizeRange(SizeT width, SizeT height, SizeT depth) {
+        if (width < 0 || height < 0 || depth < 0) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidValue, MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureSizeRange",
+                                                                      "Width and height must be greater than zero"));
+            return false;
         }
 
-        Bool ValidateTextureInternalFormatCompatibleWithInput(TextureInputFormat format,
-                                                              TextureInternalFormat internalFormat,
-                                                              TexturePixelDataType type) {
-            if (type == TexturePixelDataType::UnsignedByte332 || type == TexturePixelDataType::UnsignedByte233Rev ||
-                type == TexturePixelDataType::UnsignedShort565 || type == TexturePixelDataType::UnsignedShort565Rev ||
-                type == TexturePixelDataType::UnsignedInt101111Rev) {
-                if (format != TextureInputFormat::RGB) {
-                    MG_State::pGLContext->RecordError(
-                        ErrorCode::InvalidOperation,
-                        MakeShared<GenericErrorInfo>("MG_Impl/GLImpl",
-                                                     "ValidateTextureInternalFormatCompatibleWithInput",
-                                                     "Invalid format for the given type"));
-                    return false;
-                }
-            }
+        // TODO: GL_INVALID_VALUE is generated if width is greater than GL_MAX_TEXTURE_SIZE.
 
-            if (type == TexturePixelDataType::UnsignedShort4444 || type == TexturePixelDataType::UnsignedShort4444Rev ||
-                type == TexturePixelDataType::UnsignedShort5551 || type == TexturePixelDataType::UnsignedShort1555Rev ||
-                type == TexturePixelDataType::UnsignedInt8888 || type == TexturePixelDataType::UnsignedInt8888Rev ||
-                type == TexturePixelDataType::UnsignedInt1010102 ||
-                type == TexturePixelDataType::UnsignedInt2101010Rev ||
-                type == TexturePixelDataType::UnsignedInt5999Rev) {
-                if (format != TextureInputFormat::RGBA && format != TextureInputFormat::BGRA) {
-                    MG_State::pGLContext->RecordError(
-                        ErrorCode::InvalidOperation,
-                        MakeShared<GenericErrorInfo>("MG_Impl/GLImpl",
-                                                     "ValidateTextureInternalFormatCompatibleWithInput",
-                                                     "Invalid format for the given type"));
-                    return false;
-                }
-            }
+        return true;
+    }
 
-            if (internalFormat == TextureInternalFormat::DepthComponent ||
-                internalFormat == TextureInternalFormat::DepthComponent16 ||
-                internalFormat == TextureInternalFormat::DepthComponent24 ||
-                internalFormat == TextureInternalFormat::DepthComponent32F) {
-                if (format != TextureInputFormat::DepthComponent) {
-                    MG_State::pGLContext->RecordError(
-                        ErrorCode::InvalidOperation,
-                        MakeShared<GenericErrorInfo>("MG_Impl/GLImpl",
-                                                     "ValidateTextureInternalFormatCompatibleWithInput",
-                                                     "Invalid format for depth component internal format"));
-                    return false;
-                }
-            }
+    Bool ValidateTextureInternalFormat(TextureInternalFormat format) {
+        if (format == TextureInternalFormat::Unknown) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidEnum, MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureInternalFormat",
+                                                                     "Invalid texture sized internal format"));
+            return false;
+        }
+        return true;
+    }
 
-            if (format == TextureInputFormat::DepthComponent &&
-                (internalFormat != TextureInternalFormat::DepthComponent &&
-                 internalFormat != TextureInternalFormat::DepthComponent16 &&
-                 internalFormat != TextureInternalFormat::DepthComponent24 &&
-                 internalFormat != TextureInternalFormat::DepthComponent32F &&
-                 internalFormat != TextureInternalFormat::DepthComponent32 // workaround for Minecraft 1.21.5+
-                 )) {
+    Bool ValidateTextureBorderNumber(Int border) {
+        if (border != 0) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidValue,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureBorderNumber", "Border must be zero"));
+            return false;
+        }
+        return true;
+    }
+
+    Bool ValidateTextureInternalFormatCompatibleWithInput(TextureInputFormat format,
+                                                          TextureInternalFormat internalFormat,
+                                                          TexturePixelDataType type) {
+        if (type == TexturePixelDataType::UnsignedByte332 || type == TexturePixelDataType::UnsignedByte233Rev ||
+            type == TexturePixelDataType::UnsignedShort565 || type == TexturePixelDataType::UnsignedShort565Rev ||
+            type == TexturePixelDataType::UnsignedInt101111Rev) {
+            if (format != TextureInputFormat::RGB) {
                 MG_State::pGLContext->RecordError(
                     ErrorCode::InvalidOperation,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureInternalFormatCompatibleWithInput",
-                                                 "Invalid internal format for depth component format"));
+                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureInternalFormatCompatibleWithInput",
+                                                 "Invalid format for the given type"));
                 return false;
             }
-            return true;
         }
 
-        Bool ValidateTextureLevelWithUploadTarget(TextureUploadTarget target, Int level) {
-            if (target == TextureUploadTarget::TextureRectangle ||
-                target == TextureUploadTarget::ProxyTextureRectangle) {
-                if (level != 0) {
-                    MG_State::pGLContext->RecordError(
-                        ErrorCode::InvalidValue,
-                        MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureLevelWithUploadTarget",
-                                                     "Level must be zero for rectangle textures"));
-                    return false;
-                }
-            }
-            return true;
-        }
-
-        Bool ValidateTextureObject(SharedPtr<MG_State::GLState::ITextureObject> textureObject) {
-            if (!textureObject) {
+        if (type == TexturePixelDataType::UnsignedShort4444 || type == TexturePixelDataType::UnsignedShort4444Rev ||
+            type == TexturePixelDataType::UnsignedShort5551 || type == TexturePixelDataType::UnsignedShort1555Rev ||
+            type == TexturePixelDataType::UnsignedInt8888 || type == TexturePixelDataType::UnsignedInt8888Rev ||
+            type == TexturePixelDataType::UnsignedInt1010102 || type == TexturePixelDataType::UnsignedInt2101010Rev ||
+            type == TexturePixelDataType::UnsignedInt5999Rev) {
+            if (format != TextureInputFormat::RGBA && format != TextureInputFormat::BGRA) {
                 MG_State::pGLContext->RecordError(
                     ErrorCode::InvalidOperation,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureObject", "Texture object is null"));
+                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureInternalFormatCompatibleWithInput",
+                                                 "Invalid format for the given type"));
                 return false;
             }
-            return true;
         }
 
-        Bool ValidateTextureTargetUniformity(SharedPtr<MG_State::GLState::ITextureObject> textureObject,
-                                             TextureTarget target) {
-            if (!textureObject) return true; // should be created later
-            TextureTarget prevTarget = textureObject->GetTarget();
-            if (prevTarget != target) {
+        if (internalFormat == TextureInternalFormat::DepthComponent ||
+            internalFormat == TextureInternalFormat::DepthComponent16 ||
+            internalFormat == TextureInternalFormat::DepthComponent24 ||
+            internalFormat == TextureInternalFormat::DepthComponent32F) {
+            if (format != TextureInputFormat::DepthComponent) {
                 MG_State::pGLContext->RecordError(
                     ErrorCode::InvalidOperation,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureTargetUniformity",
-                                                 "Texture target does not match the previously created texture"));
+                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureInternalFormatCompatibleWithInput",
+                                                 "Invalid format for depth component internal format"));
                 return false;
             }
-            return true;
         }
 
-        Bool ValidateTextureSubImageOffsets(SharedPtr<MG_State::GLState::ITextureObject> textureObject, Int xoffset,
-                                            Int width, Int yoffset, Int height, Int zoffset, Int depth) {
-            auto baseSize = textureObject->GetBaseSize();
-            if (xoffset < 0 || (xoffset + width) > baseSize.x()) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureSubImageOffsets",
-                                                 "xoffset must be non-negative and (xoffset + width) must not exceed "
-                                                 "the texture width."));
-                return false;
-            }
-            if (baseSize.y() == 0) return true;
-
-            if (yoffset < 0 || (yoffset + height) > baseSize.y()) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureSubImageOffsets",
-                                                 "yoffset must be non-negative and (yoffset + height) must not exceed "
-                                                 "the texture height."));
-                return false;
-            }
-            if (baseSize.z() == 0) return true;
-
-            if (zoffset < 0 || (zoffset + depth) > baseSize.z()) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureSubImageOffsets",
-                                                 "zoffset must be non-negative and (zoffset + depth) must not exceed "
-                                                 "the texture depth."));
-                return false;
-            }
-            return true;
+        if (format == TextureInputFormat::DepthComponent &&
+            (internalFormat != TextureInternalFormat::DepthComponent &&
+             internalFormat != TextureInternalFormat::DepthComponent16 &&
+             internalFormat != TextureInternalFormat::DepthComponent24 &&
+             internalFormat != TextureInternalFormat::DepthComponent32F &&
+             internalFormat != TextureInternalFormat::DepthComponent32 // workaround for Minecraft 1.21.5+
+             )) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidOperation,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureInternalFormatCompatibleWithInput",
+                                             "Invalid internal format for depth component format"));
+            return false;
         }
+        return true;
+    }
 
-        Bool ValidateBaseInternalFormatMatch(TextureInternalFormat format1, TextureInternalFormat format2) {
-            auto unsizedFormat1 = MG_Util::ConvertInternalFormatToUnsized(format1);
-            auto unsizedFormat2 = MG_Util::ConvertInternalFormatToUnsized(format2);
-            if (unsizedFormat1 != unsizedFormat2) {
+    Bool ValidateTextureLevelWithUploadTarget(TextureUploadTarget target, Int level) {
+        if (target == TextureUploadTarget::TextureRectangle || target == TextureUploadTarget::ProxyTextureRectangle) {
+            if (level != 0) {
                 MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidOperation,
-                    MakeShared<GenericErrorInfo>(
-                        std::format("MG_Impl/GLImpl", "ValidateBaseInternalFormatMatch",
-                                    "The base internal format of the two formats do not match ({} vs. {})",
-                                    MG_Util::ConvertTextureInternalFormatToString(unsizedFormat1).c_str(),
-                                    MG_Util::ConvertTextureInternalFormatToString(unsizedFormat2).c_str())));
+                    ErrorCode::InvalidValue,
+                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureLevelWithUploadTarget",
+                                                 "Level must be zero for rectangle textures"));
                 return false;
             }
-            return true;
-        } // namespace TextureImpl
+        }
+        return true;
+    }
+
+    Bool ValidateTextureObject(SharedPtr<MG_State::GLState::ITextureObject> textureObject) {
+        if (!textureObject) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidOperation,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureObject", "Texture object is null"));
+            return false;
+        }
+        return true;
+    }
+
+    Bool ValidateTextureTargetUniformity(SharedPtr<MG_State::GLState::ITextureObject> textureObject,
+                                         TextureTarget target) {
+        if (!textureObject) return true; // should be created later
+        TextureTarget prevTarget = textureObject->GetTarget();
+        if (prevTarget != target) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidOperation,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureTargetUniformity",
+                                             "Texture target does not match the previously created texture"));
+            return false;
+        }
+        return true;
+    }
+
+    Bool ValidateTextureSubImageOffsets(SharedPtr<MG_State::GLState::ITextureObject> textureObject, Int xoffset,
+                                        Int width, Int yoffset, Int height, Int zoffset, Int depth) {
+        auto baseSize = textureObject->GetBaseSize();
+        if (xoffset < 0 || (xoffset + width) > baseSize.x()) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidValue,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureSubImageOffsets",
+                                             "xoffset must be non-negative and (xoffset + width) must not exceed "
+                                             "the texture width."));
+            return false;
+        }
+        if (baseSize.y() == 0) return true;
+
+        if (yoffset < 0 || (yoffset + height) > baseSize.y()) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidValue,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureSubImageOffsets",
+                                             "yoffset must be non-negative and (yoffset + height) must not exceed "
+                                             "the texture height."));
+            return false;
+        }
+        if (baseSize.z() == 0) return true;
+
+        if (zoffset < 0 || (zoffset + depth) > baseSize.z()) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidValue,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateTextureSubImageOffsets",
+                                             "zoffset must be non-negative and (zoffset + depth) must not exceed "
+                                             "the texture depth."));
+            return false;
+        }
+        return true;
+    }
+
+    Bool ValidateBaseInternalFormatMatch(TextureInternalFormat format1, TextureInternalFormat format2) {
+        auto unsizedFormat1 = MG_Util::ConvertInternalFormatToUnsized(format1);
+        auto unsizedFormat2 = MG_Util::ConvertInternalFormatToUnsized(format2);
+        if (unsizedFormat1 != unsizedFormat2) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidOperation,
+                MakeUnique<GenericErrorInfo>(
+                    std::format("MG_Impl/GLImpl", "ValidateBaseInternalFormatMatch",
+                                "The base internal format of the two formats do not match ({} vs. {})",
+                                MG_Util::ConvertTextureInternalFormatToString(unsizedFormat1).c_str(),
+                                MG_Util::ConvertTextureInternalFormatToString(unsizedFormat2).c_str())));
+            return false;
+        }
+        return true;
     } // namespace TextureImpl
-} // namespace MobileGL::MG_Impl::GLImpl
+} // namespace MobileGL::MG_Impl::GLImpl::TextureImpl

MobileGL/MG_Impl/GLImpl/Texture/Validators.h

@@ -12,27 +12,25 @@
 #include <Includes.h>
 #include <MG_State/GLState/TextureState/TextureObject.h>
 
-namespace MobileGL::MG_Impl::GLImpl {
-    namespace TextureImpl {
-        Bool ValidateTextureTarget(TextureTarget target);
-        Bool ValidateTextureUploadTarget(TextureUploadTarget textureUploadTarget);
-        Bool ValidateTextureName(Uint texture, Bool allowZero = false);
-        Bool ValidateTextureInputFormat(TextureInputFormat format);
-        Bool ValidateTexturePixelDataType(TexturePixelDataType texturePixelDataType);
-        Bool ValidateTextureLevelNumber(Int level);
-        Bool ValidateTextureSizeWithTextureUploadTarget(TextureUploadTarget target, GLsizei width, GLsizei height);
-        Bool ValidateTextureSizeRange(SizeT width, SizeT height, SizeT depth);
-        Bool ValidateTextureInternalFormat(TextureInternalFormat format);
-        Bool ValidateTextureBorderNumber(Int border);
-        Bool ValidateTextureInternalFormatCompatibleWithInput(TextureInputFormat format,
-                                                              TextureInternalFormat internalFormat,
-                                                              TexturePixelDataType type);
-        Bool ValidateTextureLevelWithUploadTarget(TextureUploadTarget target, Int level);
-        Bool ValidateTextureObject(SharedPtr<MG_State::GLState::ITextureObject> textureObject);
-        Bool ValidateTextureTargetUniformity(SharedPtr<MG_State::GLState::ITextureObject> textureObject,
-                                             TextureTarget target);
-        Bool ValidateTextureSubImageOffsets(SharedPtr<MG_State::GLState::ITextureObject> textureObject, Int xoffset,
-                                            Int width, Int yoffset = 0, Int height = 0, Int zoffset = 0, Int depth = 0);
-        Bool ValidateBaseInternalFormatMatch(TextureInternalFormat format1, TextureInternalFormat format2);
-    } // namespace TextureImpl
-} // namespace MobileGL::MG_Impl::GLImpl
+namespace MobileGL::MG_Impl::GLImpl::TextureImpl {
+    Bool ValidateTextureTarget(TextureTarget target);
+    Bool ValidateTextureUploadTarget(TextureUploadTarget textureUploadTarget);
+    Bool ValidateTextureName(Uint texture, Bool allowZero = false);
+    Bool ValidateTextureInputFormat(TextureInputFormat format);
+    Bool ValidateTexturePixelDataType(TexturePixelDataType texturePixelDataType);
+    Bool ValidateTextureLevelNumber(Int level);
+    Bool ValidateTextureSizeWithTextureUploadTarget(TextureUploadTarget target, GLsizei width, GLsizei height);
+    Bool ValidateTextureSizeRange(SizeT width, SizeT height, SizeT depth);
+    Bool ValidateTextureInternalFormat(TextureInternalFormat format);
+    Bool ValidateTextureBorderNumber(Int border);
+    Bool ValidateTextureInternalFormatCompatibleWithInput(TextureInputFormat format,
+                                                          TextureInternalFormat internalFormat,
+                                                          TexturePixelDataType type);
+    Bool ValidateTextureLevelWithUploadTarget(TextureUploadTarget target, Int level);
+    Bool ValidateTextureObject(SharedPtr<MG_State::GLState::ITextureObject> textureObject);
+    Bool ValidateTextureTargetUniformity(SharedPtr<MG_State::GLState::ITextureObject> textureObject,
+                                         TextureTarget target);
+    Bool ValidateTextureSubImageOffsets(SharedPtr<MG_State::GLState::ITextureObject> textureObject, Int xoffset,
+                                        Int width, Int yoffset = 0, Int height = 0, Int zoffset = 0, Int depth = 0);
+    Bool ValidateBaseInternalFormatMatch(TextureInternalFormat format1, TextureInternalFormat format2);
+} // namespace MobileGL::MG_Impl::GLImpl::TextureImpl

MobileGL/MG_Impl/GLImpl/VertexArray/GL_VertexArray.cpp

@@ -12,222 +12,216 @@
 #include <MG_State/GLState/ErrorState/Error.h>
 #include <MG_Util/Converters/GLToMG/DataTypeConverter.h>
 
-namespace MobileGL {
-    namespace MG_Impl::GLImpl {
-        void DisableVertexAttribArray_State(GLuint index) {
-            if (!VertexArrayImpl::ValidateVertexAttributeIndex(index)) return;
+namespace MobileGL::MG_Impl::GLImpl {
+    void DisableVertexAttribArray_State(GLuint index) {
+        if (!VertexArrayImpl::ValidateVertexAttributeIndex(index)) return;
 
-            auto vao = MG_State::pGLContext->GetBoundVertexArray();
-            if (!vao) {
-                MG_State::pGLContext->RecordError(ErrorCode::InvalidOperation,
-                                                  MakeShared<GenericErrorInfo>("MG_Impl/GLImpl",
-                                                                               "EnableVertexAttribArray_State",
-                                                                               "No vertex array object is bound."));
-                return;
-            }
-
-            vao->DisableAttribute(index);
+        auto& vao = MG_State::pGLContext->GetBoundVertexArray();
+        if (!vao) {
+            MG_State::pGLContext->RecordError(ErrorCode::InvalidOperation,
+                                              MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl",
+                                                                           "EnableVertexAttribArray_State",
+                                                                           "No vertex array object is bound."));
+            return;
         }
 
-        void EnableVertexAttribArray_State(GLuint index) {
-            if (!VertexArrayImpl::ValidateVertexAttributeIndex(index)) return;
+        vao->DisableAttribute(index);
+    }
 
-            auto vao = MG_State::pGLContext->GetBoundVertexArray();
-            if (!vao) {
-                MG_State::pGLContext->RecordError(ErrorCode::InvalidOperation,
-                                                  MakeShared<GenericErrorInfo>("MG_Impl/GLImpl",
-                                                                               "EnableVertexAttribArray_State",
-                                                                               "No vertex array object is bound."));
-                return;
-            }
+    void EnableVertexAttribArray_State(GLuint index) {
+        if (!VertexArrayImpl::ValidateVertexAttributeIndex(index)) return;
 
-            vao->EnableAttribute(index);
+        auto& vao = MG_State::pGLContext->GetBoundVertexArray();
+        if (!vao) {
+            MG_State::pGLContext->RecordError(ErrorCode::InvalidOperation,
+                                              MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl",
+                                                                           "EnableVertexAttribArray_State",
+                                                                           "No vertex array object is bound."));
+            return;
         }
 
-        // TODO: implement GL_BGRA support
-        void VertexAttribIPointer_State(GLuint index, GLint size, GLenum type, GLsizei stride, const void* pointer) {
-            if (!VertexArrayImpl::ValidateVertexAttributeIndex(index)) return;
+        vao->EnableAttribute(index);
+    }
 
-            DataType dataType = MG_Util::ConvertGLEnumToDataType(type);
-            if (!VertexArrayImpl::ValidateVertexAttribPointerParams(index, size, dataType, stride)) return;
+    // TODO: implement GL_BGRA support
+    void VertexAttribIPointer_State(GLuint index, GLint size, GLenum type, GLsizei stride, const void* pointer) {
+        if (!VertexArrayImpl::ValidateVertexAttributeIndex(index)) return;
 
-            auto vao = MG_State::pGLContext->GetBoundVertexArray();
-            if (!vao) {
-                MG_State::pGLContext->RecordError(ErrorCode::InvalidOperation,
-                                                  MakeShared<GenericErrorInfo>("MG_Impl/GLImpl",
-                                                                               "VertexAttribPointer_State",
-                                                                               "No vertex array object is bound."));
-                return;
-            }
+        DataType dataType = MG_Util::ConvertGLEnumToDataType(type);
+        if (!VertexArrayImpl::ValidateVertexAttribPointerParams(index, size, dataType, stride)) return;
 
-            auto& vboSlot = MG_State::pGLContext->GetBufferBindingSlot(BufferTarget::Vertex);
-            auto vbo = vboSlot.GetBoundObject();
-            if (!vbo) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidOperation,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "VertexAttribPointer_State",
-                                                 "No buffer is bound to GL_ARRAY_BUFFER."));
-                return;
-            }
-
-            SizeT offset = reinterpret_cast<SizeT>(pointer);
-
-            vao->SetAttributeFormat(index, size, dataType, false, stride, offset, true);
-            vao->BindAttributeBuffer(index, vbo);
+        auto& vao = MG_State::pGLContext->GetBoundVertexArray();
+        if (!vao) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidOperation, MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "VertexAttribPointer_State",
+                                                                          "No vertex array object is bound."));
+            return;
         }
 
-        // TODO: implement GL_BGRA support
-        void VertexAttribPointer_State(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride,
-                                       const void* pointer) {
-            if (!VertexArrayImpl::ValidateVertexAttributeIndex(index)) return;
-
-            DataType dataType = MG_Util::ConvertGLEnumToDataType(type);
-            if (!VertexArrayImpl::ValidateVertexAttribPointerParams(index, size, dataType, stride)) return;
-
-            auto vao = MG_State::pGLContext->GetBoundVertexArray();
-            if (!vao) {
-                MG_State::pGLContext->RecordError(ErrorCode::InvalidOperation,
-                                                  MakeShared<GenericErrorInfo>("MG_Impl/GLImpl",
-                                                                               "VertexAttribPointer_State",
-                                                                               "No vertex array object is bound."));
-                return;
-            }
-
-            auto& vboSlot = MG_State::pGLContext->GetBufferBindingSlot(BufferTarget::Vertex);
-            auto vbo = vboSlot.GetBoundObject();
-            if (!vbo) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidOperation,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "VertexAttribPointer_State",
-                                                 "No buffer is bound to GL_ARRAY_BUFFER."));
-                return;
-            }
-
-            SizeT offset = reinterpret_cast<SizeT>(pointer);
-
-            vao->SetAttributeFormat(index, size, dataType, normalized, stride, offset, false);
-            vao->BindAttributeBuffer(index, vbo);
+        auto& vboSlot = MG_State::pGLContext->GetBufferBindingSlot(BufferTarget::Vertex);
+        auto& vbo = vboSlot.GetBoundObject();
+        if (!vbo) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidOperation, MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "VertexAttribPointer_State",
+                                                                          "No buffer is bound to GL_ARRAY_BUFFER."));
+            return;
         }
 
-        void BindVertexArray_State(GLuint array) {
-            if (array == 0) {
+        auto offset = reinterpret_cast<SizeT>(pointer);
+
+        vao->SetAttributeFormat(index, size, dataType, false, stride, offset, true);
+        vao->BindAttributeBuffer(index, vbo);
+    }
+
+    // TODO: implement GL_BGRA support
+    void VertexAttribPointer_State(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride,
+                                   const void* pointer) {
+        if (!VertexArrayImpl::ValidateVertexAttributeIndex(index)) return;
+
+        DataType dataType = MG_Util::ConvertGLEnumToDataType(type);
+        if (!VertexArrayImpl::ValidateVertexAttribPointerParams(index, size, dataType, stride)) return;
+
+        auto& vao = MG_State::pGLContext->GetBoundVertexArray();
+        if (!vao) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidOperation, MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "VertexAttribPointer_State",
+                                                                          "No vertex array object is bound."));
+            return;
+        }
+
+        auto& vboSlot = MG_State::pGLContext->GetBufferBindingSlot(BufferTarget::Vertex);
+        auto& vbo = vboSlot.GetBoundObject();
+        if (!vbo) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidOperation, MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "VertexAttribPointer_State",
+                                                                          "No buffer is bound to GL_ARRAY_BUFFER."));
+            return;
+        }
+
+        SizeT offset = reinterpret_cast<SizeT>(pointer);
+
+        vao->SetAttributeFormat(index, size, dataType, normalized, stride, offset, false);
+        vao->BindAttributeBuffer(index, vbo);
+    }
+
+    void BindVertexArray_State(GLuint array) {
+        if (array == 0) {
+            MG_State::pGLContext->BindVertexArray(0);
+            return;
+        }
+
+        if (!VertexArrayImpl::ValidateVertexArrayName(array)) return;
+
+        if (!MG_State::pGLContext->ValidateVertexArrayObject(array)) {
+            MG_State::pGLContext->CreateVertexArrayObject(array);
+        }
+
+        MG_State::pGLContext->BindVertexArray(array);
+    }
+
+    void DeleteVertexArrays_State(GLsizei n, const GLuint* arrays) {
+        if (n < 0) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidValue,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "DeleteVertexArrays_State", "n must be non-negative."));
+            return;
+        }
+
+        for (GLsizei i = 0; i < n; ++i) {
+            GLuint vao = arrays[i];
+            if (vao == 0) continue;
+
+            if (!VertexArrayImpl::ValidateVertexArrayName(vao)) continue;
+
+            if (MG_State::pGLContext->GetBoundVertexArray() &&
+                MG_State::pGLContext->GetBoundVertexArray() == MG_State::pGLContext->GetVertexArrayObject(vao)) {
                 MG_State::pGLContext->BindVertexArray(0);
-                return;
             }
 
-            if (!VertexArrayImpl::ValidateVertexArrayName(array)) return;
+            MG_State::pGLContext->MarkVertexArrayForDeletion(vao);
+        }
+    }
 
-            if (!MG_State::pGLContext->ValidateVertexArrayObject(array)) {
-                MG_State::pGLContext->CreateVertexArrayObject(array);
-            }
-
-            MG_State::pGLContext->BindVertexArray(array);
+    void GenVertexArrays_State(GLsizei n, GLuint* arrays) {
+        if (n < 0) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidValue,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "GenVertexArrays_State", "n must be non-negative."));
+            return;
         }
 
-        void DeleteVertexArrays_State(GLsizei n, const GLuint* arrays) {
-            if (n < 0) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "DeleteVertexArrays_State",
-                                                                          "n must be non-negative."));
-                return;
-            }
+        static thread_local Vector<Uint> vaos;
+        MG_State::pGLContext->GenVertexArrayNames(n, vaos);
+        Memcpy(arrays, vaos.data(), n * sizeof(GLuint));
+    }
 
-            for (GLsizei i = 0; i < n; ++i) {
-                GLuint vao = arrays[i];
-                if (vao == 0) continue;
+    GLboolean IsVertexArray_State(GLuint array) {
+        if (array == 0) {
+            MG_State::pGLContext->RecordError(ErrorCode::InvalidValue,
+                                              MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "IsVertexArray_State",
+                                                                           "Vertex array name 0 is not supported."));
+            return GL_FALSE;
+        }
+        if (!VertexArrayImpl::ValidateVertexArrayName(array)) return GL_FALSE;
+        if (!MG_State::pGLContext->ValidateVertexArrayObject(array)) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidOperation,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "IsVertexArray_State",
+                                             std::format("Vertex array object {} does not exist.", array)));
+            return GL_FALSE;
+        }
+        return GL_TRUE;
+    }
 
-                if (!VertexArrayImpl::ValidateVertexArrayName(vao)) continue;
+    void VertexAttribDivisor_State(GLuint index, GLuint divisor) {
+        if (!VertexArrayImpl::ValidateVertexAttributeIndex(index)) return;
 
-                if (MG_State::pGLContext->GetBoundVertexArray() &&
-                    MG_State::pGLContext->GetBoundVertexArray() == MG_State::pGLContext->GetVertexArrayObject(vao)) {
-                    MG_State::pGLContext->BindVertexArray(0);
-                }
-
-                MG_State::pGLContext->MarkVertexArrayForDeletion(vao);
-            }
+        auto& vao = MG_State::pGLContext->GetBoundVertexArray();
+        if (!vao) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidOperation, MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "VertexAttribDivisor_State",
+                                                                          "No vertex array object is bound."));
+            return;
         }
 
-        void GenVertexArrays_State(GLsizei n, GLuint* arrays) {
-            if (n < 0) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "GenVertexArrays_State", "n must be non-negative."));
-                return;
-            }
+        vao->SetAttributeDivisor(index, divisor);
+    }
 
-            auto vaoNames = MG_State::pGLContext->GenVertexArrayNames(n);
-            Copy(vaoNames.data(), arrays, vaoNames.size());
-        }
+    /* @INSERTION_POINT:FUNCTION_IMPLEMENTATION@ */
+    void VertexAttribDivisor(GLuint index, GLuint divisor) {
+        VertexAttribDivisor_State(index, divisor);
+    }
 
-        GLboolean IsVertexArray_State(GLuint array) {
-            if (array == 0) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "IsVertexArray_State",
-                                                                          "Vertex array name 0 is not supported."));
-                return GL_FALSE;
-            }
-            if (!VertexArrayImpl::ValidateVertexArrayName(array)) return GL_FALSE;
-            if (!MG_State::pGLContext->ValidateVertexArrayObject(array)) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidOperation,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "IsVertexArray_State",
-                                                 std::format("Vertex array object {} does not exist.", array)));
-                return GL_FALSE;
-            }
-            return GL_TRUE;
-        }
+    GLboolean IsVertexArray(GLuint array) {
+        return IsVertexArray_State(array);
+    }
 
-        void VertexAttribDivisor_State(GLuint index, GLuint divisor) {
-            if (!VertexArrayImpl::ValidateVertexAttributeIndex(index)) return;
+    void DisableVertexAttribArray(GLuint index) {
+        DisableVertexAttribArray_State(index);
+    }
 
-            auto vao = MG_State::pGLContext->GetBoundVertexArray();
-            if (!vao) {
-                MG_State::pGLContext->RecordError(ErrorCode::InvalidOperation,
-                                                  MakeShared<GenericErrorInfo>("MG_Impl/GLImpl",
-                                                                               "VertexAttribDivisor_State",
-                                                                               "No vertex array object is bound."));
-                return;
-            }
+    void EnableVertexAttribArray(GLuint index) {
+        EnableVertexAttribArray_State(index);
+    }
 
-            vao->SetAttributeDivisor(index, divisor);
-        }
+    void VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void* pointer) {
+        VertexAttribIPointer_State(index, size, type, stride, pointer);
+    }
 
-        /* @INSERTION_POINT:FUNCTION_IMPLEMENTATION@ */
-        void VertexAttribDivisor(GLuint index, GLuint divisor) {
-            VertexAttribDivisor_State(index, divisor);
-        }
+    void VertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride,
+                             const void* pointer) {
+        VertexAttribPointer_State(index, size, type, normalized, stride, pointer);
+    }
 
-        GLboolean IsVertexArray(GLuint array) {
-            return IsVertexArray_State(array);
-        }
+    void BindVertexArray(GLuint array) {
+        BindVertexArray_State(array);
+    }
 
-        void DisableVertexAttribArray(GLuint index) {
-            DisableVertexAttribArray_State(index);
-        }
+    void DeleteVertexArrays(GLsizei n, const GLuint* arrays) {
+        DeleteVertexArrays_State(n, arrays);
+    }
 
-        void EnableVertexAttribArray(GLuint index) {
-            EnableVertexAttribArray_State(index);
-        }
-
-        void VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void* pointer) {
-            VertexAttribIPointer_State(index, size, type, stride, pointer);
-        }
-
-        void VertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride,
-                                 const void* pointer) {
-            VertexAttribPointer_State(index, size, type, normalized, stride, pointer);
-        }
-
-        void BindVertexArray(GLuint array) {
-            BindVertexArray_State(array);
-        }
-
-        void DeleteVertexArrays(GLsizei n, const GLuint* arrays) {
-            DeleteVertexArrays_State(n, arrays);
-        }
-
-        void GenVertexArrays(GLsizei n, GLuint* arrays) {
-            GenVertexArrays_State(n, arrays);
-        }
-    } // namespace MG_Impl::GLImpl
-} // namespace MobileGL
+    void GenVertexArrays(GLsizei n, GLuint* arrays) {
+        GenVertexArrays_State(n, arrays);
+    }
+} // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/VertexArray/GL_VertexArray.h

@@ -9,18 +9,16 @@
 #pragma once
 #include <Includes.h>
 
-namespace MobileGL {
-    namespace MG_Impl::GLImpl {
-        /* @INSERTION_POINT:FUNCTION_DECLARATION@ */
-        void VertexAttribDivisor(GLuint index, GLuint divisor);
-        GLboolean IsVertexArray(GLuint array);
-        void DisableVertexAttribArray(GLuint index);
-        void EnableVertexAttribArray(GLuint index);
-        void VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void* pointer);
-        void VertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride,
-                                 const void* pointer);
-        void BindVertexArray(GLuint array);
-        void DeleteVertexArrays(GLsizei n, const GLuint* arrays);
-        void GenVertexArrays(GLsizei n, GLuint* arrays);
-    } // namespace MG_Impl::GLImpl
-} // namespace MobileGL
+namespace MobileGL::MG_Impl::GLImpl {
+    /* @INSERTION_POINT:FUNCTION_DECLARATION@ */
+    void VertexAttribDivisor(GLuint index, GLuint divisor);
+    GLboolean IsVertexArray(GLuint array);
+    void DisableVertexAttribArray(GLuint index);
+    void EnableVertexAttribArray(GLuint index);
+    void VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void* pointer);
+    void VertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride,
+                             const void* pointer);
+    void BindVertexArray(GLuint array);
+    void DeleteVertexArrays(GLsizei n, const GLuint* arrays);
+    void GenVertexArrays(GLsizei n, GLuint* arrays);
+} // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/VertexArray/Validators.cpp

@@ -12,74 +12,71 @@
 #include <MG_Util/Converters/MGToGL/DataTypeConverter.h>
 #include <MG_Util/Converters/MGToStr/DataTypeConverter.h>
 
-namespace MobileGL::MG_Impl::GLImpl {
-    namespace VertexArrayImpl {
+namespace MobileGL::MG_Impl::GLImpl::VertexArrayImpl {
+    Bool ValidateVertexArrayName(Uint index) {
+        Bool isValid = MG_State::pGLContext->ValidateVertexArrayName(index);
+        if (!isValid) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidOperation,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateVertexArrayName",
+                                             std::format("Vertex array name {} is not valid.", index)));
+            return false;
+        }
+        return true;
+    }
 
-        Bool ValidateVertexArrayName(Uint index) {
-            Bool isValid = MG_State::pGLContext->ValidateVertexArrayName(index);
-            if (!isValid) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidOperation,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateVertexArrayName",
-                                                 std::format("Vertex array name {} is not valid.", index)));
-                return false;
-            }
-            return true;
+    Bool ValidateVertexArrayObject(Uint index) {
+        if (!MG_State::pGLContext->ValidateVertexArrayObject(index)) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidOperation,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateVertexArrayObject",
+                                             std::format("Vertex array object {} does not exist.", index)));
+            return false;
+        }
+        return true;
+    }
+
+    Bool ValidateVertexAttributeIndex(Uint index) {
+        if (index >= MG_State::GLState::VertexArrayObject::MAX_VERTEX_ATTRIBS) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidValue,
+                MakeUnique<GenericErrorInfo>(
+                    "MG_Impl/GLImpl", "ValidateVertexAttributeIndex",
+                    std::format("Attribute index {} exceeds maximum of {}.", index,
+                                MG_State::GLState::VertexArrayObject::MAX_VERTEX_ATTRIBS - 1)));
+            return false;
+        }
+        return true;
+    }
+
+    Bool ValidateVertexAttribPointerParams(Uint index, SizeT size, DataType type, Int stride) {
+        if (size < 1 || size > 4) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidValue,
+                MakeUnique<GenericErrorInfo>(
+                    "MG_Impl/GLImpl", "ValidateVertexAttribPointerParams",
+                    std::format("Invalid size {} for attribute {}. Must be 1-4.", size, index)));
+            return false;
         }
 
-        Bool ValidateVertexArrayObject(Uint index) {
-            if (!MG_State::pGLContext->ValidateVertexArrayObject(index)) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidOperation,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateVertexArrayObject",
-                                                 std::format("Vertex array object {} does not exist.", index)));
-                return false;
-            }
-            return true;
+        if (type == DataType::Unknown) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidEnum,
+                MakeUnique<GenericErrorInfo>(
+                    "MG_Impl/GLImpl", "ValidateVertexAttribPointerParams",
+                    std::format("Invalid type {} for attribute {}.", MG_Util::ConvertDataTypeToString(type), index)));
+            return false;
         }
 
-        Bool ValidateVertexAttributeIndex(Uint index) {
-            if (index >= MG_State::GLState::VertexArrayObject::MAX_VERTEX_ATTRIBS) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue,
-                    MakeShared<GenericErrorInfo>(
-                        "MG_Impl/GLImpl", "ValidateVertexAttributeIndex",
-                        std::format("Attribute index {} exceeds maximum of {}.", index,
-                                    MG_State::GLState::VertexArrayObject::MAX_VERTEX_ATTRIBS - 1)));
-                return false;
-            }
-            return true;
+        if (stride < 0) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidValue,
+                MakeUnique<GenericErrorInfo>(
+                    "MG_Impl/GLImpl", "ValidateVertexAttribPointerParams",
+                    std::format("Negative stride {} is not allowed for attribute {}.", stride, index)));
+            return false;
         }
 
-        Bool ValidateVertexAttribPointerParams(Uint index, SizeT size, DataType type, Int stride) {
-            if (size < 1 || size > 4) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue,
-                    MakeShared<GenericErrorInfo>(
-                        "MG_Impl/GLImpl", "ValidateVertexAttribPointerParams",
-                        std::format("Invalid size {} for attribute {}. Must be 1-4.", size, index)));
-                return false;
-            }
-
-            if (type == DataType::Unknown) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidEnum,
-                    MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateVertexAttribPointerParams",
-                                                 std::format("Invalid type {} for attribute {}.",
-                                                             MG_Util::ConvertDataTypeToString(type).c_str(), index)));
-                return false;
-            }
-
-            if (stride < 0) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue,
-                    MakeShared<GenericErrorInfo>(
-                        "MG_Impl/GLImpl", "ValidateVertexAttribPointerParams",
-                        std::format("Negative stride {} is not allowed for attribute {}.", stride, index)));
-                return false;
-            }
-
-            return true;
-        }
-    } // namespace VertexArrayImpl
-} // namespace MobileGL::MG_Impl::GLImpl
+        return true;
+    }
+} // namespace MobileGL::MG_Impl::GLImpl::VertexArrayImpl

MobileGL/MG_Impl/GLImpl/VertexArray/Validators.h

@@ -10,11 +10,9 @@
 #include <Includes.h>
 #include <MG_State/GLState/VertexArrayState/VertexArrayObject.h>
 
-namespace MobileGL::MG_Impl::GLImpl {
-    namespace VertexArrayImpl {
-        Bool ValidateVertexArrayName(Uint index);
-        Bool ValidateVertexArrayObject(Uint index);
-        Bool ValidateVertexAttributeIndex(Uint index);
-        Bool ValidateVertexAttribPointerParams(Uint index, SizeT size, DataType type, Int stride);
-    } // namespace VertexArrayImpl
-} // namespace MobileGL::MG_Impl::GLImpl
+namespace MobileGL::MG_Impl::GLImpl::VertexArrayImpl {
+    Bool ValidateVertexArrayName(Uint index);
+    Bool ValidateVertexArrayObject(Uint index);
+    Bool ValidateVertexAttributeIndex(Uint index);
+    Bool ValidateVertexAttribPointerParams(Uint index, SizeT size, DataType type, Int stride);
+} // namespace MobileGL::MG_Impl::GLImpl::VertexArrayImpl

MobileGL/MG_Impl/GLXImpl/LookUp/LookUp.h

@@ -10,9 +10,7 @@
 #include <Includes.h>
 #include "MG_Impl/GetProcAddress.h"
 
-namespace MG_Impl {
-    namespace GLXImpl {
-        void* GetProcAddress(const char* name);
-        void* GetProcAddressARB(const char* name);
-    } // namespace GLXImpl
-} // namespace MG_Impl
+namespace MG_Impl::GLXImpl {
+    void* GetProcAddress(const char* name);
+    void* GetProcAddressARB(const char* name);
+} // namespace MG_Impl::GLXImpl

MobileGL/MG_Impl/GetProcAddress.h

@@ -9,8 +9,6 @@
 #pragma once
 #include <Includes.h>
 
-namespace MobileGL {
-    namespace MG_Impl {
-        void* GetProcAddress(const char* name);
-    } // namespace MG_Impl
-} // namespace MobileGL
+namespace MobileGL::MG_Impl {
+    void* GetProcAddress(const char* name);
+} // namespace MobileGL::MG_Impl

MobileGL/MG_Impl/Init.cpp

@@ -18,25 +18,27 @@
 namespace MobileGL::MG_Impl {
     void Init() {
         MGLOG_D("Initializing MobileGL Implementation...");
-        GLImpl::TextureImpl::pProxyTextureManager = new GLImpl::TextureImpl::ProxyTextureManager();
+        GLImpl::TextureImpl::pProxyTextureManager = MakeUnique<GLImpl::TextureImpl::ProxyTextureManager>();
 
         // TODO: get real info in EGL
-        auto fbo0 = MG_State::pGLContext->CreateFramebufferObject(0);
+        auto& fbo0 = MG_State::pGLContext->CreateFramebufferObject(0);
         auto colorTex = MakeShared<MG_State::GLState::TextureObject2D>(0);
         colorTex->SetInternalFormat(TextureInternalFormat::RGBA8);
         colorTex->AllocateStorage(TextureUploadTarget::Texture2D, 0, {{512, 512, 1}, 0});
-
+        // colorTex->SetMipmapLevel({{512, 512, 1}, 0, false, 0, {nullptr, 0}});
         auto depthTex = MakeShared<MG_State::GLState::TextureObject2D>(0);
         depthTex->SetInternalFormat(TextureInternalFormat::Depth32FStencil8);
         depthTex->AllocateStorage(TextureUploadTarget::Texture2D, 0, {{512, 512, 1}, 0});
+        // depthTex->SetMipmapLevel({{512, 512, 1}, 0, false, 0, {nullptr, 0}});
         auto stencilTex = MakeShared<MG_State::GLState::TextureObject2D>(0);
         stencilTex->SetInternalFormat(TextureInternalFormat::Depth32FStencil8);
         stencilTex->AllocateStorage(TextureUploadTarget::Texture2D, 0, {{512, 512, 1}, 0});
+        // stencilTex->SetMipmapLevel({{512, 512, 1}, 0, false, 0, {nullptr, 0}});
         fbo0->AttachTexture(FramebufferAttachmentType::Color0, colorTex);
         fbo0->AttachTexture(FramebufferAttachmentType::Depth, depthTex);
         fbo0->AttachTexture(FramebufferAttachmentType::Stencil, stencilTex);
         GLImpl::FramebufferImpl::pDefaultFramebufferInfo =
-            new GLImpl::FramebufferImpl::DefaultFramebufferInfo(fbo0, colorTex, depthTex, stencilTex);
+            MakeUnique<GLImpl::FramebufferImpl::DefaultFramebufferInfo>(fbo0, colorTex, depthTex, stencilTex);
         MG_State::pGLContext->GetFramebufferBindingSlot(FramebufferTarget::Draw).Bind(fbo0);
         MG_State::pGLContext->GetFramebufferBindingSlot(FramebufferTarget::Read).Bind(fbo0);
     }