[Docs] (README): Add an important note about rewriting this project.

# Conflict:
#	MG/Includes.h

# Changes:
#      Remove ShittilyDraw, ready to implement MG_RHI...
#      Update progress.

.gitignore

@@ -0,0 +1,5 @@
+################################################################################
+# 此 .gitignore 文件已由 Microsoft(R) Visual Studio 自动创建。
+################################################################################
+
+/build

CMakeLists.txt

@@ -10,7 +10,7 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -w -fvisibility=hidden -funwind-tables -g -D_THREAD_SAFE -fPIC -stdlib=libc++")
 
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -w -g -std=gnu99 -funwind-tables -O3 -fvisibility=hidden")
+#set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -w -g -std=gnu99 -funwind-tables -O3 -fvisibility=hidden")
 
 set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-libstdc++")
 
@@ -25,6 +25,9 @@ find_library(GLSLANG_LIB glslang PATHS ${CMAKE_SOURCE_DIR}/libraries/arm64-v8a/)
 add_library(${CMAKE_PROJECT_NAME} SHARED 
         MG/Init.cpp
 
+        # MG_GL/Implementations/GLX
+        MG/MG_GL/Implementations/GLX/GLXFuncsDefinitions/GLXFuncsDefinitions.cpp
+
         # MG_GL/Implementations/GL
         MG/MG_GL/Implementations/GL/GLFuncsDefinitions/GLFuncsDefinitions.cpp
         

MG/Constants.h

@@ -5,26 +5,48 @@
 #ifndef MOBILEGL_CONSTANTS_H
 #define MOBILEGL_CONSTANTS_H
 
+#include <array>
+#include <unordered_map>
+#include <unordered_set>
+#include <GL/gl.h>
+#include <ankerl/unordered_dense.h>
+
 #ifdef __ANDROID__
 #define __ANDROID_API__ 26
 #endif
-#define MG_EXPORT extern "C" __attribute__((visibility("default")))
 
-#include <array>
+#ifdef _WIN32
-#include <unordered_set>
+#define MG_EXPORT extern "C" __declspec(dllexport)
-#include <GL/gl.h>
+#else
+#define MG_EXPORT extern "C" __attribute__((visibility("default")))
+#endif
+
+namespace ankerl {
+    template <typename K, typename V>
+    using unordered_map = ankerl::unordered_dense::map<K, V>;
+    
+    template <typename T>
+    using unordered_set = ankerl::unordered_dense::set<T>;
+}
 
 namespace MG_Constants {
     namespace Common {
-        inline const int LOG_LEVEL_DEBUG = 0x0010;
+        inline constexpr int LOG_LEVEL_DEBUG     = 0x0010;
-        inline const int LOG_LEVEL_WARN = 0x0011;
+        inline constexpr int LOG_LEVEL_WARN      = 0x0011;
-        inline const int LOG_LEVEL_ERROR = 0x0012;
+        inline constexpr int LOG_LEVEL_ERROR     = 0x0012;
-        inline const int LOG_LEVEL_INFO = 0x0013;
+        inline constexpr int LOG_LEVEL_INFO      = 0x0013;
-        inline const int LOG_LEVEL_FATAL = 0x0014;
+        inline constexpr int LOG_LEVEL_FATAL     = 0x0014;
+
+
+        inline constexpr int LOG_TARGET_NONE     = 0x00;
+        inline constexpr int LOG_TARGET_CONSOLE  = 0x01;
+        inline constexpr int LOG_TARGET_FILE     = 0x02;
+        inline constexpr int LOG_TARGET_ANDROID  = 0x04;  // Android logcat
+        inline constexpr int LOG_TARGET_ALL      = LOG_TARGET_CONSOLE | LOG_TARGET_FILE | LOG_TARGET_ANDROID;
     }
     
     namespace Blend {
-        static const std::unordered_set<GLenum> VALID_FACTORS = {
+        static const ankerl::unordered_set<GLenum> VALID_FACTORS = {
                 GL_ZERO, GL_ONE, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR,
                 GL_DST_COLOR, GL_ONE_MINUS_DST_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA,
                 GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA, GL_CONSTANT_COLOR, GL_ONE_MINUS_CONSTANT_COLOR,
@@ -33,51 +55,51 @@ namespace MG_Constants {
     }
     
     namespace Depth {
-        static const std::unordered_set<GLenum> VALID_FUNCS = {
+        static const ankerl::unordered_set<GLenum> VALID_FUNCS = {
                 GL_NEVER, GL_LESS, GL_EQUAL, GL_LEQUAL, GL_GREATER, GL_NOTEQUAL, GL_GEQUAL, GL_ALWAYS
         }; // OpenGL 3
     }
     
     namespace CommonState {
-        static const std::unordered_set<GLenum> VALID_CAPS = {
+        static const ankerl::unordered_set<GLenum> VALID_CAPS = {
                 GL_BLEND, GL_DEPTH_TEST, GL_STENCIL_TEST, GL_SCISSOR_TEST, GL_CULL_FACE,
                 GL_POLYGON_OFFSET_FILL, GL_SAMPLE_ALPHA_TO_COVERAGE, GL_SAMPLE_COVERAGE
         }; // OpenGL 3
     }
     
     namespace Framebuffer {
-        static const std::unordered_set<GLenum> VALID_ATTACHMENTS = {
+        static const ankerl::unordered_set<GLenum> VALID_ATTACHMENTS = {
                 GL_COLOR_ATTACHMENT0, GL_DEPTH_ATTACHMENT,
                 GL_STENCIL_ATTACHMENT, GL_DEPTH_STENCIL_ATTACHMENT
         }; // OpenGL 3
         
-        static const std::unordered_set<GLenum> VALID_TARGETS = {
+        static const ankerl::unordered_set<GLenum> VALID_TARGETS = {
                 GL_FRAMEBUFFER, GL_DRAW_FRAMEBUFFER, GL_READ_FRAMEBUFFER
         }; // OpenGL 3
         
-        static const std::unordered_set<GLenum> VALID_ACCESS = {
+        static const ankerl::unordered_set<GLenum> VALID_ACCESS = {
                 GL_READ_ONLY, GL_WRITE_ONLY, GL_READ_WRITE
         }; // OpenGL 3
     }
     
     namespace Buffer {
-        static const std::unordered_set<GLenum> VALID_PARAM_NAMES = {
+        static const ankerl::unordered_set<GLenum> VALID_PARAM_NAMES = {
                 GL_BUFFER_ACCESS, GL_BUFFER_MAPPED, GL_BUFFER_SIZE, GL_BUFFER_USAGE
         }; // OpenGL 3
         
-        static const std::unordered_set<GLenum> VALID_TARGETS = { 
+        static const ankerl::unordered_set<GLenum> VALID_TARGETS = { 
                 GL_ARRAY_BUFFER, GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, GL_ELEMENT_ARRAY_BUFFER,
                 GL_PIXEL_PACK_BUFFER, GL_PIXEL_UNPACK_BUFFER, GL_TEXTURE_BUFFER,
                 GL_TRANSFORM_FEEDBACK_BUFFER,  GL_UNIFORM_BUFFER
         }; // OpenGL 3
         
-        static const std::unordered_set<GLenum> VALID_ACCESS = {
+        static const ankerl::unordered_set<GLenum> VALID_ACCESS = {
                 GL_READ_ONLY, GL_WRITE_ONLY, GL_READ_WRITE
         }; // OpenGL 3
     }
 
     namespace PixelStore {
-        static const std::unordered_map<GLenum, GLint> DEFAULT_VALUES_MAP = {
+        static const ankerl::unordered_map<GLenum, GLint> DEFAULT_VALUES_MAP = {
                 {GL_PACK_SWAP_BYTES,   GL_FALSE},
                 {GL_PACK_LSB_FIRST,    GL_FALSE},
                 {GL_PACK_ROW_LENGTH,   0},
@@ -96,7 +118,7 @@ namespace MG_Constants {
                 {GL_UNPACK_ALIGNMENT,  4}
         }; // OpenGL 3
         
-        static const std::unordered_set<GLenum> VALID_PARAM_NAMES = {
+        static const ankerl::unordered_set<GLenum> VALID_PARAM_NAMES = {
                 GL_PACK_SWAP_BYTES, GL_PACK_LSB_FIRST, GL_PACK_ROW_LENGTH, GL_PACK_IMAGE_HEIGHT,
                 GL_PACK_SKIP_ROWS, GL_PACK_SKIP_PIXELS, GL_PACK_SKIP_IMAGES, GL_PACK_ALIGNMENT,
                 GL_UNPACK_SWAP_BYTES, GL_UNPACK_LSB_FIRST, GL_UNPACK_ROW_LENGTH,
@@ -110,18 +132,18 @@ namespace MG_Constants {
         inline const GLuint MAX_TEXTURE_UNITS = 80;
         const GLsizei MAX_TEXTURE_SIZE = 32768;
         const GLsizei MAX_ARRAY_LAYERS = 256;
-        inline const std::unordered_set<GLenum> VALID_TARGETS = {
+        inline const ankerl::unordered_set<GLenum> VALID_TARGETS = {
                 GL_TEXTURE_2D, GL_PROXY_TEXTURE_2D, GL_TEXTURE_1D_ARRAY, GL_PROXY_TEXTURE_1D_ARRAY,
                 GL_TEXTURE_RECTANGLE, GL_PROXY_TEXTURE_RECTANGLE, GL_TEXTURE_CUBE_MAP_POSITIVE_X,
                 GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 
                 GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, GL_PROXY_TEXTURE_CUBE_MAP
         }; // OpenGL 3
 
-        inline const std::unordered_set<GLenum> VALID_FORMATS = {
+        inline const ankerl::unordered_set<GLenum> VALID_FORMATS = {
                 GL_RED, GL_RG, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_DEPTH_COMPONENT, GL_DEPTH_STENCIL
         }; // OpenGL 3
 
-        inline const std::unordered_set<GLenum> VALID_INTERNAL_FORMATS = {
+        inline const ankerl::unordered_set<GLenum> VALID_INTERNAL_FORMATS = {
                 GL_RED, GL_RG, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_DEPTH_COMPONENT, GL_DEPTH_STENCIL,
                 GL_RGBA32F, GL_RGBA32I, GL_RGBA32UI, GL_RGBA16, GL_RGBA16F, GL_RGBA16I, 
                 GL_RGBA16UI, GL_RGBA8, GL_RGBA8UI, GL_SRGB8_ALPHA8, GL_RGB10_A2, GL_RGB10_A2UI, 
@@ -132,11 +154,11 @@ namespace MG_Constants {
                 GL_RGB16, GL_RGB8_SNORM, GL_RGB8, GL_RGB8I, GL_RGB8UI, GL_SRGB8, GL_RGB9_E5, 
                 GL_RG16_SNORM, GL_RG8_SNORM, GL_COMPRESSED_RG_RGTC2, GL_COMPRESSED_SIGNED_RG_RGTC2,
                 GL_R16_SNORM, GL_R8_SNORM, GL_COMPRESSED_RED_RGTC1, GL_COMPRESSED_SIGNED_RED_RGTC1,
-                GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT16, GL_DEPTH32F_STENCIL8,
+                GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT32, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT16,
-                GL_DEPTH24_STENCIL8
+                GL_DEPTH32F_STENCIL8, GL_DEPTH24_STENCIL8
         }; // OpenGL 3
 
-        inline const std::unordered_set<GLenum> VALID_TYPES = {
+        inline const ankerl::unordered_set<GLenum> VALID_TYPES = {
                 GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, 
                 GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, 
                 GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV,
@@ -144,14 +166,14 @@ namespace MG_Constants {
                 GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, GL_UNSIGNED_INT_2_10_10_10_REV
         }; // OpenGL 3
 
-        inline const std::unordered_set<GLenum> VALID_TEXTURE_PARAM_NAMES = {
+        inline const ankerl::unordered_set<GLenum> VALID_TEXTURE_PARAM_NAMES = {
                 GL_TEXTURE_BASE_LEVEL, GL_TEXTURE_COMPARE_FUNC, GL_TEXTURE_COMPARE_MODE, GL_TEXTURE_MIN_FILTER, 
                 GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MAX_LEVEL, GL_TEXTURE_SWIZZLE_R, GL_TEXTURE_SWIZZLE_G,
                 GL_TEXTURE_SWIZZLE_B, GL_TEXTURE_SWIZZLE_A, GL_TEXTURE_SWIZZLE_RGBA, GL_TEXTURE_WRAP_S,
                 GL_TEXTURE_WRAP_T, GL_TEXTURE_WRAP_R, GL_TEXTURE_LOD_BIAS, GL_TEXTURE_MIN_LOD, GL_TEXTURE_MAX_LOD, GL_TEXTURE_BORDER_COLOR
         }; // OpenGL 3
         
-        inline const std::unordered_set<GLenum> VALID_QUERY_LEVEL_PROPERTY_PARAM_NAMES = {
+        inline const ankerl::unordered_set<GLenum> VALID_QUERY_LEVEL_PROPERTY_PARAM_NAMES = {
                 GL_TEXTURE_WIDTH, GL_TEXTURE_HEIGHT, GL_TEXTURE_DEPTH, GL_TEXTURE_INTERNAL_FORMAT,
                 GL_TEXTURE_RED_SIZE, GL_TEXTURE_GREEN_SIZE, GL_TEXTURE_BLUE_SIZE, GL_TEXTURE_ALPHA_SIZE,
                 GL_TEXTURE_DEPTH_SIZE, GL_TEXTURE_COMPRESSED, GL_TEXTURE_COMPRESSED_IMAGE_SIZE

MG/Global.h

@@ -22,12 +22,13 @@ namespace MG_Global {
     
     namespace GL {
         inline const int GLVersionMajor    = 3;
-        inline const int GLVersionMinor = 0;
+        inline const int GLVersionMinor    = 2;
         inline const int GLVersionRevision = 0;
     }
     
     namespace Common {
         inline constexpr int LogLevel    = MG_Constants::Common::LOG_LEVEL_INFO;
+        inline constexpr int LogTarget   = MG_Constants::Common::LOG_TARGET_ALL;
         
 #ifdef __ANDROID__
         inline const char* LOG_FILE_PATH = "/sdcard/MG/latest.log";

MG/Includes.h

@@ -84,8 +84,6 @@
 #include <cstring>
 #include <iostream>
 #include <cstdio>
-#include <dlfcn.h>
-#include <unistd.h>
 #include <ctime>
 #include <chrono>
 #include <thread>
@@ -103,7 +101,6 @@
 #include <unordered_map>
 #include <queue>
 #include <format>
-#include <vulkan/vulkan.h>
 #include <glslang/Public/ShaderLang.h>
 #include <glslang/Include/Types.h>
 #include <glslang/Public/ShaderLang.h>
@@ -112,10 +109,20 @@
 #include <glm/gtc/matrix_transform.hpp>
 #include <glm/glm.hpp>
 #include <ankerl/unordered_dense.h>
-#include "GLES/gl32.h"
+#include <GLES3/gl32.h>
 
 #include "MG_Include/UncertainBool.hpp"
 
+#ifdef _WIN32
+#include <Windows.h>
+#endif
+
+#ifndef _WIN32
+#include <dlfcn.h>
+#include <unistd.h>
+#include <vulkan/vulkan.h>
+#endif
+
 #ifdef __ANDROID__
 #include <android/log.h>
 #include <pthread.h>

MG/Init.cpp

@@ -4,14 +4,43 @@
 
 #include "Includes.h"
 
-__attribute__((constructor)) void MG_Initialize() {
+void MG_Initialize() {
     MG_Util::Debug::LogInit();
     MG_Util::Debug::LogI("MobileGL Initializing...");
     MG_State::Init();
     MG_GL::BackendLoader::Init();
 }
 
-__attribute__((destructor)) void MG_Destroy() {
+void MG_Destroy() {
     MG_Util::Debug::LogI("MobileGL Exiting...");
     MG_State::Destroy();
 }
+
+#if defined(__linux__) || defined(__APPLE__)
+__attribute__((constructor)) static void AutoInit() {
+    MG_Initialize();
+}
+
+__attribute__((destructor)) static void AutoDestroy() {
+    MG_Destroy();
+}
+#endif
+
+#ifdef _WIN32
+BOOL WINAPI DllMain(HMODULE hModule,
+                      DWORD  ul_reason_for_call,
+                      LPVOID lpReserved)
+{
+    switch (ul_reason_for_call)
+    {
+    case DLL_PROCESS_ATTACH:
+        MG_Initialize();
+        break;
+
+    case DLL_PROCESS_DETACH:
+        MG_Destroy();
+        break;
+    }
+    return TRUE;
+}
+#endif

MG/MG_GL/Implementations/EGL/VK/EGL_EMU.cpp

@@ -11,9 +11,9 @@ std::atomic<uintptr_t> g_nextSurfaceId{1};
 EGLenum g_currentAPI = EGL_OPENGL_ES_API;
 
 std::mutex g_globalMutex;
-std::unordered_map<EGLDisplay, VulkanDisplay> g_displays;
+ankerl::unordered_map<EGLDisplay, VulkanDisplay> g_displays;
-std::unordered_map<EGLSurface, VulkanSurface> g_surfaces;
+ankerl::unordered_map<EGLSurface, VulkanSurface> g_surfaces;
-std::unordered_map<EGLContext, VulkanContext> g_contexts;
+ankerl::unordered_map<EGLContext, VulkanContext> g_contexts;
 EGLint g_lastError = EGL_SUCCESS;
 
 thread_local EGLContext tls_currentContext = EGL_NO_CONTEXT;

MG/MG_GL/Implementations/EGL/VK/EGL_EMU.h

@@ -69,9 +69,9 @@ extern std::atomic<uintptr_t> g_nextSurfaceId;
 extern EGLenum g_currentAPI;
 
 extern std::mutex g_globalMutex;
-extern std::unordered_map<EGLDisplay, VulkanDisplay> g_displays;
+extern ankerl::unordered_map<EGLDisplay, VulkanDisplay> g_displays;
-extern std::unordered_map<EGLSurface, VulkanSurface> g_surfaces;
+extern ankerl::unordered_map<EGLSurface, VulkanSurface> g_surfaces;
-extern std::unordered_map<EGLContext, VulkanContext> g_contexts;
+extern ankerl::unordered_map<EGLContext, VulkanContext> g_contexts;
 extern EGLint g_lastError;
 
 extern thread_local EGLContext tls_currentContext;

MG/MG_GL/Implementations/GL/Buffer/GL_Buffer.cpp

@@ -5,34 +5,79 @@
 #include "GL_Buffer.h"
 
 namespace MG_GL::GL {
-    void* MapBuffer(GLenum target, GLenum access) {
+    void* MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length,
-        MG_Util::Debug::LogD("glMapBuffer(target=0x%x, access=0x%x)", target, access);
+                         GLbitfield access) {
+        MG_Util::Debug::LogD("glMapBufferRange, target: %s, offset: %lld, length: %lld, access: 0x%X",
+                             MG_Util::Debug::GLEnumToString(target),
+                             static_cast<long long>(offset),
+                             static_cast<long long>(length),
+                             access);
+        void* mappedPointer = nullptr;
+        GLenum result = MG_State::AcquireBufferMemoryRange(target, offset, length, access, &mappedPointer);
 
-        void* mappedPtr = nullptr;
+        if (result == GL_NO_ERROR) {
-        GLenum err = MG_State::AcquireBufferMemory(target, access, &mappedPtr);
+            MG_Util::Debug::LogD("Mapped pointer: %p", mappedPointer);
-
+            return mappedPointer;
-        if (err != GL_NO_ERROR) {
+        }
-            MG_State::SetError(err);
+        MG_State::SetError(result);
-            MG_Util::Debug::LogE("glMapBuffer failed: %s",
+        MG_Util::Debug::LogE("Error mapping buffer range: %s", MG_Util::Debug::GLEnumToString(result));
-                                 MG_Util::Debug::GLEnumToString(err));
         return nullptr;
     }
 
+    void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) {
+        MG_Util::Debug::LogD("glFlushMappedBufferRange, target: %s, offset: %lld, length: %lld",
+                             MG_Util::Debug::GLEnumToString(target),
+                             static_cast<long long>(offset),
+                             static_cast<long long>(length));
+        GLenum result = MG_State::SyncBufferMemory(target, offset, length);
+        if (result == GL_NO_ERROR) {
+            return;
+        }
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error flushing mapped buffer range: %s",
+                             MG_Util::Debug::GLEnumToString(result));
+    }
+
+    void CopyBufferSubData(GLenum readTarget, GLenum writeTarget,
+                           GLintptr readOffset, GLintptr writeOffset,
+                           GLsizeiptr size) {
+        MG_Util::Debug::LogD("glCopyBufferSubData, readTarget: %s, writeTarget: %s, "
+                             "readOffset: %lld, writeOffset: %lld, size: %lld",
+                             MG_Util::Debug::GLEnumToString(readTarget),
+                             MG_Util::Debug::GLEnumToString(writeTarget),
+                             static_cast<long long>(readOffset),
+                             static_cast<long long>(writeOffset),
+                             static_cast<long long>(size));
+        GLenum result = MG_State::CopyBufferRange(readTarget, writeTarget, readOffset, writeOffset, size);
+        if (result == GL_NO_ERROR) {
+            return;
+        }
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error copying buffer subdata: %s",
+                             MG_Util::Debug::GLEnumToString(result));
+    }
+    
+    void* MapBuffer(GLenum target, GLenum access) {
+        MG_Util::Debug::LogD("glMapBuffer(target=0x%x, access=0x%x)", target, access);
+        void* mappedPtr = nullptr;
+        GLenum err = MG_State::AcquireBufferMemory(target, access, &mappedPtr);
+        if (err != GL_NO_ERROR) {
+            MG_State::SetError(err);
+            MG_Util::Debug::LogE("glMapBuffer failed: %s", MG_Util::Debug::GLEnumToString(err));
+            return nullptr;
+        }
         MG_Util::Debug::LogD("glMapBuffer returns %p", mappedPtr);
         return mappedPtr;
     }
     
     GLboolean UnmapBuffer(GLenum target) {
         MG_Util::Debug::LogD("glUnmapBuffer(target=0x%x)", target);
-
         GLenum err = MG_State::ReleaseBufferMemory(target);
         if (err != GL_NO_ERROR) {
             MG_State::SetError(err);
-            MG_Util::Debug::LogE("glUnmapBuffer failed: %s",
+            MG_Util::Debug::LogE("glUnmapBuffer failed: %s", MG_Util::Debug::GLEnumToString(err));
-                                 MG_Util::Debug::GLEnumToString(err));
             return GL_FALSE;
         }
-        
         MG_Util::Debug::LogD("glUnmapBuffer succeeded");
         return GL_TRUE;
     }
@@ -118,6 +163,18 @@ namespace MG_GL::GL {
         return isValid ? GL_TRUE : GL_FALSE;
     }
 
+    void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data) {
+        MG_Util::Debug::LogD("glBufferSubData, target: %s, offset: %lld, size: %lld, data: %p",
+                             MG_Util::Debug::GLEnumToString(target),
+                             static_cast<long long>(offset),
+                             static_cast<long long>(size),
+                             data);
+        GLenum result = MG_State::CommitBufferStorageRegion(target, offset, size, data);
+        if (result != GL_NO_ERROR) {
+            MG_State::SetError(result);
+            MG_Util::Debug::LogE("Error from MG State: %s", MG_Util::Debug::GLEnumToString(result));
+        }
+    }
     void DeleteBuffers(GLsizei n, const GLuint *buffers) {
         MG_Util::Debug::LogD("glDeleteBuffers, n: %d, buffers: %p", n, buffers);
 

MG/MG_GL/Implementations/GL/Buffer/GL_Buffer.h

@@ -8,10 +8,14 @@
 #include "../../../../Includes.h"
 
 namespace MG_GL::GL {
+    void* MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
+    void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length);
+    void CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
     void* MapBuffer(GLenum target, GLenum access);
     GLboolean UnmapBuffer(GLenum target);
     void BindBuffer(GLenum target, GLuint buffer);
     void BufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage);
+    void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data);
     void GetBufferParameteriv(GLenum target, GLenum pname, GLint* params);
     void GenBuffers(GLsizei n, GLuint* buffers);
     void DeleteBuffers(GLsizei n, const GLuint *buffers);

MG/MG_GL/Implementations/GL/Common/GL_Common.cpp

@@ -5,6 +5,16 @@
 #include "GL_Common.h"
 
 namespace MG_GL::GL {
+    void Clear(GLbitfield mask) {
+        MG_Util::Debug::LogD("glClear, mask: 0x%X", mask);
+        GLenum result = MG_State::glClear(mask);
+        if (result == GL_NO_ERROR) {
+            return;
+        }
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error clearing buffers: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+    
     void Enable(GLenum cap) {
         MG_Util::Debug::LogD("glEnable, cap: %s", MG_Util::Debug::GLEnumToString(cap));
         GLenum result = MG_State::glEnable(cap);

MG/MG_GL/Implementations/GL/Drawing/GL_Drawing.h

@@ -5,9 +5,14 @@
 #ifndef MOBILEGL_GL_DRAWING_H
 #define MOBILEGL_GL_DRAWING_H
 #include "../../../../Includes.h"
+
 namespace MG_GL::GL {
     void DrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices);
     void DrawArrays(GLenum mode, GLint first, GLsizei count);
+    void DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex);
+    void MultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid *const *indices, GLsizei drawcount);
+    void MultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid *const *indices, GLsizei drawcount, const GLint *basevertex);
+    void DrawBuffer(GLenum buf);
 }
 
 #endif //MOBILEGL_GL_DRAWING_H

MG/MG_GL/Implementations/GL/Framebuffer/GL_Framebuffer.cpp

@@ -65,4 +65,9 @@ namespace MG_GL::GL {
                              MG_Util::Debug::GLEnumToString(result));
         return result;
     }
+
+    void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
+                         GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) {
+        // TODO
+    }
 }

MG/MG_GL/Implementations/GL/GLFuncsDefinitions/GLFuncsDefinitions.cpp

@@ -46,7 +46,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, BlendEquationSeparate, GLenum modeRGB, GLenu
 DECLARE_GL_FUNCTION_HEAD(void, BlendFunc, GLenum sfactor, GLenum dfactor) DECLARE_GL_FUNCTION_END_NO_RETURN(void, BlendFunc, sfactor,dfactor)
 DECLARE_GL_FUNCTION_HEAD(void, BlendFuncSeparate, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) DECLARE_GL_FUNCTION_END_NO_RETURN(void, BlendFuncSeparate, sfactorRGB,dfactorRGB,sfactorAlpha,dfactorAlpha)
 DECLARE_GL_FUNCTION_HEAD(void, BufferData, GLenum target, GLsizeiptr size, const void *data, GLenum usage) DECLARE_GL_FUNCTION_END_NO_RETURN(void, BufferData, target,size,data,usage)
-DECLARE_GL_FUNCTION_STUB_HEAD(void, BufferSubData, GLenum target, GLintptr offset, GLsizeiptr size, const void *data) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BufferSubData, target,offset,size,data)
+DECLARE_GL_FUNCTION_HEAD(void, BufferSubData, GLenum target, GLintptr offset, GLsizeiptr size, const void *data) DECLARE_GL_FUNCTION_END_NO_RETURN(void, BufferSubData, target,offset,size,data)
 DECLARE_GL_FUNCTION_HEAD(GLenum, CheckFramebufferStatus, GLenum target) DECLARE_GL_FUNCTION_END(GLenum, CheckFramebufferStatus, target)
 DECLARE_GL_FUNCTION_HEAD(void, Clear, GLbitfield mask) DECLARE_GL_FUNCTION_END_NO_RETURN(void, Clear, mask)
 DECLARE_GL_FUNCTION_HEAD(void, ClearColor, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ClearColor, red,green,blue,alpha)
@@ -201,7 +201,7 @@ DECLARE_GL_FUNCTION_HEAD(void, BlitFramebuffer, GLint srcX0, GLint srcY0, GLint
 //DECLARE_GL_FUNCTION_STUB_HEAD(void, BlitFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BlitFramebuffer, srcX0,srcY0,srcX1,srcY1,dstX0,dstY0,dstX1,dstY1,mask,filter)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, RenderbufferStorageMultisample, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, RenderbufferStorageMultisample, target,samples,internalformat,width,height)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, FramebufferTextureLayer, GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, FramebufferTextureLayer, target,attachment,texture,level,layer)
-DECLARE_GL_FUNCTION_STUB_HEAD(void, FlushMappedBufferRange, GLenum target, GLintptr offset, GLsizeiptr length) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, FlushMappedBufferRange, target,offset,length)
+DECLARE_GL_FUNCTION_HEAD(void, FlushMappedBufferRange, GLenum target, GLintptr offset, GLsizeiptr length) DECLARE_GL_FUNCTION_END_NO_RETURN(void, FlushMappedBufferRange, target,offset,length)
 DECLARE_GL_FUNCTION_HEAD(void, BindVertexArray, GLuint array) DECLARE_GL_FUNCTION_END_NO_RETURN(void, BindVertexArray, array)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DeleteVertexArrays, GLsizei n, const GLuint *arrays) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DeleteVertexArrays, n,arrays)
 DECLARE_GL_FUNCTION_HEAD(void, GenVertexArrays, GLsizei n, GLuint *arrays) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GenVertexArrays, n,arrays)
@@ -234,7 +234,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, ClearBufferiv, GLenum buffer, GLint drawbuff
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ClearBufferuiv, GLenum buffer, GLint drawbuffer, const GLuint *value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ClearBufferuiv, buffer,drawbuffer,value)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ClearBufferfv, GLenum buffer, GLint drawbuffer, const GLfloat *value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ClearBufferfv, buffer,drawbuffer,value)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ClearBufferfi, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ClearBufferfi, buffer,drawbuffer,depth,stencil)
-DECLARE_GL_FUNCTION_STUB_HEAD(void, CopyBufferSubData, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, CopyBufferSubData, readTarget,writeTarget,readOffset,writeOffset,size)
+DECLARE_GL_FUNCTION_HEAD(void, CopyBufferSubData, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) DECLARE_GL_FUNCTION_END_NO_RETURN(void, CopyBufferSubData, readTarget,writeTarget,readOffset,writeOffset,size)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetUniformIndices, GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetUniformIndices, program,uniformCount,uniformNames,uniformIndices)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetActiveUniformsiv, GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetActiveUniformsiv, program,uniformCount,uniformIndices,pname,params)
 DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, GetUniformBlockIndex, GLuint program, const GLchar *uniformBlockName) DECLARE_GL_FUNCTION_STUB_END(GLuint, GetUniformBlockIndex, program,uniformBlockName)
@@ -366,7 +366,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, BlendFunci, GLuint buf, GLenum src, GLenum d
 DECLARE_GL_FUNCTION_STUB_HEAD(void, BlendFuncSeparatei, GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BlendFuncSeparatei, buf,srcRGB,dstRGB,srcAlpha,dstAlpha)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ColorMaski, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ColorMaski, index,r,g,b,a)
 DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsEnabledi, GLenum target, GLuint index) DECLARE_GL_FUNCTION_STUB_END(GLboolean, IsEnabledi, target,index)
-DECLARE_GL_FUNCTION_STUB_HEAD(void, DrawElementsBaseVertex, GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DrawElementsBaseVertex, mode,count,type,indices,basevertex)
+DECLARE_GL_FUNCTION_HEAD(void, DrawElementsBaseVertex, GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex) DECLARE_GL_FUNCTION_END_NO_RETURN(void, DrawElementsBaseVertex, mode,count,type,indices,basevertex)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DrawRangeElementsBaseVertex, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DrawRangeElementsBaseVertex, mode,start,end,count,type,indices,basevertex)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DrawElementsInstancedBaseVertex, GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DrawElementsInstancedBaseVertex, mode,count,type,indices,instancecount,basevertex)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, FramebufferTexture, GLenum target, GLenum attachment, GLuint texture, GLint level) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, FramebufferTexture, target,attachment,texture,level)
@@ -389,7 +389,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, GetSamplerParameterIuiv, GLuint sampler, GLe
 DECLARE_GL_FUNCTION_STUB_HEAD(void, TexBuffer, GLenum target, GLenum internalformat, GLuint buffer) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, TexBuffer, target,internalformat,buffer)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, TexBufferRange, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, TexBufferRange, target,internalformat,buffer,offset,size)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, TexStorage3DMultisample, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, TexStorage3DMultisample, target,samples,internalformat,width,height,depth,fixedsamplelocations)
-DECLARE_GL_FUNCTION_STUB_HEAD(void*, MapBufferRange, GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) DECLARE_GL_FUNCTION_STUB_END(void*, MapBufferRange, target,offset,length,access)
+DECLARE_GL_FUNCTION_HEAD(void*, MapBufferRange, GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) DECLARE_GL_FUNCTION_END(void*, MapBufferRange, target,offset,length,access)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ClearIndex, GLfloat c ) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ClearIndex,c)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, IndexMask, GLuint mask ) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, IndexMask,mask)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, AlphaFunc, GLenum func, GLclampf ref ) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, AlphaFunc,func,ref)
@@ -403,7 +403,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, EdgeFlag, GLboolean flag ) DECLARE_GL_FUNCTI
 DECLARE_GL_FUNCTION_STUB_HEAD(void, EdgeFlagv, const GLboolean *flag ) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, EdgeFlagv,flag)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ClipPlane, GLenum plane, const GLdouble *equation ) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ClipPlane,plane,equation)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetClipPlane, GLenum plane, GLdouble *equation ) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetClipPlane,plane,equation)
-DECLARE_GL_FUNCTION_STUB_HEAD(void, DrawBuffer, GLenum mode ) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DrawBuffer,mode)
+DECLARE_GL_FUNCTION_HEAD(void, DrawBuffer, GLenum mode ) DECLARE_GL_FUNCTION_END_NO_RETURN(void, DrawBuffer,mode)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, EnableClientState, GLenum cap ) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, EnableClientState,cap)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DisableClientState, GLenum cap ) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DisableClientState,cap)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetDoublev, GLenum pname, GLdouble *params ) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetDoublev,pname,params)
@@ -739,7 +739,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, LoadTransposeMatrixd,const GLdouble* m) DECL
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MultTransposeMatrixf,const GLfloat* m) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MultTransposeMatrixf,m)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MultTransposeMatrixd,const GLdouble* m) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MultTransposeMatrixd,m)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MultiDrawArrays, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MultiDrawArrays,mode,first,count,drawcount)
-DECLARE_GL_FUNCTION_STUB_HEAD(void, MultiDrawElements, GLenum mode, const GLsizei* count, GLenum type, const void* const*indices, GLsizei drawcount) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MultiDrawElements,mode,count,type,indices,drawcount)
+DECLARE_GL_FUNCTION_HEAD(void, MultiDrawElements, GLenum mode, const GLsizei* count, GLenum type, const void* const*indices, GLsizei drawcount) DECLARE_GL_FUNCTION_END_NO_RETURN(void, MultiDrawElements,mode,count,type,indices,drawcount)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, PointParameterf, GLenum pname, GLfloat param) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PointParameterf,pname,param)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, PointParameterfv, GLenum pname, const GLfloat* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PointParameterfv,pname,params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, PointParameteri, GLenum pname, GLint param) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PointParameteri,pname,param)
@@ -815,12 +815,12 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, VertexAttrib4uiv, GLuint index, const GLuint
 DECLARE_GL_FUNCTION_STUB_HEAD(void, VertexAttrib4usv, GLuint index, const GLushort* v) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, VertexAttrib4usv,index,v)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, PrimitiveRestartIndex, GLuint index) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PrimitiveRestartIndex,index)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetActiveUniformName, GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetActiveUniformName,program,uniformIndex,bufSize,length,uniformName)
-DECLARE_GL_FUNCTION_STUB_HEAD(void, MultiDrawElementsBaseVertex, GLenum mode, const GLsizei* count, GLenum type, const void* const*indices, GLsizei drawcount, const GLint* basevertex) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MultiDrawElementsBaseVertex,mode,count,type,indices,drawcount,basevertex)
+DECLARE_GL_FUNCTION_HEAD(void, MultiDrawElementsBaseVertex, GLenum mode, const GLsizei* count, GLenum type, const void* const*indices, GLsizei drawcount, const GLint* basevertex) DECLARE_GL_FUNCTION_END_NO_RETURN(void, MultiDrawElementsBaseVertex,mode,count,type,indices,drawcount,basevertex)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ProvokingVertex, GLenum mode) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ProvokingVertex,mode)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, TexImage2DMultisample, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, TexImage2DMultisample,target,samples,internalformat,width,height,fixedsamplelocations)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, TexImage3DMultisample, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, TexImage3DMultisample,target,samples,internalformat,width,height,depth,fixedsamplelocations)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, BindFragDataLocationIndexed, GLuint program, GLuint colorNumber, GLuint index, const GLchar* name) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BindFragDataLocationIndexed,program,colorNumber,index,name)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLint, GetFragDataIndex, GLuint program, const GLchar* name) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLint, GetFragDataIndex,program,name)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLint, GetFragDataIndex, GLuint program, const GLchar* name) DECLARE_GL_FUNCTION_STUB_END(GLint, GetFragDataIndex,program,name)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, QueryCounter, GLuint id, GLenum target) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, QueryCounter,id,target)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetQueryObjecti64v, GLuint id, GLenum pname, GLint64* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetQueryObjecti64v,id,pname,params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetQueryObjectui64v, GLuint id, GLenum pname, GLuint64* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetQueryObjectui64v,id,pname,params)
@@ -880,8 +880,8 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, UniformMatrix3x4dv, GLint location, GLsizei
 DECLARE_GL_FUNCTION_STUB_HEAD(void, UniformMatrix4x2dv, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, UniformMatrix4x2dv,location,count,transpose,value)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, UniformMatrix4x3dv, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, UniformMatrix4x3dv,location,count,transpose,value)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetUniformdv, GLuint program, GLint location, GLdouble* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetUniformdv,program,location,params)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLint, GetSubroutineUniformLocation, GLuint program, GLenum shadertype, const GLchar* name) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLint, GetSubroutineUniformLocation,program,shadertype,name)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLint, GetSubroutineUniformLocation, GLuint program, GLenum shadertype, const GLchar* name) DECLARE_GL_FUNCTION_STUB_END(GLint, GetSubroutineUniformLocation,program,shadertype,name)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, GetSubroutineIndex, GLuint program, GLenum shadertype, const GLchar* name) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLuint, GetSubroutineIndex,program,shadertype,name)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, GetSubroutineIndex, GLuint program, GLenum shadertype, const GLchar* name) DECLARE_GL_FUNCTION_STUB_END(GLuint, GetSubroutineIndex,program,shadertype,name)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetActiveSubroutineUniformiv, GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint* values) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetActiveSubroutineUniformiv,program,shadertype,index,pname,values)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetActiveSubroutineUniformName, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetActiveSubroutineUniformName,program,shadertype,index,bufSize,length,name)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetActiveSubroutineName, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetActiveSubroutineName,program,shadertype,index,bufSize,length,name)
@@ -946,7 +946,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, InvalidateBufferSubData, GLuint buffer, GLin
 DECLARE_GL_FUNCTION_STUB_HEAD(void, InvalidateBufferData, GLuint buffer) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, InvalidateBufferData,buffer)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MultiDrawArraysIndirect, GLenum mode, const void* indirect, GLsizei drawcount, GLsizei stride) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MultiDrawArraysIndirect,mode,indirect,drawcount,stride)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MultiDrawElementsIndirect, GLenum mode, GLenum type, const void* indirect, GLsizei drawcount, GLsizei stride) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MultiDrawElementsIndirect,mode,type,indirect,drawcount,stride)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLint, GetProgramResourceLocationIndex, GLuint program, GLenum programInterface, const GLchar* name) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLint, GetProgramResourceLocationIndex,program,programInterface,name)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLint, GetProgramResourceLocationIndex, GLuint program, GLenum programInterface, const GLchar* name) DECLARE_GL_FUNCTION_STUB_END(GLint, GetProgramResourceLocationIndex,program,programInterface,name)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ShaderStorageBlockBinding, GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ShaderStorageBlockBinding,program,storageBlockIndex,storageBlockBinding)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, TextureView, GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, TextureView,texture,target,origtexture,internalformat,minlevel,numlevels,minlayer,numlayers)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, VertexAttribLFormat, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, VertexAttribLFormat,attribindex,size,type,relativeoffset)
@@ -973,7 +973,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, NamedBufferSubData, GLuint buffer, GLintptr
 DECLARE_GL_FUNCTION_STUB_HEAD(void, CopyNamedBufferSubData, GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, CopyNamedBufferSubData,readBuffer,writeBuffer,readOffset,writeOffset,size)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ClearNamedBufferData, GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void* data) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ClearNamedBufferData,buffer,internalformat,format,type,data)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ClearNamedBufferSubData, GLuint buffer, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void* data) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ClearNamedBufferSubData,buffer,internalformat,offset,size,format,type,data)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, UnmapNamedBuffer, GLuint buffer) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, UnmapNamedBuffer,buffer)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, UnmapNamedBuffer, GLuint buffer) DECLARE_GL_FUNCTION_STUB_END(GLboolean, UnmapNamedBuffer,buffer)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, FlushMappedNamedBufferRange, GLuint buffer, GLintptr offset, GLsizeiptr length) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, FlushMappedNamedBufferRange,buffer,offset,length)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetNamedBufferParameteriv, GLuint buffer, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetNamedBufferParameteriv,buffer,pname,params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetNamedBufferParameteri64v, GLuint buffer, GLenum pname, GLint64* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetNamedBufferParameteri64v,buffer,pname,params)
@@ -994,7 +994,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, ClearNamedFramebufferuiv, GLuint framebuffer
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ClearNamedFramebufferfv, GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ClearNamedFramebufferfv,framebuffer,buffer,drawbuffer,value)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ClearNamedFramebufferfi, GLuint framebuffer, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ClearNamedFramebufferfi,framebuffer,buffer,drawbuffer,depth,stencil)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, BlitNamedFramebuffer, GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BlitNamedFramebuffer,readFramebuffer,drawFramebuffer,srcX0,srcY0,srcX1,srcY1,dstX0,dstY0,dstX1,dstY1,mask,filter)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLenum, CheckNamedFramebufferStatus, GLuint framebuffer, GLenum target) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLenum, CheckNamedFramebufferStatus,framebuffer,target)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLenum, CheckNamedFramebufferStatus, GLuint framebuffer, GLenum target) DECLARE_GL_FUNCTION_STUB_END(GLenum, CheckNamedFramebufferStatus,framebuffer,target)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetNamedFramebufferParameteriv, GLuint framebuffer, GLenum pname, GLint* param) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetNamedFramebufferParameteriv,framebuffer,pname,param)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetNamedFramebufferAttachmentParameteriv, GLuint framebuffer, GLenum attachment, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetNamedFramebufferAttachmentParameteriv,framebuffer,attachment,pname,params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, CreateRenderbuffers, GLsizei n, GLuint* renderbuffers) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, CreateRenderbuffers,n,renderbuffers)
@@ -1077,23 +1077,23 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, SpecializeShader, GLuint shader, const GLcha
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MultiDrawArraysIndirectCount, GLenum mode, const void* indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MultiDrawArraysIndirectCount,mode,indirect,drawcount,maxdrawcount,stride)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MultiDrawElementsIndirectCount, GLenum mode, GLenum type, const void* indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MultiDrawElementsIndirectCount,mode,type,indirect,drawcount,maxdrawcount,stride)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, PolygonOffsetClamp, GLfloat factor, GLfloat units, GLfloat clamp) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PolygonOffsetClamp,factor,units,clamp)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLuint64, GetTextureHandleARB, GLuint texture) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLuint64, GetTextureHandleARB,texture)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLuint64, GetTextureHandleARB, GLuint texture) DECLARE_GL_FUNCTION_STUB_END(GLuint64, GetTextureHandleARB,texture)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLuint64, GetTextureSamplerHandleARB, GLuint texture, GLuint sampler) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLuint64, GetTextureSamplerHandleARB,texture,sampler)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLuint64, GetTextureSamplerHandleARB, GLuint texture, GLuint sampler) DECLARE_GL_FUNCTION_STUB_END(GLuint64, GetTextureSamplerHandleARB,texture,sampler)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MakeTextureHandleResidentARB, GLuint64 handle) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MakeTextureHandleResidentARB,handle)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MakeTextureHandleNonResidentARB, GLuint64 handle) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MakeTextureHandleNonResidentARB,handle)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLuint64, GetImageHandleARB, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum format) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLuint64, GetImageHandleARB,texture,level,layered,layer,format)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLuint64, GetImageHandleARB, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum format) DECLARE_GL_FUNCTION_STUB_END(GLuint64, GetImageHandleARB,texture,level,layered,layer,format)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MakeImageHandleResidentARB, GLuint64 handle, GLenum access) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MakeImageHandleResidentARB,handle,access)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MakeImageHandleNonResidentARB, GLuint64 handle) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MakeImageHandleNonResidentARB,handle)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, UniformHandleui64ARB, GLint location, GLuint64 value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, UniformHandleui64ARB,location,value)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, UniformHandleui64vARB, GLint location, GLsizei count, const GLuint64* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, UniformHandleui64vARB,location,count,value)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ProgramUniformHandleui64ARB, GLuint program, GLint location, GLuint64 value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ProgramUniformHandleui64ARB,program,location,value)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ProgramUniformHandleui64vARB, GLuint program, GLint location, GLsizei count, const GLuint64* values) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ProgramUniformHandleui64vARB,program,location,count,values)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsTextureHandleResidentARB, GLuint64 handle) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, IsTextureHandleResidentARB,handle)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsTextureHandleResidentARB, GLuint64 handle) DECLARE_GL_FUNCTION_STUB_END(GLboolean, IsTextureHandleResidentARB,handle)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsImageHandleResidentARB, GLuint64 handle) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, IsImageHandleResidentARB,handle)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsImageHandleResidentARB, GLuint64 handle) DECLARE_GL_FUNCTION_STUB_END(GLboolean, IsImageHandleResidentARB,handle)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, VertexAttribL1ui64ARB, GLuint index, GLuint64EXT x) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, VertexAttribL1ui64ARB,index,x)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, VertexAttribL1ui64vARB, GLuint index, const GLuint64EXT* v) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, VertexAttribL1ui64vARB,index,v)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetVertexAttribLui64vARB, GLuint index, GLenum pname, GLuint64EXT* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetVertexAttribLui64vARB,index,pname,params)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLsync, CreateSyncFromCLeventARB,struct _cl_context *context, struct _cl_event *event, GLbitfield flags) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLsync, CreateSyncFromCLeventARB,context,event,flags)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLsync, CreateSyncFromCLeventARB,struct _cl_context *context, struct _cl_event *event, GLbitfield flags) DECLARE_GL_FUNCTION_STUB_END(GLsync, CreateSyncFromCLeventARB,context,event,flags)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ClampColorARB, GLenum target, GLenum clamp) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ClampColorARB,target,clamp)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DispatchComputeGroupSizeARB, GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z, GLuint group_size_x, GLuint group_size_y, GLuint group_size_z) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DispatchComputeGroupSizeARB,num_groups_x,num_groups_y,num_groups_z,group_size_x,group_size_y,group_size_z)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ProgramStringARB, GLenum target, GLenum format, GLsizei len, const void* string) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ProgramStringARB,target,format,len,string)
@@ -1246,10 +1246,10 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, FramebufferSampleLocationsfvARB, GLenum targ
 DECLARE_GL_FUNCTION_STUB_HEAD(void, NamedFramebufferSampleLocationsfvARB, GLuint framebuffer, GLuint start, GLsizei count, const GLfloat* v) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, NamedFramebufferSampleLocationsfvARB,framebuffer,start,count,v)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, EvaluateDepthValuesARB,void) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, EvaluateDepthValuesARB,)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DeleteObjectARB, GLhandleARB obj) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DeleteObjectARB,obj)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLhandleARB, GetHandleARB, GLenum pname) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLhandleARB, GetHandleARB,pname)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLhandleARB, GetHandleARB, GLenum pname) DECLARE_GL_FUNCTION_STUB_END(GLhandleARB, GetHandleARB,pname)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DetachObjectARB, GLhandleARB containerObj, GLhandleARB attachedObj) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DetachObjectARB,containerObj,attachedObj)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLhandleARB, CreateShaderObjectARB, GLenum shaderType) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLhandleARB, CreateShaderObjectARB,shaderType)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLhandleARB, CreateShaderObjectARB, GLenum shaderType) DECLARE_GL_FUNCTION_STUB_END(GLhandleARB, CreateShaderObjectARB,shaderType)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLhandleARB, CreateProgramObjectARB,void) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLhandleARB, CreateProgramObjectARB,)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLhandleARB, CreateProgramObjectARB,void) DECLARE_GL_FUNCTION_STUB_END(GLhandleARB, CreateProgramObjectARB,)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, AttachObjectARB, GLhandleARB containerObj, GLhandleARB obj) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, AttachObjectARB,containerObj,obj)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, UseProgramObjectARB, GLhandleARB programObj) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, UseProgramObjectARB,programObj)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetObjectParameterfvARB, GLhandleARB obj, GLenum pname, GLfloat* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetObjectParameterfvARB,obj,pname,params)
@@ -1259,7 +1259,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, GetAttachedObjectsARB, GLhandleARB container
 DECLARE_GL_FUNCTION_STUB_HEAD(void, NamedStringARB, GLenum type, GLint namelen, const GLchar* name, GLint strinen, const GLchar* string) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, NamedStringARB,type,namelen,name,strinen,string)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DeleteNamedStringARB, GLint namelen, const GLchar* name) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DeleteNamedStringARB,namelen,name)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, CompileShaderIncludeARB, GLuint shader, GLsizei count, const GLchar* const*path, const GLint* length) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, CompileShaderIncludeARB,shader,count,path,length)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsNamedStringARB, GLint namelen, const GLchar* name) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, IsNamedStringARB,namelen,name)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsNamedStringARB, GLint namelen, const GLchar* name) DECLARE_GL_FUNCTION_STUB_END(GLboolean, IsNamedStringARB,namelen,name)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetNamedStringARB, GLint namelen, const GLchar* name, GLsizei bufSize, GLint* strinen, GLchar* string) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetNamedStringARB,namelen,name,bufSize,strinen,string)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetNamedStringivARB, GLint namelen, const GLchar* name, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetNamedStringivARB,namelen,name,pname,params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, BufferPageCommitmentARB, GLenum target, GLintptr offset, GLsizeiptr size, GLboolean commit) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BufferPageCommitmentARB,target,offset,size,commit)
@@ -1458,7 +1458,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, Vertex3xOES, GLfixed x, GLfixed y) DECLARE_G
 DECLARE_GL_FUNCTION_STUB_HEAD(void, Vertex3xvOES,const GLfixed* coords) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, Vertex3xvOES,coords)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, Vertex4xOES, GLfixed x, GLfixed y, GLfixed z) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, Vertex4xOES,x,y,z)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, Vertex4xvOES,const GLfixed* coords) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, Vertex4xvOES,coords)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLbitfield, QueryMatrixxOES, GLfixed* mantissa, GLint* exponent) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLbitfield, QueryMatrixxOES,mantissa,exponent)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLbitfield, QueryMatrixxOES, GLfixed* mantissa, GLint* exponent) DECLARE_GL_FUNCTION_STUB_END(GLbitfield, QueryMatrixxOES,mantissa,exponent)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ClearDepthfOES, GLclampf depth) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ClearDepthfOES,depth)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ClipPlanefOES, GLenum plane, const GLfloat* equation) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ClipPlanefOES,plane,equation)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DepthRangefOES, GLclampf n, GLclampf f) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DepthRangefOES,n,f)
@@ -1469,7 +1469,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, TbufferMask3DFX, GLuint mask) DECLARE_GL_FUN
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DebugMessageEnableAMD, GLenum category, GLenum severity, GLsizei count, const GLuint* ids, GLboolean enabled) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DebugMessageEnableAMD,category,severity,count,ids,enabled)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DebugMessageInsertAMD, GLenum category, GLenum severity, GLuint id, GLsizei length, const GLchar* buf) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DebugMessageInsertAMD,category,severity,id,length,buf)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DebugMessageCallbackAMD, GLDEBUGPROCAMD callback, void* userParam) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DebugMessageCallbackAMD,callback,userParam)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, GetDebugMessageLogAMD, GLuint count, GLsizei bufSize, GLenum* categories, GLuint* severities, GLuint* ids, GLsizei* lengths, GLchar* message) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLuint, GetDebugMessageLogAMD,count,bufSize,categories,severities,ids,lengths,message)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, GetDebugMessageLogAMD, GLuint count, GLsizei bufSize, GLenum* categories, GLuint* severities, GLuint* ids, GLsizei* lengths, GLchar* message) DECLARE_GL_FUNCTION_STUB_END(GLuint, GetDebugMessageLogAMD,count,bufSize,categories,severities,ids,lengths,message)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, BlendFuncIndexedAMD, GLuint buf, GLenum src, GLenum dst) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BlendFuncIndexedAMD,buf,src,dst)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, BlendFuncSeparateIndexedAMD, GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BlendFuncSeparateIndexedAMD,buf,srcRGB,dstRGB,srcAlpha,dstAlpha)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, BlendEquationIndexedAMD, GLuint buf, GLenum mode) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BlendEquationIndexedAMD,buf,mode)
@@ -1519,7 +1519,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, MultiDrawArraysIndirectAMD, GLenum mode, con
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MultiDrawElementsIndirectAMD, GLenum mode, GLenum type, const void* indirect, GLsizei primcount, GLsizei stride) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MultiDrawElementsIndirectAMD,mode,type,indirect,primcount,stride)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GenNamesAMD, GLenum identifier, GLuint num, GLuint* names) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GenNamesAMD,identifier,num,names)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DeleteNamesAMD, GLenum identifier, GLuint num, const GLuint* names) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DeleteNamesAMD,identifier,num,names)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsNameAMD, GLenum identifier, GLuint name) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, IsNameAMD,identifier,name)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsNameAMD, GLenum identifier, GLuint name) DECLARE_GL_FUNCTION_STUB_END(GLboolean, IsNameAMD,identifier,name)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, QueryObjectParameteruiAMD, GLenum target, GLuint id, GLenum pname, GLuint param) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, QueryObjectParameteruiAMD,target,id,pname,param)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetPerfMonitorGroupsAMD, GLint* numGroups, GLsizei groupsSize, GLuint* groups) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetPerfMonitorGroupsAMD,numGroups,groupsSize,groups)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetPerfMonitorCountersAMD, GLuint group, GLint* numCounters, GLint* maxActiveCounters, GLsizei counterSize, GLuint* counters) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetPerfMonitorCountersAMD,group,numCounters,maxActiveCounters,counterSize,counters)
@@ -1546,28 +1546,28 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, MultiDrawRangeElementArrayAPPLE, GLenum mode
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GenFencesAPPLE, GLsizei n, GLuint* fences) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GenFencesAPPLE,n,fences)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DeleteFencesAPPLE, GLsizei n, const GLuint* fences) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DeleteFencesAPPLE,n,fences)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, SetFenceAPPLE, GLuint fence) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, SetFenceAPPLE,fence)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsFenceAPPLE, GLuint fence) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, IsFenceAPPLE,fence)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsFenceAPPLE, GLuint fence) DECLARE_GL_FUNCTION_STUB_END(GLboolean, IsFenceAPPLE,fence)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, TestFenceAPPLE, GLuint fence) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, TestFenceAPPLE,fence)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, TestFenceAPPLE, GLuint fence) DECLARE_GL_FUNCTION_STUB_END(GLboolean, TestFenceAPPLE,fence)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, FinishFenceAPPLE, GLuint fence) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, FinishFenceAPPLE,fence)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, TestObjectAPPLE, GLenum object, GLuint name) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, TestObjectAPPLE,object,name)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, TestObjectAPPLE, GLenum object, GLuint name) DECLARE_GL_FUNCTION_STUB_END(GLboolean, TestObjectAPPLE,object,name)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, FinishObjectAPPLE, GLenum object, GLint name) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, FinishObjectAPPLE,object,name)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, BufferParameteriAPPLE, GLenum target, GLenum pname, GLint param) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BufferParameteriAPPLE,target,pname,param)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, FlushMappedBufferRangeAPPLE, GLenum target, GLintptr offset, GLsizeiptr size) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, FlushMappedBufferRangeAPPLE,target,offset,size)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLenum, ObjectPurgeableAPPLE, GLenum objectType, GLuint name, GLenum option) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLenum, ObjectPurgeableAPPLE,objectType,name,option)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLenum, ObjectPurgeableAPPLE, GLenum objectType, GLuint name, GLenum option) DECLARE_GL_FUNCTION_STUB_END(GLenum, ObjectPurgeableAPPLE,objectType,name,option)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLenum, ObjectUnpurgeableAPPLE, GLenum objectType, GLuint name, GLenum option) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLenum, ObjectUnpurgeableAPPLE,objectType,name,option)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLenum, ObjectUnpurgeableAPPLE, GLenum objectType, GLuint name, GLenum option) DECLARE_GL_FUNCTION_STUB_END(GLenum, ObjectUnpurgeableAPPLE,objectType,name,option)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetObjectParameterivAPPLE, GLenum objectType, GLuint name, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetObjectParameterivAPPLE,objectType,name,pname,params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, TextureRangeAPPLE, GLenum target, GLsizei length, const void* pointer) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, TextureRangeAPPLE,target,length,pointer)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetTexParameterPointervAPPLE, GLenum target, GLenum pname, void* *params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetTexParameterPointervAPPLE,target,pname,*params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, BindVertexArrayAPPLE, GLuint array) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BindVertexArrayAPPLE,array)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DeleteVertexArraysAPPLE, GLsizei n, const GLuint* arrays) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DeleteVertexArraysAPPLE,n,arrays)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GenVertexArraysAPPLE, GLsizei n, GLuint* arrays) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GenVertexArraysAPPLE,n,arrays)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsVertexArrayAPPLE, GLuint array) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, IsVertexArrayAPPLE,array)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsVertexArrayAPPLE, GLuint array) DECLARE_GL_FUNCTION_STUB_END(GLboolean, IsVertexArrayAPPLE,array)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, VertexArrayRangeAPPLE, GLsizei length, void* pointer) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, VertexArrayRangeAPPLE,length,pointer)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, FlushVertexArrayRangeAPPLE, GLsizei length, void* pointer) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, FlushVertexArrayRangeAPPLE,length,pointer)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, VertexArrayParameteriAPPLE, GLenum pname, GLint param) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, VertexArrayParameteriAPPLE,pname,param)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, EnableVertexAttribAPPLE, GLuint index, GLenum pname) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, EnableVertexAttribAPPLE,index,pname)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DisableVertexAttribAPPLE, GLuint index, GLenum pname) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DisableVertexAttribAPPLE,index,pname)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsVertexAttribEnabledAPPLE, GLuint index, GLenum pname) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, IsVertexAttribEnabledAPPLE,index,pname)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsVertexAttribEnabledAPPLE, GLuint index, GLenum pname) DECLARE_GL_FUNCTION_STUB_END(GLboolean, IsVertexAttribEnabledAPPLE,index,pname)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MapVertexAttrib1dAPPLE, GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MapVertexAttrib1dAPPLE,index,size,u1,u2,stride,order,points)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MapVertexAttrib1fAPPLE, GLuint index, GLuint size, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MapVertexAttrib1fAPPLE,index,size,u1,u2,stride,order,points)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MapVertexAttrib2dAPPLE, GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MapVertexAttrib2dAPPLE,index,size,u1,u2,ustride,uorder,v1,v2,vstride,vorder,points)
@@ -1580,7 +1580,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, TexBumpParameterivATI, GLenum pname, const G
 DECLARE_GL_FUNCTION_STUB_HEAD(void, TexBumpParameterfvATI, GLenum pname, const GLfloat* param) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, TexBumpParameterfvATI,pname,param)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetTexBumpParameterivATI, GLenum pname, GLint* param) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetTexBumpParameterivATI,pname,param)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetTexBumpParameterfvATI, GLenum pname, GLfloat* param) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetTexBumpParameterfvATI,pname,param)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, GenFragmentShadersATI, GLuint range) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLuint, GenFragmentShadersATI,range)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, GenFragmentShadersATI, GLuint range) DECLARE_GL_FUNCTION_STUB_END(GLuint, GenFragmentShadersATI,range)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, BindFragmentShaderATI, GLuint id) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BindFragmentShaderATI,id)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DeleteFragmentShaderATI, GLuint id) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DeleteFragmentShaderATI,id)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, BeginFragmentShaderATI,void) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BeginFragmentShaderATI,)
@@ -1599,8 +1599,8 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, PNTrianesiATI, GLenum pname, GLint param) DE
 DECLARE_GL_FUNCTION_STUB_HEAD(void, PNTrianesfATI, GLenum pname, GLfloat param) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PNTrianesfATI,pname,param)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, StencilOpSeparateATI, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, StencilOpSeparateATI,face,sfail,dpfail,dppass)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, StencilFuncSeparateATI, GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, StencilFuncSeparateATI,frontfunc,backfunc,ref,mask)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, NewObjectBufferATI, GLsizei size, const void* pointer, GLenum usage) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLuint, NewObjectBufferATI,size,pointer,usage)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, NewObjectBufferATI, GLsizei size, const void* pointer, GLenum usage) DECLARE_GL_FUNCTION_STUB_END(GLuint, NewObjectBufferATI,size,pointer,usage)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsObjectBufferATI, GLuint buffer) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, IsObjectBufferATI,buffer)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsObjectBufferATI, GLuint buffer) DECLARE_GL_FUNCTION_STUB_END(GLboolean, IsObjectBufferATI,buffer)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, UpdateObjectBufferATI, GLuint buffer, GLuint offset, GLsizei size, const void* pointer, GLenum preserve) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, UpdateObjectBufferATI,buffer,offset,size,pointer,preserve)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetObjectBufferfvATI, GLuint buffer, GLenum pname, GLfloat* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetObjectBufferfvATI,buffer,pname,params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetObjectBufferivATI, GLuint buffer, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetObjectBufferivATI,buffer,pname,params)
@@ -1662,8 +1662,8 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, VertexBlendEnvfATI, GLenum pname, GLfloat pa
 DECLARE_GL_FUNCTION_STUB_HEAD(void, EGLImageTargetTexStorageEXT, GLenum target, GLeglImageOES image, const GLint*  attrib_list) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, EGLImageTargetTexStorageEXT,target,image,attrib_list)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, EGLImageTargetTextureStorageEXT, GLuint texture, GLeglImageOES image, const GLint*  attrib_list) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, EGLImageTargetTextureStorageEXT,texture,image,attrib_list)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, UniformBufferEXT, GLuint program, GLint location, GLuint buffer) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, UniformBufferEXT,program,location,buffer)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLint, GetUniformBufferSizeEXT, GLuint program, GLint location) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLint, GetUniformBufferSizeEXT,program,location)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLint, GetUniformBufferSizeEXT, GLuint program, GLint location) DECLARE_GL_FUNCTION_STUB_END(GLint, GetUniformBufferSizeEXT,program,location)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLintptr, GetUniformOffsetEXT, GLuint program, GLint location) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLintptr, GetUniformOffsetEXT,program,location)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLintptr, GetUniformOffsetEXT, GLuint program, GLint location) DECLARE_GL_FUNCTION_STUB_END(GLintptr, GetUniformOffsetEXT,program,location)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ColorSubTableEXT, GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void* data) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ColorSubTableEXT,target,start,count,format,type,data)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, CopyColorSubTableEXT, GLenum target, GLsizei start, GLint x, GLint y, GLsizei width) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, CopyColorSubTableEXT,target,start,x,y,width)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, LockArraysEXT, GLint first, GLsizei count) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, LockArraysEXT,first,count)
@@ -1793,7 +1793,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, GetDoubleIndexedvEXT, GLenum target, GLuint
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetPointerIndexedvEXT, GLenum target, GLuint index, void* *data) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetPointerIndexedvEXT,target,index,*data)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, EnableIndexedEXT, GLenum target, GLuint index) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, EnableIndexedEXT,target,index)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DisableIndexedEXT, GLenum target, GLuint index) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DisableIndexedEXT,target,index)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsEnabledIndexedEXT, GLenum target, GLuint index) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, IsEnabledIndexedEXT,target,index)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsEnabledIndexedEXT, GLenum target, GLuint index) DECLARE_GL_FUNCTION_STUB_END(GLboolean, IsEnabledIndexedEXT,target,index)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetIntegerIndexedvEXT, GLenum target, GLuint index, GLint* data) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetIntegerIndexedvEXT,target,index,data)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetBooleanIndexedvEXT, GLenum target, GLuint index, GLboolean* data) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetBooleanIndexedvEXT,target,index,data)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, CompressedTextureImage3DEXT, GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void* bits) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, CompressedTextureImage3DEXT,texture,target,level,internalformat,width,height,depth,border,imageSize,bits)
@@ -1816,7 +1816,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, MatrixMultTransposefEXT, GLenum mode, const
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MatrixMultTransposedEXT, GLenum mode, const GLdouble* m) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MatrixMultTransposedEXT,mode,m)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, NamedBufferDataEXT, GLuint buffer, GLsizeiptr size, const void* data, GLenum usage) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, NamedBufferDataEXT,buffer,size,data,usage)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, NamedBufferSubDataEXT, GLuint buffer, GLintptr offset, GLsizeiptr size, const void* data) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, NamedBufferSubDataEXT,buffer,offset,size,data)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, UnmapNamedBufferEXT, GLuint buffer) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, UnmapNamedBufferEXT,buffer)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, UnmapNamedBufferEXT, GLuint buffer) DECLARE_GL_FUNCTION_STUB_END(GLboolean, UnmapNamedBufferEXT,buffer)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetNamedBufferParameterivEXT, GLuint buffer, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetNamedBufferParameterivEXT,buffer,pname,params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetNamedBufferPointervEXT, GLuint buffer, GLenum pname, void* *params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetNamedBufferPointervEXT,buffer,pname,*params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetNamedBufferSubDataEXT, GLuint buffer, GLintptr offset, GLsizeiptr size, void* data) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetNamedBufferSubDataEXT,buffer,offset,size,data)
@@ -1857,7 +1857,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, NamedRenderbufferStorageEXT, GLuint renderbu
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetNamedRenderbufferParameterivEXT, GLuint renderbuffer, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetNamedRenderbufferParameterivEXT,renderbuffer,pname,params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, NamedRenderbufferStorageMultisampleEXT, GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, NamedRenderbufferStorageMultisampleEXT,renderbuffer,samples,internalformat,width,height)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, NamedRenderbufferStorageMultisampleCoverageEXT, GLuint renderbuffer, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, NamedRenderbufferStorageMultisampleCoverageEXT,renderbuffer,coverageSamples,colorSamples,internalformat,width,height)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLenum, CheckNamedFramebufferStatusEXT, GLuint framebuffer, GLenum target) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLenum, CheckNamedFramebufferStatusEXT,framebuffer,target)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLenum, CheckNamedFramebufferStatusEXT, GLuint framebuffer, GLenum target) DECLARE_GL_FUNCTION_STUB_END(GLenum, CheckNamedFramebufferStatusEXT,framebuffer,target)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, NamedFramebufferTexture1DEXT, GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, NamedFramebufferTexture1DEXT,framebuffer,attachment,textarget,texture,level)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, NamedFramebufferTexture2DEXT, GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, NamedFramebufferTexture2DEXT,framebuffer,attachment,textarget,texture,level)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, NamedFramebufferTexture3DEXT, GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, NamedFramebufferTexture3DEXT,framebuffer,attachment,textarget,texture,level,zoffset)
@@ -1978,7 +1978,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, TextureMaterialEXT, GLenum face, GLenum mode
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetUnsignedBytevEXT, GLenum pname, GLubyte* data) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetUnsignedBytevEXT,pname,data)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetUnsignedBytei_vEXT, GLenum target, GLuint index, GLubyte* data) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetUnsignedBytei_vEXT,target,index,data)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DeleteMemoryObjectsEXT, GLsizei n, const GLuint* memoryObjects) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DeleteMemoryObjectsEXT,n,memoryObjects)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsMemoryObjectEXT, GLuint memoryObject) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, IsMemoryObjectEXT,memoryObject)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsMemoryObjectEXT, GLuint memoryObject) DECLARE_GL_FUNCTION_STUB_END(GLboolean, IsMemoryObjectEXT,memoryObject)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, CreateMemoryObjectsEXT, GLsizei n, GLuint* memoryObjects) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, CreateMemoryObjectsEXT,n,memoryObjects)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MemoryObjectParameterivEXT, GLuint memoryObject, GLenum pname, const GLint* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MemoryObjectParameterivEXT,memoryObject,pname,params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetMemoryObjectParameterivEXT, GLuint memoryObject, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetMemoryObjectParameterivEXT,memoryObject,pname,params)
@@ -2035,7 +2035,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, SecondaryColor3usvEXT,const GLushort* v) DEC
 DECLARE_GL_FUNCTION_STUB_HEAD(void, SecondaryColorPointerEXT, GLint size, GLenum type, GLsizei stride, const void* pointer) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, SecondaryColorPointerEXT,size,type,stride,pointer)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GenSemaphoresEXT, GLsizei n, GLuint* semaphores) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GenSemaphoresEXT,n,semaphores)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DeleteSemaphoresEXT, GLsizei n, const GLuint* semaphores) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DeleteSemaphoresEXT,n,semaphores)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsSemaphoreEXT, GLuint semaphore) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, IsSemaphoreEXT,semaphore)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsSemaphoreEXT, GLuint semaphore) DECLARE_GL_FUNCTION_STUB_END(GLboolean, IsSemaphoreEXT,semaphore)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, SemaphoreParameterui64vEXT, GLuint semaphore, GLenum pname, const GLuint64* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, SemaphoreParameterui64vEXT,semaphore,pname,params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetSemaphoreParameterui64vEXT, GLuint semaphore, GLenum pname, GLuint64* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetSemaphoreParameterui64vEXT,semaphore,pname,params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, WaitSemaphoreEXT, GLuint semaphore, GLuint numBufferBarriers, const GLuint* buffers, GLuint numTextureBarriers, const GLuint* textures, const GLenum* srcLayouts) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, WaitSemaphoreEXT,semaphore,numBufferBarriers,buffers,numTextureBarriers,textures,srcLayouts)
@@ -2045,14 +2045,14 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, ImportSemaphoreWin32HandleEXT, GLuint semaph
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ImportSemaphoreWin32NameEXT, GLuint semaphore, GLenum handleType, const void* name) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ImportSemaphoreWin32NameEXT,semaphore,handleType,name)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, UseShaderProgramEXT, GLenum type, GLuint program) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, UseShaderProgramEXT,type,program)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ActiveProgramEXT, GLuint program) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ActiveProgramEXT,program)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, CreateShaderProgramEXT, GLenum type, const GLchar* string) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLuint, CreateShaderProgramEXT,type,string)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, CreateShaderProgramEXT, GLenum type, const GLchar* string) DECLARE_GL_FUNCTION_STUB_END(GLuint, CreateShaderProgramEXT,type,string)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, FramebufferFetchBarrierEXT,void) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, FramebufferFetchBarrierEXT,)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, StencilClearTagEXT, GLsizei stencilTagBits, GLuint stencilClearTag) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, StencilClearTagEXT,stencilTagBits,stencilClearTag)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ActiveStencilFaceEXT, GLenum face) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ActiveStencilFaceEXT,face)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, TexSubImage1DEXT, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void* pixels) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, TexSubImage1DEXT,target,level,xoffset,width,format,type,pixels)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ClearColorIiEXT, GLint red, GLint green, GLint blue, GLint alpha) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ClearColorIiEXT,red,green,blue,alpha)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ClearColorIuiEXT, GLuint red, GLuint green, GLuint blue, GLuint alpha) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ClearColorIuiEXT,red,green,blue,alpha)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, AreTexturesResidentEXT, GLsizei n, const GLuint* textures, GLboolean* residences) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, AreTexturesResidentEXT,n,textures,residences)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, AreTexturesResidentEXT, GLsizei n, const GLuint* textures, GLboolean* residences) DECLARE_GL_FUNCTION_STUB_END(GLboolean, AreTexturesResidentEXT,n,textures,residences)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, PrioritizeTexturesEXT, GLsizei n, const GLuint* textures, const GLclampf* priorities) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PrioritizeTexturesEXT,n,textures,priorities)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, TextureNormalEXT, GLenum mode) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, TextureNormalEXT,mode)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, TexStorage1DEXT, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, TexStorage1DEXT,target,levels,internalformat,width)
@@ -2079,7 +2079,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, GetVertexAttribLdvEXT, GLuint index, GLenum
 DECLARE_GL_FUNCTION_STUB_HEAD(void, BeginVertexShaderEXT,void) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BeginVertexShaderEXT,)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, EndVertexShaderEXT,void) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, EndVertexShaderEXT,)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, BindVertexShaderEXT, GLuint id) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BindVertexShaderEXT,id)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, GenVertexShadersEXT, GLuint range) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLuint, GenVertexShadersEXT,range)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, GenVertexShadersEXT, GLuint range) DECLARE_GL_FUNCTION_STUB_END(GLuint, GenVertexShadersEXT,range)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DeleteVertexShaderEXT, GLuint id) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DeleteVertexShaderEXT,id)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ShaderOp1EXT, GLenum op, GLuint res, GLuint arg1) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ShaderOp1EXT,op,res,arg1)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ShaderOp2EXT, GLenum op, GLuint res, GLuint arg1, GLuint arg2) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ShaderOp2EXT,op,res,arg1,arg2)
@@ -2088,7 +2088,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, SwizzleEXT, GLuint res, GLuint in, GLenum ou
 DECLARE_GL_FUNCTION_STUB_HEAD(void, WriteMaskEXT, GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, WriteMaskEXT,res,in,outX,outY,outZ,outW)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, InsertComponentEXT, GLuint res, GLuint src, GLuint num) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, InsertComponentEXT,res,src,num)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ExtractComponentEXT, GLuint res, GLuint src, GLuint num) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ExtractComponentEXT,res,src,num)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, GenSymbolsEXT, GLenum datatype, GLenum storagetype, GLenum range, GLuint components) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLuint, GenSymbolsEXT,datatype,storagetype,range,components)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, GenSymbolsEXT, GLenum datatype, GLenum storagetype, GLenum range, GLuint components) DECLARE_GL_FUNCTION_STUB_END(GLuint, GenSymbolsEXT,datatype,storagetype,range,components)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, SetInvariantEXT, GLuint id, GLenum type, const void* addr) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, SetInvariantEXT,id,type,addr)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, SetLocalConstantEXT, GLuint id, GLenum type, const void* addr) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, SetLocalConstantEXT,id,type,addr)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, VariantbvEXT, GLuint id, const GLbyte* addr) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, VariantbvEXT,id,addr)
@@ -2102,12 +2102,12 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, VariantuivEXT, GLuint id, const GLuint* addr
 DECLARE_GL_FUNCTION_STUB_HEAD(void, VariantPointerEXT, GLuint id, GLenum type, GLuint stride, const void* addr) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, VariantPointerEXT,id,type,stride,addr)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, EnableVariantClientStateEXT, GLuint id) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, EnableVariantClientStateEXT,id)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DisableVariantClientStateEXT, GLuint id) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DisableVariantClientStateEXT,id)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, BindLightParameterEXT, GLenum light, GLenum value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLuint, BindLightParameterEXT,light,value)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, BindLightParameterEXT, GLenum light, GLenum value) DECLARE_GL_FUNCTION_STUB_END(GLuint, BindLightParameterEXT,light,value)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, BindMaterialParameterEXT, GLenum face, GLenum value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLuint, BindMaterialParameterEXT,face,value)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, BindMaterialParameterEXT, GLenum face, GLenum value) DECLARE_GL_FUNCTION_STUB_END(GLuint, BindMaterialParameterEXT,face,value)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, BindTexGenParameterEXT, GLenum unit, GLenum coord, GLenum value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLuint, BindTexGenParameterEXT,unit,coord,value)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, BindTexGenParameterEXT, GLenum unit, GLenum coord, GLenum value) DECLARE_GL_FUNCTION_STUB_END(GLuint, BindTexGenParameterEXT,unit,coord,value)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, BindTextureUnitParameterEXT, GLenum unit, GLenum value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLuint, BindTextureUnitParameterEXT,unit,value)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, BindTextureUnitParameterEXT, GLenum unit, GLenum value) DECLARE_GL_FUNCTION_STUB_END(GLuint, BindTextureUnitParameterEXT,unit,value)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, BindParameterEXT, GLenum value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLuint, BindParameterEXT,value)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, BindParameterEXT, GLenum value) DECLARE_GL_FUNCTION_STUB_END(GLuint, BindParameterEXT,value)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsVariantEnabledEXT, GLuint id, GLenum cap) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, IsVariantEnabledEXT,id,cap)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsVariantEnabledEXT, GLuint id, GLenum cap) DECLARE_GL_FUNCTION_STUB_END(GLboolean, IsVariantEnabledEXT,id,cap)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetVariantBooleanvEXT, GLuint id, GLenum value, GLboolean* data) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetVariantBooleanvEXT,id,value,data)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetVariantIntegervEXT, GLuint id, GLenum value, GLint* data) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetVariantIntegervEXT,id,value,data)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetVariantFloatvEXT, GLuint id, GLenum value, GLfloat* data) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetVariantFloatvEXT,id,value,data)
@@ -2121,10 +2121,10 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, GetLocalConstantFloatvEXT, GLuint id, GLenum
 DECLARE_GL_FUNCTION_STUB_HEAD(void, VertexWeightfEXT, GLfloat weight) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, VertexWeightfEXT,weight)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, VertexWeightfvEXT,const GLfloat* weight) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, VertexWeightfvEXT,weight)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, VertexWeightPointerEXT, GLint size, GLenum type, GLsizei stride, const void* pointer) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, VertexWeightPointerEXT,size,type,stride,pointer)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, AcquireKeyedMutexWin32EXT, GLuint memory, GLuint64 key, GLuint timeout) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, AcquireKeyedMutexWin32EXT,memory,key,timeout)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, AcquireKeyedMutexWin32EXT, GLuint memory, GLuint64 key, GLuint timeout) DECLARE_GL_FUNCTION_STUB_END(GLboolean, AcquireKeyedMutexWin32EXT,memory,key,timeout)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, ReleaseKeyedMutexWin32EXT, GLuint memory, GLuint64 key) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, ReleaseKeyedMutexWin32EXT,memory,key)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, ReleaseKeyedMutexWin32EXT, GLuint memory, GLuint64 key) DECLARE_GL_FUNCTION_STUB_END(GLboolean, ReleaseKeyedMutexWin32EXT,memory,key)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, WindowRectanesEXT, GLenum mode, GLsizei count, const GLint* box) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, WindowRectanesEXT,mode,count,box)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLsync, ImportSyncEXT, GLenum external_sync_type, GLintptr external_sync, GLbitfield flags) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLsync, ImportSyncEXT,external_sync_type,external_sync,flags)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLsync, ImportSyncEXT, GLenum external_sync_type, GLintptr external_sync, GLbitfield flags) DECLARE_GL_FUNCTION_STUB_END(GLsync, ImportSyncEXT,external_sync_type,external_sync,flags)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, FrameTerminatorGREMEDY,void) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, FrameTerminatorGREMEDY,)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, StringMarkerGREMEDY, GLsizei len, const void* string) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, StringMarkerGREMEDY,len,string)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ImageTransformParameteriHP, GLenum target, GLenum pname, GLint param) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ImageTransformParameteriHP,target,pname,param)
@@ -2195,12 +2195,12 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, UploadGpuMaskNVX, GLbitfield mask) DECLARE_G
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MulticastViewportArrayvNVX, GLuint gpu, GLuint first, GLsizei count, const GLfloat* v) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MulticastViewportArrayvNVX,gpu,first,count,v)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MulticastViewportPositionWScaleNVX, GLuint gpu, GLuint index, GLfloat xcoeff, GLfloat ycoeff) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MulticastViewportPositionWScaleNVX,gpu,index,xcoeff,ycoeff)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MulticastScissorArrayvNVX, GLuint gpu, GLuint first, GLsizei count, const GLint* v) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MulticastScissorArrayvNVX,gpu,first,count,v)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, AsyncCopyBufferSubDataNVX, GLsizei waitSemaphoreCount, const GLuint* waitSemaphoreArray, const GLuint64* fenceValueArray, GLuint readGpu, GLbitfield writeGpuMask, GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size, GLsizei signalSemaphoreCount, const GLuint* signalSemaphoreArray, const GLuint64* signalValueArray) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLuint, AsyncCopyBufferSubDataNVX,waitSemaphoreCount,waitSemaphoreArray,fenceValueArray,readGpu,writeGpuMask,readBuffer,writeBuffer,readOffset,writeOffset,size,signalSemaphoreCount,signalSemaphoreArray,signalValueArray)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, AsyncCopyBufferSubDataNVX, GLsizei waitSemaphoreCount, const GLuint* waitSemaphoreArray, const GLuint64* fenceValueArray, GLuint readGpu, GLbitfield writeGpuMask, GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size, GLsizei signalSemaphoreCount, const GLuint* signalSemaphoreArray, const GLuint64* signalValueArray) DECLARE_GL_FUNCTION_STUB_END(GLuint, AsyncCopyBufferSubDataNVX,waitSemaphoreCount,waitSemaphoreArray,fenceValueArray,readGpu,writeGpuMask,readBuffer,writeBuffer,readOffset,writeOffset,size,signalSemaphoreCount,signalSemaphoreArray,signalValueArray)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, AsyncCopyImageSubDataNVX, GLsizei waitSemaphoreCount, const GLuint* waitSemaphoreArray, const GLuint64* waitValueArray, GLuint srcGpu, GLbitfield dstGpuMask, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth, GLsizei signalSemaphoreCount, const GLuint* signalSemaphoreArray, const GLuint64* signalValueArray) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLuint, AsyncCopyImageSubDataNVX,waitSemaphoreCount,waitSemaphoreArray,waitValueArray,srcGpu,dstGpuMask,srcName,srcTarget,srcLevel,srcX,srcY,srcZ,dstName,dstTarget,dstLevel,dstX,dstY,dstZ,srcWidth,srcHeight,srcDepth,signalSemaphoreCount,signalSemaphoreArray,signalValueArray)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, AsyncCopyImageSubDataNVX, GLsizei waitSemaphoreCount, const GLuint* waitSemaphoreArray, const GLuint64* waitValueArray, GLuint srcGpu, GLbitfield dstGpuMask, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth, GLsizei signalSemaphoreCount, const GLuint* signalSemaphoreArray, const GLuint64* signalValueArray) DECLARE_GL_FUNCTION_STUB_END(GLuint, AsyncCopyImageSubDataNVX,waitSemaphoreCount,waitSemaphoreArray,waitValueArray,srcGpu,dstGpuMask,srcName,srcTarget,srcLevel,srcX,srcY,srcZ,dstName,dstTarget,dstLevel,dstX,dstY,dstZ,srcWidth,srcHeight,srcDepth,signalSemaphoreCount,signalSemaphoreArray,signalValueArray)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, LGPUNamedBufferSubDataNVX, GLbitfield gpuMask, GLuint buffer, GLintptr offset, GLsizeiptr size, const void* data) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, LGPUNamedBufferSubDataNVX,gpuMask,buffer,offset,size,data)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, LGPUCopyImageSubDataNVX, GLuint sourceGpu, GLbitfield destinationGpuMask, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srxY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, LGPUCopyImageSubDataNVX,sourceGpu,destinationGpuMask,srcName,srcTarget,srcLevel,srcX,srxY,srcZ,dstName,dstTarget,dstLevel,dstX,dstY,dstZ,width,height,depth)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, LGPUInterlockNVX,void) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, LGPUInterlockNVX,)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, CreateProgressFenceNVX,void) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLuint, CreateProgressFenceNVX,)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, CreateProgressFenceNVX,void) DECLARE_GL_FUNCTION_STUB_END(GLuint, CreateProgressFenceNVX,)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, SignalSemaphoreui64NVX, GLuint signalGpu, GLsizei fenceObjectCount, const GLuint* semaphoreArray, const GLuint64* fenceValueArray) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, SignalSemaphoreui64NVX,signalGpu,fenceObjectCount,semaphoreArray,fenceValueArray)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, WaitSemaphoreui64NVX, GLuint waitGpu, GLsizei fenceObjectCount, const GLuint* semaphoreArray, const GLuint64* fenceValueArray) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, WaitSemaphoreui64NVX,waitGpu,fenceObjectCount,semaphoreArray,fenceValueArray)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ClientWaitSemaphoreui64NVX, GLsizei fenceObjectCount, const GLuint* semaphoreArray, const GLuint64* fenceValueArray) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ClientWaitSemaphoreui64NVX,fenceObjectCount,semaphoreArray,fenceValueArray)
@@ -2209,35 +2209,35 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, MultiDrawArraysIndirectBindlessNV, GLenum mo
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MultiDrawElementsIndirectBindlessNV, GLenum mode, GLenum type, const void* indirect, GLsizei drawCount, GLsizei stride, GLint vertexBufferCount) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MultiDrawElementsIndirectBindlessNV,mode,type,indirect,drawCount,stride,vertexBufferCount)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MultiDrawArraysIndirectBindlessCountNV, GLenum mode, const void* indirect, GLsizei drawCount, GLsizei maxDrawCount, GLsizei stride, GLint vertexBufferCount) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MultiDrawArraysIndirectBindlessCountNV,mode,indirect,drawCount,maxDrawCount,stride,vertexBufferCount)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MultiDrawElementsIndirectBindlessCountNV, GLenum mode, GLenum type, const void* indirect, GLsizei drawCount, GLsizei maxDrawCount, GLsizei stride, GLint vertexBufferCount) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MultiDrawElementsIndirectBindlessCountNV,mode,type,indirect,drawCount,maxDrawCount,stride,vertexBufferCount)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLuint64, GetTextureHandleNV, GLuint texture) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLuint64, GetTextureHandleNV,texture)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLuint64, GetTextureHandleNV, GLuint texture) DECLARE_GL_FUNCTION_STUB_END(GLuint64, GetTextureHandleNV,texture)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLuint64, GetTextureSamplerHandleNV, GLuint texture, GLuint sampler) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLuint64, GetTextureSamplerHandleNV,texture,sampler)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLuint64, GetTextureSamplerHandleNV, GLuint texture, GLuint sampler) DECLARE_GL_FUNCTION_STUB_END(GLuint64, GetTextureSamplerHandleNV,texture,sampler)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MakeTextureHandleResidentNV, GLuint64 handle) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MakeTextureHandleResidentNV,handle)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MakeTextureHandleNonResidentNV, GLuint64 handle) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MakeTextureHandleNonResidentNV,handle)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLuint64, GetImageHandleNV, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum format) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLuint64, GetImageHandleNV,texture,level,layered,layer,format)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLuint64, GetImageHandleNV, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum format) DECLARE_GL_FUNCTION_STUB_END(GLuint64, GetImageHandleNV,texture,level,layered,layer,format)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MakeImageHandleResidentNV, GLuint64 handle, GLenum access) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MakeImageHandleResidentNV,handle,access)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MakeImageHandleNonResidentNV, GLuint64 handle) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MakeImageHandleNonResidentNV,handle)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, UniformHandleui64NV, GLint location, GLuint64 value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, UniformHandleui64NV,location,value)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, UniformHandleui64vNV, GLint location, GLsizei count, const GLuint64* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, UniformHandleui64vNV,location,count,value)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ProgramUniformHandleui64NV, GLuint program, GLint location, GLuint64 value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ProgramUniformHandleui64NV,program,location,value)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ProgramUniformHandleui64vNV, GLuint program, GLint location, GLsizei count, const GLuint64* values) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ProgramUniformHandleui64vNV,program,location,count,values)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsTextureHandleResidentNV, GLuint64 handle) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, IsTextureHandleResidentNV,handle)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsTextureHandleResidentNV, GLuint64 handle) DECLARE_GL_FUNCTION_STUB_END(GLboolean, IsTextureHandleResidentNV,handle)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsImageHandleResidentNV, GLuint64 handle) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, IsImageHandleResidentNV,handle)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsImageHandleResidentNV, GLuint64 handle) DECLARE_GL_FUNCTION_STUB_END(GLboolean, IsImageHandleResidentNV,handle)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, BlendParameteriNV, GLenum pname, GLint value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BlendParameteriNV,pname,value)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, BlendBarrierNV,void) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BlendBarrierNV,)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ViewportPositionWScaleNV, GLuint index, GLfloat xcoeff, GLfloat ycoeff) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ViewportPositionWScaleNV,index,xcoeff,ycoeff)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, CreateStatesNV, GLsizei n, GLuint* states) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, CreateStatesNV,n,states)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DeleteStatesNV, GLsizei n, const GLuint* states) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DeleteStatesNV,n,states)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsStateNV, GLuint state) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, IsStateNV,state)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsStateNV, GLuint state) DECLARE_GL_FUNCTION_STUB_END(GLboolean, IsStateNV,state)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, StateCaptureNV, GLuint state, GLenum mode) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, StateCaptureNV,state,mode)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, GetCommandHeaderNV, GLenum tokenID, GLuint size) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLuint, GetCommandHeaderNV,tokenID,size)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, GetCommandHeaderNV, GLenum tokenID, GLuint size) DECLARE_GL_FUNCTION_STUB_END(GLuint, GetCommandHeaderNV,tokenID,size)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLushort, GetStageIndexNV, GLenum shadertype) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLushort, GetStageIndexNV,shadertype)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLushort, GetStageIndexNV, GLenum shadertype) DECLARE_GL_FUNCTION_STUB_END(GLushort, GetStageIndexNV,shadertype)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DrawCommandsNV, GLenum primitiveMode, GLuint buffer, const GLintptr* indirects, const GLsizei* sizes, GLuint count) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DrawCommandsNV,primitiveMode,buffer,indirects,sizes,count)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DrawCommandsAddressNV, GLenum primitiveMode, const GLuint64* indirects, const GLsizei* sizes, GLuint count) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DrawCommandsAddressNV,primitiveMode,indirects,sizes,count)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DrawCommandsStatesNV, GLuint buffer, const GLintptr* indirects, const GLsizei* sizes, const GLuint* states, const GLuint* fbos, GLuint count) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DrawCommandsStatesNV,buffer,indirects,sizes,states,fbos,count)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DrawCommandsStatesAddressNV,const GLuint64* indirects, const GLsizei* sizes, const GLuint* states, const GLuint* fbos, GLuint count) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DrawCommandsStatesAddressNV,indirects,sizes,states,fbos,count)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, CreateCommandListsNV, GLsizei n, GLuint* lists) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, CreateCommandListsNV,n,lists)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DeleteCommandListsNV, GLsizei n, const GLuint* lists) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DeleteCommandListsNV,n,lists)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsCommandListNV, GLuint list) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, IsCommandListNV,list)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsCommandListNV, GLuint list) DECLARE_GL_FUNCTION_STUB_END(GLboolean, IsCommandListNV,list)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ListDrawCommandsStatesClientNV, GLuint list, GLuint segment, const void* *indirects, const GLsizei* sizes, const GLuint* states, const GLuint* fbos, GLuint count) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ListDrawCommandsStatesClientNV,list,segment,indirects,sizes,states,fbos,count)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, CommandListSegmentsNV, GLuint list, GLuint segments) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, CommandListSegmentsNV,list,segments)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, CompileCommandListNV, GLuint list) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, CompileCommandListNV,list)
@@ -2253,7 +2253,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, ClearDepthdNV, GLdouble depth) DECLARE_GL_FU
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DepthBoundsdNV, GLdouble zmin, GLdouble zmax) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DepthBoundsdNV,zmin,zmax)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DrawTextureNV, GLuint texture, GLuint sampler, GLfloat x0, GLfloat y0, GLfloat x1, GLfloat y1, GLfloat z, GLfloat s0, GLfloat t0, GLfloat s1, GLfloat t1) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DrawTextureNV,texture,sampler,x0,y0,x1,y1,z,s0,t0,s1,t1)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DrawVkImageNV, GLuint64 vkImage, GLuint sampler, GLfloat x0, GLfloat y0, GLfloat x1, GLfloat y1, GLfloat z, GLfloat s0, GLfloat t0, GLfloat s1, GLfloat t1) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DrawVkImageNV,vkImage,sampler,x0,y0,x1,y1,z,s0,t0,s1,t1)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLVULKANPROCNV, GetVkProcAddrNV,const GLchar* name) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLVULKANPROCNV, GetVkProcAddrNV,name)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLVULKANPROCNV, GetVkProcAddrNV,const GLchar* name) DECLARE_GL_FUNCTION_STUB_END(GLVULKANPROCNV, GetVkProcAddrNV,name)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, WaitVkSemaphoreNV, GLuint64 vkSemaphore) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, WaitVkSemaphoreNV,vkSemaphore)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, SignalVkSemaphoreNV, GLuint64 vkSemaphore) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, SignalVkSemaphoreNV,vkSemaphore)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, SignalVkFenceNV, GLuint64 vkFence) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, SignalVkFenceNV,vkFence)
@@ -2271,8 +2271,8 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, SampleMaskIndexedNV, GLuint index, GLbitfiel
 DECLARE_GL_FUNCTION_STUB_HEAD(void, TexRenderbufferNV, GLenum target, GLuint renderbuffer) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, TexRenderbufferNV,target,renderbuffer)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DeleteFencesNV, GLsizei n, const GLuint* fences) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DeleteFencesNV,n,fences)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GenFencesNV, GLsizei n, GLuint* fences) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GenFencesNV,n,fences)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsFenceNV, GLuint fence) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, IsFenceNV,fence)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsFenceNV, GLuint fence) DECLARE_GL_FUNCTION_STUB_END(GLboolean, IsFenceNV,fence)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, TestFenceNV, GLuint fence) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, TestFenceNV,fence)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, TestFenceNV, GLuint fence) DECLARE_GL_FUNCTION_STUB_END(GLboolean, TestFenceNV,fence)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetFenceivNV, GLuint fence, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetFenceivNV,fence,pname,params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, FinishFenceNV, GLuint fence) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, FinishFenceNV,fence)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, SetFenceNV, GLuint fence, GLenum condition) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, SetFenceNV,fence,condition)
@@ -2382,7 +2382,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, MultiDrawMeshTasksIndirectNV, GLintptr indir
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MultiDrawMeshTasksIndirectCountNV, GLintptr indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MultiDrawMeshTasksIndirectCountNV,indirect,drawcount,maxdrawcount,stride)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GenOcclusionQueriesNV, GLsizei n, GLuint* ids) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GenOcclusionQueriesNV,n,ids)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DeleteOcclusionQueriesNV, GLsizei n, const GLuint* ids) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DeleteOcclusionQueriesNV,n,ids)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsOcclusionQueryNV, GLuint id) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, IsOcclusionQueryNV,id)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsOcclusionQueryNV, GLuint id) DECLARE_GL_FUNCTION_STUB_END(GLboolean, IsOcclusionQueryNV,id)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, BeginOcclusionQueryNV, GLuint id) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BeginOcclusionQueryNV,id)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, EndOcclusionQueryNV,void) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, EndOcclusionQueryNV,)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetOcclusionQueryivNV, GLuint id, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetOcclusionQueryivNV,id,pname,params)
@@ -2390,9 +2390,9 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, GetOcclusionQueryuivNV, GLuint id, GLenum pn
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ProgramBufferParametersfvNV, GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLfloat* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ProgramBufferParametersfvNV,target,bindingIndex,wordIndex,count,params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ProgramBufferParametersIivNV, GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLint* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ProgramBufferParametersIivNV,target,bindingIndex,wordIndex,count,params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ProgramBufferParametersIuivNV, GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLuint* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ProgramBufferParametersIuivNV,target,bindingIndex,wordIndex,count,params)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, GenPathsNV, GLsizei range) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLuint, GenPathsNV,range)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, GenPathsNV, GLsizei range) DECLARE_GL_FUNCTION_STUB_END(GLuint, GenPathsNV,range)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DeletePathsNV, GLuint path, GLsizei range) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DeletePathsNV,path,range)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsPathNV, GLuint path) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, IsPathNV,path)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsPathNV, GLuint path) DECLARE_GL_FUNCTION_STUB_END(GLboolean, IsPathNV,path)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, PathCommandsNV, GLuint path, GLsizei numCommands, const GLubyte* commands, GLsizei numCoords, GLenum coordType, const void* coords) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PathCommandsNV,path,numCommands,commands,numCoords,coordType,coords)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, PathCoordsNV, GLuint path, GLsizei numCoords, GLenum coordType, const void* coords) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PathCoordsNV,path,numCoords,coordType,coords)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, PathSubCommandsNV, GLuint path, GLsizei commandStart, GLsizei commandsToDelete, GLsizei numCommands, const GLubyte* commands, GLsizei numCoords, GLenum coordType, const void* coords) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PathSubCommandsNV,path,commandStart,commandsToDelete,numCommands,commands,numCoords,coordType,coords)
@@ -2428,10 +2428,10 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, GetPathDashArrayNV, GLuint path, GLfloat* da
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetPathMetricsNV, GLbitfield metricQueryMask, GLsizei numPaths, GLenum pathNameType, const void* paths, GLuint pathBase, GLsizei stride, GLfloat* metrics) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetPathMetricsNV,metricQueryMask,numPaths,pathNameType,paths,pathBase,stride,metrics)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetPathMetricRangeNV, GLbitfield metricQueryMask, GLuint firstPathName, GLsizei numPaths, GLsizei stride, GLfloat* metrics) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetPathMetricRangeNV,metricQueryMask,firstPathName,numPaths,stride,metrics)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetPathSpacingNV, GLenum pathListMode, GLsizei numPaths, GLenum pathNameType, const void* paths, GLuint pathBase, GLfloat advanceScale, GLfloat kerningScale, GLenum transformType, GLfloat* returnedSpacing) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetPathSpacingNV,pathListMode,numPaths,pathNameType,paths,pathBase,advanceScale,kerningScale,transformType,returnedSpacing)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsPointInFillPathNV, GLuint path, GLuint mask, GLfloat x, GLfloat y) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, IsPointInFillPathNV,path,mask,x,y)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsPointInFillPathNV, GLuint path, GLuint mask, GLfloat x, GLfloat y) DECLARE_GL_FUNCTION_STUB_END(GLboolean, IsPointInFillPathNV,path,mask,x,y)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsPointInStrokePathNV, GLuint path, GLfloat x, GLfloat y) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, IsPointInStrokePathNV,path,x,y)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsPointInStrokePathNV, GLuint path, GLfloat x, GLfloat y) DECLARE_GL_FUNCTION_STUB_END(GLboolean, IsPointInStrokePathNV,path,x,y)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLfloat, GetPathLengthNV, GLuint path, GLsizei startSegment, GLsizei numSegments) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLfloat, GetPathLengthNV,path,startSegment,numSegments)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLfloat, GetPathLengthNV, GLuint path, GLsizei startSegment, GLsizei numSegments) DECLARE_GL_FUNCTION_STUB_END(GLfloat, GetPathLengthNV,path,startSegment,numSegments)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, PointAlongPathNV, GLuint path, GLsizei startSegment, GLsizei numSegments, GLfloat distance, GLfloat* x, GLfloat* y, GLfloat* tangentX, GLfloat* tangentY) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, PointAlongPathNV,path,startSegment,numSegments,distance,x,y,tangentX,tangentY)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, PointAlongPathNV, GLuint path, GLsizei startSegment, GLsizei numSegments, GLfloat distance, GLfloat* x, GLfloat* y, GLfloat* tangentX, GLfloat* tangentY) DECLARE_GL_FUNCTION_STUB_END(GLboolean, PointAlongPathNV,path,startSegment,numSegments,distance,x,y,tangentX,tangentY)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MatrixLoad3x2fNV, GLenum matrixMode, const GLfloat* m) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MatrixLoad3x2fNV,matrixMode,m)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MatrixLoad3x3fNV, GLenum matrixMode, const GLfloat* m) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MatrixLoad3x3fNV,matrixMode,m)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MatrixLoadTranspose3x3fNV, GLenum matrixMode, const GLfloat* m) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MatrixLoadTranspose3x3fNV,matrixMode,m)
@@ -2442,9 +2442,9 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, StencilThenCoverFillPathNV, GLuint path, GLe
 DECLARE_GL_FUNCTION_STUB_HEAD(void, StencilThenCoverStrokePathNV, GLuint path, GLint reference, GLuint mask, GLenum coverMode) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, StencilThenCoverStrokePathNV,path,reference,mask,coverMode)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, StencilThenCoverFillPathInstancedNV, GLsizei numPaths, GLenum pathNameType, const void* paths, GLuint pathBase, GLenum fillMode, GLuint mask, GLenum coverMode, GLenum transformType, const GLfloat* transformValues) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, StencilThenCoverFillPathInstancedNV,numPaths,pathNameType,paths,pathBase,fillMode,mask,coverMode,transformType,transformValues)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, StencilThenCoverStrokePathInstancedNV, GLsizei numPaths, GLenum pathNameType, const void* paths, GLuint pathBase, GLint reference, GLuint mask, GLenum coverMode, GLenum transformType, const GLfloat* transformValues) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, StencilThenCoverStrokePathInstancedNV,numPaths,pathNameType,paths,pathBase,reference,mask,coverMode,transformType,transformValues)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLenum, PathGlyphIndexRangeNV, GLenum fontTarget, const void* fontName, GLbitfield fontStyle, GLuint pathParameterTemplate, GLfloat emScale, GLuint* baseAndCount) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLenum, PathGlyphIndexRangeNV,fontTarget,fontName,fontStyle,pathParameterTemplate,emScale,baseAndCount)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLenum, PathGlyphIndexRangeNV, GLenum fontTarget, const void* fontName, GLbitfield fontStyle, GLuint pathParameterTemplate, GLfloat emScale, GLuint* baseAndCount) DECLARE_GL_FUNCTION_STUB_END(GLenum, PathGlyphIndexRangeNV,fontTarget,fontName,fontStyle,pathParameterTemplate,emScale,baseAndCount)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLenum, PathGlyphIndexArrayNV, GLuint firstPathName, GLenum fontTarget, const void* fontName, GLbitfield fontStyle, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLenum, PathGlyphIndexArrayNV,firstPathName,fontTarget,fontName,fontStyle,firstGlyphIndex,numGlyphs,pathParameterTemplate,emScale)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLenum, PathGlyphIndexArrayNV, GLuint firstPathName, GLenum fontTarget, const void* fontName, GLbitfield fontStyle, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale) DECLARE_GL_FUNCTION_STUB_END(GLenum, PathGlyphIndexArrayNV,firstPathName,fontTarget,fontName,fontStyle,firstGlyphIndex,numGlyphs,pathParameterTemplate,emScale)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLenum, PathMemoryGlyphIndexArrayNV, GLuint firstPathName, GLenum fontTarget, GLsizeiptr fontSize, const void* fontData, GLsizei faceIndex, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLenum, PathMemoryGlyphIndexArrayNV,firstPathName,fontTarget,fontSize,fontData,faceIndex,firstGlyphIndex,numGlyphs,pathParameterTemplate,emScale)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLenum, PathMemoryGlyphIndexArrayNV, GLuint firstPathName, GLenum fontTarget, GLsizeiptr fontSize, const void* fontData, GLsizei faceIndex, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale) DECLARE_GL_FUNCTION_STUB_END(GLenum, PathMemoryGlyphIndexArrayNV,firstPathName,fontTarget,fontSize,fontData,faceIndex,firstGlyphIndex,numGlyphs,pathParameterTemplate,emScale)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ProgramPathFragmentInputGenNV, GLuint program, GLint location, GLenum genMode, GLint components, const GLfloat* coeffs) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ProgramPathFragmentInputGenNV,program,location,genMode,components,coeffs)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetProgramResourcefvNV, GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum* props, GLsizei count, GLsizei* length, GLfloat* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetProgramResourcefvNV,program,programInterface,index,propCount,props,count,length,params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, PathColorGenNV, GLenum color, GLenum genMode, GLenum colorFormat, const GLfloat* coeffs) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PathColorGenNV,color,genMode,colorFormat,coeffs)
@@ -2466,7 +2466,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, GetVideoi64vNV, GLuint video_slot, GLenum pn
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetVideoui64vNV, GLuint video_slot, GLenum pname, GLuint64EXT* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetVideoui64vNV,video_slot,pname,params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, PrimitiveRestartNV,void) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PrimitiveRestartNV,)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, PrimitiveRestartIndexNV, GLuint index) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PrimitiveRestartIndexNV,index)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLint, QueryResourceNV, GLenum queryType, GLint tagId, GLuint count, GLint* buffer) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLint, QueryResourceNV,queryType,tagId,count,buffer)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLint, QueryResourceNV, GLenum queryType, GLint tagId, GLuint count, GLint* buffer) DECLARE_GL_FUNCTION_STUB_END(GLint, QueryResourceNV,queryType,tagId,count,buffer)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GenQueryResourceTagNV, GLsizei n, GLint* tagIds) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GenQueryResourceTagNV,n,tagIds)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DeleteQueryResourceTagNV, GLsizei n, const GLint* tagIds) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DeleteQueryResourceTagNV,n,tagIds)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, QueryResourceTagNV, GLint tagId, const GLchar* tagString) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, QueryResourceTagNV,tagId,tagString)
@@ -2492,10 +2492,10 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, ScissorExclusiveNV, GLint x, GLint y, GLsize
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ScissorExclusiveArrayvNV, GLuint first, GLsizei count, const GLint* v) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ScissorExclusiveArrayvNV,first,count,v)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MakeBufferResidentNV, GLenum target, GLenum access) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MakeBufferResidentNV,target,access)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MakeBufferNonResidentNV, GLenum target) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MakeBufferNonResidentNV,target)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsBufferResidentNV, GLenum target) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, IsBufferResidentNV,target)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsBufferResidentNV, GLenum target) DECLARE_GL_FUNCTION_STUB_END(GLboolean, IsBufferResidentNV,target)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MakeNamedBufferResidentNV, GLuint buffer, GLenum access) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MakeNamedBufferResidentNV,buffer,access)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MakeNamedBufferNonResidentNV, GLuint buffer) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MakeNamedBufferNonResidentNV,buffer)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsNamedBufferResidentNV, GLuint buffer) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, IsNamedBufferResidentNV,buffer)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsNamedBufferResidentNV, GLuint buffer) DECLARE_GL_FUNCTION_STUB_END(GLboolean, IsNamedBufferResidentNV,buffer)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetBufferParameterui64vNV, GLenum target, GLenum pname, GLuint64EXT* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetBufferParameterui64vNV,target,pname,params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetNamedBufferParameterui64vNV, GLuint buffer, GLenum pname, GLuint64EXT* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetNamedBufferParameterui64vNV,buffer,pname,params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetIntegerui64vNV, GLenum value, GLuint64EXT* result) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetIntegerui64vNV,value,result)
@@ -2528,28 +2528,28 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, BindBufferOffsetNV, GLenum target, GLuint in
 DECLARE_GL_FUNCTION_STUB_HEAD(void, BindBufferBaseNV, GLenum target, GLuint index, GLuint buffer) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BindBufferBaseNV,target,index,buffer)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, TransformFeedbackVaryingsNV, GLuint program, GLsizei count, const GLint* locations, GLenum bufferMode) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, TransformFeedbackVaryingsNV,program,count,locations,bufferMode)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ActiveVaryingNV, GLuint program, const GLchar* name) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ActiveVaryingNV,program,name)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLint, GetVaryingLocationNV, GLuint program, const GLchar* name) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLint, GetVaryingLocationNV,program,name)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLint, GetVaryingLocationNV, GLuint program, const GLchar* name) DECLARE_GL_FUNCTION_STUB_END(GLint, GetVaryingLocationNV,program,name)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetActiveVaryingNV, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetActiveVaryingNV,program,index,bufSize,length,size,type,name)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetTransformFeedbackVaryingNV, GLuint program, GLuint index, GLint* location) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetTransformFeedbackVaryingNV,program,index,location)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, TransformFeedbackStreamAttribsNV, GLsizei count, const GLint* attribs, GLsizei nbuffers, const GLint* bufstreams, GLenum bufferMode) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, TransformFeedbackStreamAttribsNV,count,attribs,nbuffers,bufstreams,bufferMode)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, BindTransformFeedbackNV, GLenum target, GLuint id) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BindTransformFeedbackNV,target,id)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DeleteTransformFeedbacksNV, GLsizei n, const GLuint* ids) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DeleteTransformFeedbacksNV,n,ids)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GenTransformFeedbacksNV, GLsizei n, GLuint* ids) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GenTransformFeedbacksNV,n,ids)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsTransformFeedbackNV, GLuint id) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, IsTransformFeedbackNV,id)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsTransformFeedbackNV, GLuint id) DECLARE_GL_FUNCTION_STUB_END(GLboolean, IsTransformFeedbackNV,id)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, PauseTransformFeedbackNV,void) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PauseTransformFeedbackNV,)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ResumeTransformFeedbackNV,void) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ResumeTransformFeedbackNV,)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DrawTransformFeedbackNV, GLenum mode, GLuint id) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DrawTransformFeedbackNV,mode,id)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, VDPAUInitNV,const void* vdpDevice, const void* getProcAddress) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, VDPAUInitNV,vdpDevice,getProcAddress)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, VDPAUFiniNV,void) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, VDPAUFiniNV,)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLvdpauSurfaceNV, VDPAURegisterVideoSurfaceNV,const void* vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint* textureNames) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLvdpauSurfaceNV, VDPAURegisterVideoSurfaceNV,vdpSurface,target,numTextureNames,textureNames)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLvdpauSurfaceNV, VDPAURegisterVideoSurfaceNV,const void* vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint* textureNames) DECLARE_GL_FUNCTION_STUB_END(GLvdpauSurfaceNV, VDPAURegisterVideoSurfaceNV,vdpSurface,target,numTextureNames,textureNames)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLvdpauSurfaceNV, VDPAURegisterOutputSurfaceNV,const void* vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint* textureNames) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLvdpauSurfaceNV, VDPAURegisterOutputSurfaceNV,vdpSurface,target,numTextureNames,textureNames)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLvdpauSurfaceNV, VDPAURegisterOutputSurfaceNV,const void* vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint* textureNames) DECLARE_GL_FUNCTION_STUB_END(GLvdpauSurfaceNV, VDPAURegisterOutputSurfaceNV,vdpSurface,target,numTextureNames,textureNames)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, VDPAUIsSurfaceNV, GLvdpauSurfaceNV surface) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, VDPAUIsSurfaceNV,surface)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, VDPAUIsSurfaceNV, GLvdpauSurfaceNV surface) DECLARE_GL_FUNCTION_STUB_END(GLboolean, VDPAUIsSurfaceNV,surface)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, VDPAUUnregisterSurfaceNV, GLvdpauSurfaceNV surface) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, VDPAUUnregisterSurfaceNV,surface)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, VDPAUGetSurfaceivNV, GLvdpauSurfaceNV surface, GLenum pname, GLsizei count, GLsizei* length, GLint* values) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, VDPAUGetSurfaceivNV,surface,pname,count,length,values)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, VDPAUSurfaceAccessNV, GLvdpauSurfaceNV surface, GLenum access) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, VDPAUSurfaceAccessNV,surface,access)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, VDPAUMapSurfacesNV, GLsizei numSurfaces, const GLvdpauSurfaceNV* surfaces) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, VDPAUMapSurfacesNV,numSurfaces,surfaces)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, VDPAUUnmapSurfacesNV, GLsizei numSurface, const GLvdpauSurfaceNV* surfaces) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, VDPAUUnmapSurfacesNV,numSurface,surfaces)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLvdpauSurfaceNV, VDPAURegisterVideoSurfaceWithPictureStructureNV,const void* vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint* textureNames, GLboolean isFrameStructure) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLvdpauSurfaceNV, VDPAURegisterVideoSurfaceWithPictureStructureNV,vdpSurface,target,numTextureNames,textureNames,isFrameStructure)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLvdpauSurfaceNV, VDPAURegisterVideoSurfaceWithPictureStructureNV,const void* vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint* textureNames, GLboolean isFrameStructure) DECLARE_GL_FUNCTION_STUB_END(GLvdpauSurfaceNV, VDPAURegisterVideoSurfaceWithPictureStructureNV,vdpSurface,target,numTextureNames,textureNames,isFrameStructure)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, FlushVertexArrayRangeNV,void) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, FlushVertexArrayRangeNV,)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, VertexArrayRangeNV, GLsizei length, const void* pointer) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, VertexArrayRangeNV,length,pointer)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, VertexAttribL1i64NV, GLuint index, GLint64EXT x) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, VertexAttribL1i64NV,index,x)
@@ -2583,7 +2583,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, FogCoordFormatNV, GLenum type, GLsizei strid
 DECLARE_GL_FUNCTION_STUB_HEAD(void, VertexAttribFormatNV, GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, VertexAttribFormatNV,index,size,type,normalized,stride)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, VertexAttribIFormatNV, GLuint index, GLint size, GLenum type, GLsizei stride) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, VertexAttribIFormatNV,index,size,type,stride)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetIntegerui64i_vNV, GLenum value, GLuint index, GLuint64EXT* result) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetIntegerui64i_vNV,value,index,result)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, AreProgramsResidentNV, GLsizei n, const GLuint* programs, GLboolean* residences) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, AreProgramsResidentNV,n,programs,residences)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, AreProgramsResidentNV, GLsizei n, const GLuint* programs, GLboolean* residences) DECLARE_GL_FUNCTION_STUB_END(GLboolean, AreProgramsResidentNV,n,programs,residences)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, BindProgramNV, GLenum target, GLuint id) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BindProgramNV,target,id)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DeleteProgramsNV, GLsizei n, const GLuint* programs) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DeleteProgramsNV,n,programs)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ExecuteProgramNV, GLenum target, GLuint id, const GLfloat* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ExecuteProgramNV,target,id,params)
@@ -2597,7 +2597,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, GetVertexAttribdvNV, GLuint index, GLenum pn
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetVertexAttribfvNV, GLuint index, GLenum pname, GLfloat* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetVertexAttribfvNV,index,pname,params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetVertexAttribivNV, GLuint index, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetVertexAttribivNV,index,pname,params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetVertexAttribPointervNV, GLuint index, GLenum pname, void* *pointer) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetVertexAttribPointervNV,index,pname,*pointer)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsProgramNV, GLuint id) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, IsProgramNV,id)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsProgramNV, GLuint id) DECLARE_GL_FUNCTION_STUB_END(GLboolean, IsProgramNV,id)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, LoadProgramNV, GLenum target, GLuint id, GLsizei len, const GLubyte* program) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, LoadProgramNV,target,id,len,program)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ProgramParameter4dNV, GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ProgramParameter4dNV,target,index,x,y,z,w)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ProgramParameter4dvNV, GLenum target, GLuint index, const GLdouble* v) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ProgramParameter4dvNV,target,index,v)
@@ -2655,7 +2655,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, GetVideoCaptureivNV, GLuint video_capture_sl
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetVideoCaptureStreamivNV, GLuint video_capture_slot, GLuint stream, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetVideoCaptureStreamivNV,video_capture_slot,stream,pname,params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetVideoCaptureStreamfvNV, GLuint video_capture_slot, GLuint stream, GLenum pname, GLfloat* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetVideoCaptureStreamfvNV,video_capture_slot,stream,pname,params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetVideoCaptureStreamdvNV, GLuint video_capture_slot, GLuint stream, GLenum pname, GLdouble* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetVideoCaptureStreamdvNV,video_capture_slot,stream,pname,params)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLenum, VideoCaptureNV, GLuint video_capture_slot, GLuint* sequence_num, GLuint64EXT* capture_time) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLenum, VideoCaptureNV,video_capture_slot,sequence_num,capture_time)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLenum, VideoCaptureNV, GLuint video_capture_slot, GLuint* sequence_num, GLuint64EXT* capture_time) DECLARE_GL_FUNCTION_STUB_END(GLenum, VideoCaptureNV,video_capture_slot,sequence_num,capture_time)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, VideoCaptureStreamParameterivNV, GLuint video_capture_slot, GLuint stream, GLenum pname, const GLint* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, VideoCaptureStreamParameterivNV,video_capture_slot,stream,pname,params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, VideoCaptureStreamParameterfvNV, GLuint video_capture_slot, GLuint stream, GLenum pname, const GLfloat* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, VideoCaptureStreamParameterfvNV,video_capture_slot,stream,pname,params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, VideoCaptureStreamParameterdvNV, GLuint video_capture_slot, GLuint stream, GLenum pname, const GLdouble* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, VideoCaptureStreamParameterdvNV,video_capture_slot,stream,pname,params)
@@ -2684,11 +2684,11 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, TextureColorMaskSGIS, GLboolean red, GLboole
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetTexFilterFuncSGIS, GLenum target, GLenum filter, GLfloat* weights) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetTexFilterFuncSGIS,target,filter,weights)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, TexFilterFuncSGIS, GLenum target, GLenum filter, GLsizei n, const GLfloat* weights) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, TexFilterFuncSGIS,target,filter,n,weights)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, AsyncMarkerSGIX, GLuint marker) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, AsyncMarkerSGIX,marker)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLint, FinishAsyncSGIX, GLuint* markerp) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLint, FinishAsyncSGIX,markerp)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLint, FinishAsyncSGIX, GLuint* markerp) DECLARE_GL_FUNCTION_STUB_END(GLint, FinishAsyncSGIX,markerp)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLint, PollAsyncSGIX, GLuint* markerp) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLint, PollAsyncSGIX,markerp)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLint, PollAsyncSGIX, GLuint* markerp) DECLARE_GL_FUNCTION_STUB_END(GLint, PollAsyncSGIX,markerp)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, GenAsyncMarkersSGIX, GLsizei range) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLuint, GenAsyncMarkersSGIX,range)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, GenAsyncMarkersSGIX, GLsizei range) DECLARE_GL_FUNCTION_STUB_END(GLuint, GenAsyncMarkersSGIX,range)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DeleteAsyncMarkersSGIX, GLuint marker, GLsizei range) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DeleteAsyncMarkersSGIX,marker,range)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsAsyncMarkerSGIX, GLuint marker) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLboolean, IsAsyncMarkerSGIX,marker)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsAsyncMarkerSGIX, GLuint marker) DECLARE_GL_FUNCTION_STUB_END(GLboolean, IsAsyncMarkerSGIX,marker)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, FlushRasterSGIX,void) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, FlushRasterSGIX,)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, FragmentColorMaterialSGIX, GLenum face, GLenum mode) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, FragmentColorMaterialSGIX,face,mode)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, FragmentLightfSGIX, GLenum light, GLenum pname, GLfloat param) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, FragmentLightfSGIX,light,pname,param)
@@ -2710,9 +2710,9 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, GetFragmentMaterialivSGIX, GLenum face, GLen
 DECLARE_GL_FUNCTION_STUB_HEAD(void, LightEnviSGIX, GLenum pname, GLint param) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, LightEnviSGIX,pname,param)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, FrameZoomSGIX, GLint factor) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, FrameZoomSGIX,factor)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, IooInterfaceSGIX, GLenum pname, const void* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, IooInterfaceSGIX,pname,params)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLint, GetInstrumentsSGIX,void) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLint, GetInstrumentsSGIX,)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLint, GetInstrumentsSGIX,void) DECLARE_GL_FUNCTION_STUB_END(GLint, GetInstrumentsSGIX,)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, InstrumentsBufferSGIX, GLsizei size, GLint* buffer) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, InstrumentsBufferSGIX,size,buffer)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLint, PollInstrumentsSGIX, GLint* marker_p) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(GLint, PollInstrumentsSGIX,marker_p)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLint, PollInstrumentsSGIX, GLint* marker_p) DECLARE_GL_FUNCTION_STUB_END(GLint, PollInstrumentsSGIX,marker_p)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ReadInstrumentsSGIX, GLint marker) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ReadInstrumentsSGIX,marker)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, StartInstrumentsSGIX,void) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, StartInstrumentsSGIX,)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, StopInstrumentsSGIX, GLint marker) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, StopInstrumentsSGIX,marker)

MG/MG_GL/Implementations/GL/Getter/GL_Getter.cpp

@@ -114,9 +114,15 @@ namespace MG_GL::GL {
 
     void GetIntegerv(GLenum pname, GLint *params) {
         MG_Util::Debug::LogD("glGetIntegerv, pname: %s", MG_Util::Debug::GLEnumToString(pname));
+        if (!params) {
+            MG_State::SetError(GL_INVALID_VALUE);
+            return;
+        }
+
         switch (pname) {
+            // General
             case GL_CONTEXT_PROFILE_MASK:
-                (*params) = GL_CONTEXT_CORE_PROFILE_BIT;
+                params[0] = GL_CONTEXT_CORE_PROFILE_BIT;
                 break;
             case GL_NUM_EXTENSIONS:
                 static GLint num_extensions = -1;
@@ -131,20 +137,184 @@ namespace MG_GL::GL {
                     }
                     free(copy);
                 }
-                (*params) = num_extensions;
+                params[0] = num_extensions;
                 break;
             case GL_MAJOR_VERSION:
-                (*params) = MG_Global::GL::GLVersionMajor;
+                params[0] = MG_Global::GL::GLVersionMajor;
                 break;
             case GL_MINOR_VERSION:
-                (*params) = MG_Global::GL::GLVersionMinor;
+                params[0] = MG_Global::GL::GLVersionMinor;
+                break;
+            
+            // Viewport and scissor
+            case GL_VIEWPORT:
+                memcpy(params, MG_State_T::commonState->viewport, 4 * sizeof(GLint));
+                break;
+            case GL_SCISSOR_BOX:
+                // TODO: memcpy(params, MG_State_T::commonState->scissorBox, 4 * sizeof(GLint));
+                break;
+            case GL_MAX_VIEWPORT_DIMS: {
+                static const GLint maxDims[2] = {16384, 16384};
+                memcpy(params, maxDims, sizeof(maxDims));
+                break;
+            }
+
+            // Buffer bindings
+            case GL_ARRAY_BUFFER_BINDING:
+                params[0] = static_cast<GLint>(MG_State_T::bufferState->GetCurrentBinding(GL_ARRAY_BUFFER));
+                break;
+
+            case GL_ELEMENT_ARRAY_BUFFER_BINDING:
+                params[0] = static_cast<GLint>(MG_State_T::vertexArrayState->GetBoundElementBuffer());
+                break;
+            case GL_DRAW_FRAMEBUFFER_BINDING:
+                params[0] = static_cast<GLint>(MG_State_T::framebufferState->currentBindings_[GL_DRAW_FRAMEBUFFER]);
+                break;
+            case GL_READ_FRAMEBUFFER_BINDING:
+                params[0] = static_cast<GLint>(MG_State_T::framebufferState->currentBindings_[GL_READ_FRAMEBUFFER]);
+                break;
+            case GL_RENDERBUFFER_BINDING:
+                // TODO: params[0] = static_cast<GLint>(MG_State_T::framebufferState->currentRenderbuffer_);
+                break;
+
+            // Program state
+            case GL_CURRENT_PROGRAM:
+                params[0] = static_cast<GLint>(MG_State_T::programState->currentProgram_);
+                break;
+            case GL_MAX_VERTEX_ATTRIBS:
+                // TODO: Check the real value
+                params[0] = 64;
+                break;
+                
+            // Texture state
+            case GL_TEXTURE_BINDING_2D: {
+                GLuint unit = MG_State_T::textureState->activeTextureUnit_;
+                auto& textures = MG_State_T::textureState->textureUnits_[unit].boundTextures;
+                params[0] = textures.count(GL_TEXTURE_2D) ? static_cast<GLint>(textures[GL_TEXTURE_2D]) : 0;
+                break;
+            }
+            case GL_ACTIVE_TEXTURE:
+                params[0] = GL_TEXTURE0 + MG_State_T::textureState->activeTextureUnit_;
                 break;
             case GL_MAX_TEXTURE_SIZE:
-                // TODO: Get real GL_MAX_TEXTURE_SIZE.
+                params[0] = 8192;
-                (*params) = 32768;
                 break;
+
+            // Blend state
+            case GL_BLEND_SRC_RGB:
+                params[0] = static_cast<GLint>(MG_State_T::commonState->blendSrcRGB);
+                break;
+            case GL_BLEND_DST_RGB:
+                params[0] = static_cast<GLint>(MG_State_T::commonState->blendDstRGB);
+                break;
+            case GL_BLEND_SRC_ALPHA:
+                params[0] = static_cast<GLint>(MG_State_T::commonState->blendSrcAlpha);
+                break;
+            case GL_BLEND_DST_ALPHA:
+                params[0] = static_cast<GLint>(MG_State_T::commonState->blendDstAlpha);
+                break;
+                
+            // Depth and stencil
+            case GL_DEPTH_FUNC:
+                params[0] = static_cast<GLint>(MG_State_T::commonState->depthFunc);
+                break;
+            case GL_DEPTH_WRITEMASK:
+                params[0] = static_cast<GLint>(MG_State_T::commonState->depthMask);
+                break;
+            case GL_STENCIL_REF:
+                // TODO: params[0] = MG_State_T::commonState->stencilRef;
+                break;
+
+            // Capability enables
+            case GL_BLEND:
+                params[0] = MG_State_T::commonState->capabilities[GL_BLEND] ? GL_TRUE : GL_FALSE;
+                break;
+            case GL_DEPTH_TEST:
+                params[0] = MG_State_T::commonState->capabilities[GL_DEPTH_TEST] ? GL_TRUE : GL_FALSE;
+                break;
+            case GL_SCISSOR_TEST:
+                params[0] = MG_State_T::commonState->capabilities[GL_SCISSOR_TEST] ? GL_TRUE : GL_FALSE;
+                break;
+
+            // Pixel operations
+            case GL_PACK_ALIGNMENT:
+                params[0] = MG_State_T::commonState->QueryPixelStoreInt(GL_PACK_ALIGNMENT);
+                break;
+            case GL_UNPACK_ALIGNMENT:
+                params[0] = MG_State_T::commonState->QueryPixelStoreInt(GL_UNPACK_ALIGNMENT);
+                break;
+
+            // Hardware limits, TODO: Check the real values
+            case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
+                params[0] = 32;
+                break;
+            case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
+                params[0] = 32;
+                break;
+            case GL_MAX_TEXTURE_IMAGE_UNITS:
+                params[0] = 32;
+                break;
+            case GL_MAX_RENDERBUFFER_SIZE:
+                params[0] = 65537;
+                break;
+            case GL_MAX_DRAW_BUFFERS:
+                params[0] = 32;
+                break;
+            case GL_MAX_COLOR_ATTACHMENTS:
+                params[0] = 32;
+                break;
+
+            // Color state
+            case GL_COLOR_CLEAR_VALUE: {
+                const auto& c = MG_State_T::commonState->clearColor;
+                params[0] = static_cast<GLint>(c[0] * 0x7FFF);
+                params[1] = static_cast<GLint>(c[1] * 0x7FFF);
+                params[2] = static_cast<GLint>(c[2] * 0x7FFF);
+                params[3] = static_cast<GLint>(c[3] * 0x7FFF);
+                break;
+            }
+            case GL_COLOR_WRITEMASK:
+                params[0] = MG_State_T::commonState->colorMask[0];
+                params[1] = MG_State_T::commonState->colorMask[1];
+                params[2] = MG_State_T::commonState->colorMask[2];
+                params[3] = MG_State_T::commonState->colorMask[3];
+                break;
+
+            // Stencil operations
+            case GL_STENCIL_CLEAR_VALUE:
+                // TODO: params[0] = MG_State_T::commonState->stencilClearValue;
+                break;
+            case GL_STENCIL_BITS:
+                // TODO: Check the real value
+                params[0] = 8;
+                break;
+
+           // Implementation limits
+            case GL_SUBPIXEL_BITS:
+                // TODO: Check the real value
+                params[0] = 4;
+                break;
+            case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
+                // TODO: params[0] = static_cast<GLint>(MG_State_T::textureState->compressedFormats_.size());
+                break;
+            case GL_COMPRESSED_TEXTURE_FORMATS:
+                // TODO: Implement GL_COMPRESSED_TEXTURE_FORMATS
+                break;
+
+           // Polygon state
+            case GL_POLYGON_OFFSET_FACTOR:
+                // TODO: params[0] = static_cast<GLint>(MG_State_T::commonState->polygonOffsetFactor);
+                break;
+            case GL_POLYGON_OFFSET_UNITS:
+                // TODO: params[0] = static_cast<GLint>(MG_State_T::commonState->polygonOffsetUnits);
+                break;
+
+            // Others...
             default:
+                MG_Util::Debug::LogE("glGetIntegerv: Invalid enum %s (0x%X)", MG_Util::Debug::GLEnumToString(pname), pname);
+                MG_State::SetError(GL_INVALID_ENUM);
                 break;
         }
     }
+
 }

MG/MG_GL/Implementations/GLX/GLXFuncsDefinitions/GLXFuncsDefinitions.cpp

@@ -0,0 +1,13 @@
+//
+// Created by Swung 0x48 on 2025/6/20.
+//
+
+#include "GLXFuncsDefinitions.h"
+
+MG_EXPORT void* glXGetProcAddress(const char *name) {
+    return MG_GL::GLX::GetProcAddress(name);
+}
+
+MG_EXPORT void* glXGetProcAddressARB(const char *name) {
+    return MG_GL::GLX::GetProcAddressARB(name);
+}

MG/MG_GL/Implementations/GLX/GLXFuncsDefinitions/GLXFuncsDefinitions.h

@@ -0,0 +1,10 @@
+//
+// Created by Swung 0x48 on 2025/6/20.
+//
+
+#ifndef MOBILEGL_GLX_FUNCS_DEFINITIONS_H
+#define MOBILEGL_GLX_FUNCS_DEFINITIONS_H
+
+#include "../../../../Includes.h"
+
+#endif //MOBILEGL_GLX_FUNCS_DEFINITIONS_H

MG/MG_GL/Implementations/GLX/LookUp/LookUp.cpp

@@ -8,6 +8,7 @@
 
 namespace MG_GL::GLX {
     void* GetProcAddress(const char *name) {
+        MG_Util::Debug::LogD("glXGetProcAddress(\"%s\")", name);
         void* proc = dlsym(RTLD_DEFAULT, (const char*)name);
 
         if (!proc) {

MG/MG_GL/State/Buffer/BufferState.cpp

@@ -56,31 +56,10 @@ GLenum BufferState::Create(GLuint buffer) {
     return GL_NO_ERROR;
 }
 
-//GLenum BufferState::CreateN(GLsizei n, GLuint* buffers) {
-//    MG_Util::Debug::LogD("MG_State: Buffer: CreateN called with n=%d", n);
-//    if (n < 0) return GL_INVALID_VALUE;
-//
-//    for (GLsizei i = 0; i < n; ++i) {
-//        GLenum result = Create(&buffers[i]);
-//        if (result != GL_NO_ERROR) {
-//            MG_Util::Debug::LogE("MG_State: Buffer: CreateN create buffer failed with error 0x%x", result);
-//            return result;
-//        }
-//    }
-//    MG_Util::Debug::LogD("MG_State: Buffer: CreateN created buffers successfully");
-//    return GL_NO_ERROR;
-//}
-
 GLenum BufferState::Bind(GLenum target, GLuint buffer) {
     // We don't handle unallocated buffer names here, just plain bind
     if (!IsValidTarget_(target)) return GL_INVALID_ENUM;
     MG_Util::Debug::LogD("MG_State: Buffer: Bind called with target=%s, buffer=%u", MG_Util::Debug::GLEnumToString(target), buffer);
-
-//    if (buffer != 0 && !ValidateAllocatedHandle(buffer)) {
-//        MG_Util::Debug::LogE("MG_State: Buffer: Binding invalid buffer %d to %s", buffer, MG_Util::Debug::GLEnumToString(target));
-//        return GL_INVALID_OPERATION;
-//    }
-
     currentBindings_[target] = buffer;
     MG_Util::Debug::LogD("MG_State: Buffer: Bind succeed bind buffer %u to target 0x%x", buffer, target);
     return GL_NO_ERROR;
@@ -106,44 +85,150 @@ GLenum BufferState::CommitStorage(GLenum target, GLsizeiptr size, const void* da
     return GL_NO_ERROR;
 }
 
-GLenum BufferState::AcquireBufferMemory(GLenum target, GLenum access, void** mappedPointer) {
+GLenum BufferState::CommitStorageRegion(GLenum target, GLintptr offset, GLsizeiptr size, const void* data) {
+    MG_Util::Debug::LogD("MG_State: Buffer: BufferSubData called on target 0x%x, offset=%ld, size=%ld", target, offset, size);
     if (!IsValidTarget_(target)) return GL_INVALID_ENUM;
-    if (MG_Constants::Buffer::VALID_ACCESS.find(access) == MG_Constants::Buffer::VALID_ACCESS.end()) {
+    if (offset < 0 || size < 0) return GL_INVALID_VALUE;
-        return GL_INVALID_ENUM;
-        MG_Util::Debug::LogD("MG_State: Buffer: AcquireBufferMemory buffer at target 0x%x acquired mapped memory, access mode = 0x%x", target, access);
-    }
 
     auto it = currentBindings_.find(target);
     if (it == currentBindings_.end() || it->second == 0)
         return GL_INVALID_OPERATION;
 
     BufferObject& obj = buffers_[it->second];
-    if (obj.isMapped) return GL_INVALID_OPERATION;
+    MG_Util::Debug::LogD("MG_State: Buffer: BufferSubData get buffer object %u at target 0x%x", it->second, target);
 
-    obj.isMapped = true;
+    if (static_cast<size_t>(offset + size) > obj.data.size()) return GL_INVALID_VALUE;
-    *mappedPointer = obj.data.data();
+
-    obj.accessMode = access;
+    if (data) {
+        memcpy(obj.data.data() + offset, data, size);
         obj.dirty = true;
-
+    }
     return GL_NO_ERROR;
 }
 
-GLenum BufferState::ReleaseBufferMemory(GLenum target) {
+GLenum BufferState::AcquireBufferMemoryRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, void** mappedPointer) {
-    MG_Util::Debug::LogD("MG_State: Buffer: ReleaseBufferMemory called on target 0x%x",target);
+    MG_Util::Debug::LogD("MG_State: Buffer: AcquireBufferMemoryRange called with target=0x%x, offset=%ld, length=%ld, access=0x%x", target, offset, length, access);
-    if (!IsValidTarget_(target)) return GL_INVALID_ENUM;
+    if (!IsValidTarget_(target)) {
+        MG_Util::Debug::LogE("MG_State: Buffer: AcquireBufferMemoryRange failed: invalid target 0x%x", target);
+        return GL_INVALID_ENUM;
+    }
+    if (offset < 0 || length <= 0) {
+        MG_Util::Debug::LogE("MG_State: Buffer: AcquireBufferMemoryRange failed: invalid offset %ld or length %ld", offset, length);
+        return GL_INVALID_VALUE;
+    }
 
+    auto it = currentBindings_.find(target);
+    if (it == currentBindings_.end() || it->second == 0) {
+        MG_Util::Debug::LogE("MG_State: Buffer: AcquireBufferMemoryRange failed: no buffer bound to target 0x%x", target);
+        return GL_INVALID_OPERATION;
+    }
+
+    BufferObject& obj = buffers_[it->second];
+    MG_Util::Debug::LogD("MG_State: Buffer: AcquireBufferMemoryRange operating on buffer %u", it->second);
+    if (obj.isMapped) {
+        MG_Util::Debug::LogE("MG_State: Buffer: AcquireBufferMemoryRange failed: buffer %u is already mapped", it->second);
+        return GL_INVALID_OPERATION;
+    }
+
+    const GLbitfield validFlags = GL_MAP_READ_BIT | GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT | GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_INVALIDATE_BUFFER_BIT ;
+    if ((access & ~validFlags) != 0) {
+        MG_Util::Debug::LogE("MG_State: Buffer: AcquireBufferMemoryRange failed: invalid access flags 0x%x", access);
+        return GL_INVALID_VALUE;
+    }
+
+    if (static_cast<size_t>(offset + length) > obj.data.size()) {
+        MG_Util::Debug::LogE("MG_State: Buffer: AcquireBufferMemoryRange failed: requested range [%ld, %ld) exceeds buffer size %zu", offset, offset + length, obj.data.size());
+        return GL_INVALID_VALUE;
+    }
+
+    obj.isMapped = true;
+    obj.mapOffset = offset;
+    obj.mapLength = length;
+    obj.mapAccessFlags = access;
+    obj.dirty = true;
+    *mappedPointer = obj.data.data() + offset;
+    MG_Util::Debug::LogD("MG_State: Buffer: AcquireBufferMemoryRange succeeded for buffer %u. Mapped pointer: %p", it->second, *mappedPointer);
+    return GL_NO_ERROR;
+}
+
+GLenum BufferState::SyncBufferMemory(GLenum target, GLintptr offset, GLsizeiptr length) {
+    if (!IsValidTarget_(target)) return GL_INVALID_ENUM;
+    if (offset < 0 || length <= 0) return GL_INVALID_VALUE;
 
     auto it = currentBindings_.find(target);
     if (it == currentBindings_.end() || it->second == 0)
         return GL_INVALID_OPERATION;
 
     BufferObject& obj = buffers_[it->second];
-    if (!obj.isMapped) return GL_INVALID_OPERATION;
+    if (!obj.isMapped || !(obj.mapAccessFlags & GL_MAP_FLUSH_EXPLICIT_BIT))
+        return GL_INVALID_OPERATION;
+
+    if (offset < obj.mapOffset || offset + length > obj.mapOffset + obj.mapLength)
+        return GL_INVALID_VALUE;
+
+    // TODO: Add support for flush range.
+    // Now only mark it as dirty.
+    obj.dirty = true;
+    return GL_NO_ERROR;
+}
+
+GLenum BufferState::CopyBufferRange(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) {
+    if (!IsValidTarget_(readTarget) || !IsValidTarget_(writeTarget))
+        return GL_INVALID_ENUM;
+    if (readOffset < 0 || writeOffset < 0 || size < 0)
+        return GL_INVALID_VALUE;
+
+    GLuint readBuffer = currentBindings_[readTarget];
+    GLuint writeBuffer = currentBindings_[writeTarget];
+    if (readBuffer == 0 || writeBuffer == 0 || readBuffer == writeBuffer)
+        return GL_INVALID_OPERATION;
+
+    BufferObject& src = buffers_[readBuffer];
+    BufferObject& dst = buffers_[writeBuffer];
+
+    if (static_cast<size_t>(readOffset + size) > src.data.size() ||
+        static_cast<size_t>(writeOffset + size) > dst.data.size())
+        return GL_INVALID_VALUE;
+
+    memcpy(dst.data.data() + writeOffset, src.data.data() + readOffset, size);
+    dst.dirty = true;
+    return GL_NO_ERROR;
+}
+
+GLenum BufferState::AcquireBufferMemory(GLenum target, GLenum access, void** mappedPointer) {
+    GLbitfield flags = 0;
+    switch (access) {
+        case GL_READ_ONLY:  flags = GL_MAP_READ_BIT; break;
+        case GL_WRITE_ONLY: flags = GL_MAP_WRITE_BIT; break;
+        case GL_READ_WRITE: flags = GL_MAP_READ_BIT | GL_MAP_WRITE_BIT; break;
+        default:
+            flags = access;
+    }
+    return AcquireBufferMemoryRange(target, 0, buffers_[currentBindings_[target]].data.size(), flags, mappedPointer);
+}
+
+GLenum BufferState::ReleaseBufferMemory(GLenum target) {
+    if (!IsValidTarget_(target))
+        return GL_INVALID_ENUM;
+
+    auto it = currentBindings_.find(target);
+    if (it == currentBindings_.end() || it->second == 0)
+        return GL_INVALID_OPERATION;
+
+    BufferObject& obj = buffers_[it->second];
+    if (!obj.isMapped)
+        return GL_INVALID_OPERATION;
+
+    if ((obj.mapAccessFlags & GL_MAP_FLUSH_EXPLICIT_BIT) == 0) {
+        obj.dirty = true;
+    }
 
     obj.isMapped = false;
+    obj.mapOffset = 0;
+    obj.mapLength = 0;
+    obj.mapAccessFlags = 0;
     obj.accessMode = GL_READ_WRITE;
-    obj.dirty = true;
+
-    MG_Util::Debug::LogD("MG_State: Buffer: ReleaseBufferMemory buffer at target 0x%x released mapped memory", target);
     return GL_NO_ERROR;
 }
 
@@ -163,7 +248,8 @@ bool BufferState::ValidateGeneratedName(GLuint buffer) {
 void BufferState::Delete(GLuint buffer) {
     buffers_.erase(buffer);
     if (ValidateGeneratedName(buffer))
-        freeId_.emplace_back(buffer);
+        // TODO: Prevent the object that uses a freeId from conflicting with legacy object in the backend.
+        //freeId_.emplace_back(buffer);
     for (auto& [target, id] : currentBindings_) {
         if (id == buffer) id = 0;
     }

MG/MG_GL/State/Buffer/BufferState.h

@@ -21,23 +21,29 @@ public:
         bool isMapped = false;
         bool generated = false;
         GLenum accessMode = GL_READ_WRITE;
+        GLintptr mapOffset = 0;
+        GLsizeiptr mapLength = 0;
+        GLbitfield mapAccessFlags = 0;
     };
 
     // Return: the validity of the operation, according to OpenGL 3 standard
     GLenum GenName(GLuint* buffer);
     GLenum GenNameN(GLsizei n, GLuint* buffers);
     GLenum Create(GLuint buffer);
-//    GLenum CreateN(GLsizei n, GLuint* buffers);
     GLenum Bind(GLenum target, GLuint buffer);
     GLenum CommitStorage(GLenum target, GLsizeiptr size, const void* data, GLenum usage);
+    GLenum CommitStorageRegion(GLenum target, GLintptr offset, GLsizeiptr size, const void* data);
+    GLenum AcquireBufferMemoryRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, void** mappedPointer);
+    GLenum SyncBufferMemory(GLenum target, GLintptr offset, GLsizeiptr length);
+    GLenum CopyBufferRange(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
     GLenum AcquireBufferMemory(GLenum target, GLenum access, void** mappedPointer);
     GLenum ReleaseBufferMemory(GLenum target);
     GLenum QueryPropertyIntVector(GLenum target, GLenum pname, GLint* params) const;
+    GLenum DeleteN(GLsizei n, const GLuint* buffers);
     
     bool ValidateAllocatedHandle(GLuint buffer);
     bool ValidateGeneratedName(GLuint buffer);
     void Delete(GLuint buffer);
-    GLenum DeleteN(GLsizei n, const GLuint* buffers);
     GLuint GetCurrentBinding(GLenum target) const;
 
     unordered_map<GLenum, GLuint> currentBindings_;

MG/MG_GL/State/Core/GLState.cpp

@@ -156,6 +156,19 @@ namespace MG_State {
         return MG_State_T::bufferState->AcquireBufferMemory(target, access, mappedPtr);
     }
     
+    GLenum AcquireBufferMemoryRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, void** mappedPointer) {
+        return MG_State_T::bufferState->AcquireBufferMemoryRange(target, offset, length, access, mappedPointer);
+    }
+
+    GLenum SyncBufferMemory(GLenum target, GLintptr offset, GLsizeiptr length) {
+        return MG_State_T::bufferState->SyncBufferMemory(target, offset, length);
+    }
+
+    GLenum CopyBufferRange(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) {
+        return MG_State_T::bufferState->CopyBufferRange(readTarget, writeTarget, readOffset,
+                                                        writeOffset, size);
+    }
+
     GLenum ReleaseBufferMemory(GLenum target) {
         return MG_State_T::bufferState->ReleaseBufferMemory(target);
     }
@@ -164,10 +177,6 @@ namespace MG_State {
         return MG_State_T::bufferState->Create(buffer);
     }
 
-//    GLenum CreateBuffers(GLsizei n, GLuint* buffers) {
-//        return MG_State_T::bufferState->CreateN(n, buffers);
-//    }
-
     GLenum GenBufferNames(GLsizei n, GLuint* buffers) {
         return MG_State_T::bufferState->GenNameN(n, buffers);
     }
@@ -186,6 +195,10 @@ namespace MG_State {
         return MG_State_T::bufferState->CommitStorage(target, size, data, usage);
     }
 
+    GLenum CommitBufferStorageRegion(GLenum target, GLintptr offset, GLsizeiptr size, const void* data) {
+        return MG_State_T::bufferState->CommitStorageRegion(target, offset, size, data);
+    }
+
     bool ValidateAllocatedBufferHandle(GLuint buffer) {
         return MG_State_T::bufferState->ValidateAllocatedHandle(buffer);
     }
@@ -384,11 +397,11 @@ void UpdateProgramUniformMatrix##suffix##Vector(GLint location, GLsizei count, G
     
     GLenum MG_State::AttachTexture2DToFramebuffer(GLenum target, GLenum attachment, GLenum textarget,
                                                   GLuint texture, GLint level) {
-        return MG_State_T::framebufferState->glAttachTexture2D(target, attachment, textarget,
+        return MG_State_T::framebufferState->AttachTexture2D(target, attachment, textarget,
                                                              texture, level);
     }
     
     GLenum MG_State::ValidateFramebufferCompleteness(GLenum target) {
-        return MG_State_T::framebufferState->glValidateCompleteness(target);
+        return MG_State_T::framebufferState->ValidateCompleteness(target);
     }
 }

MG/MG_GL/State/Core/GLState.h

@@ -57,12 +57,15 @@ namespace MG_State {
     
     // Buffer
     GLenum AcquireBufferMemory(GLenum target, GLenum access, void** mappedPtr);
+    GLenum AcquireBufferMemoryRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, void** mappedPointer);
+    GLenum SyncBufferMemory(GLenum target, GLintptr offset, GLsizeiptr length);
+    GLenum CopyBufferRange(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
     GLenum ReleaseBufferMemory(GLenum target);
     GLenum CreateBuffer(GLuint buffer);
-//    GLenum CreateBuffers(GLsizei n, GLuint* buffers);
     GLenum GenBufferNames(GLsizei n, GLuint* buffers);
     GLenum BindBuffer(GLenum target, GLuint buffer);
     GLenum CommitBufferStorage(GLenum target, GLsizeiptr size, const void* data, GLenum usage);
+    GLenum CommitBufferStorageRegion(GLenum target, GLintptr offset, GLsizeiptr size, const void* data);
     bool ValidateAllocatedBufferHandle(GLuint buffer);
     bool ValidateGeneratedName(GLuint buffer);
     void DeleteBuffer(GLuint buffer);

MG/MG_GL/State/Framebuffer/FramebufferState.cpp

@@ -32,7 +32,8 @@ GLenum FramebufferState::Delete(GLuint framebuffer) {
     if (framebuffer == 0) return GL_INVALID_VALUE;
     
     if (framebuffers_.erase(framebuffer)) {
-        freeIds_.insert(framebuffer);
+        // TODO: Prevent the object that uses a freeId from conflicting with legacy object in the backend.
+        //freeIds_.insert(framebuffer);
         for (auto& [target, id] : currentBindings_) {
             if (id == framebuffer) id = 0;
         }
@@ -54,7 +55,7 @@ GLenum FramebufferState::Bind(GLenum target, GLuint framebuffer) {
     return GL_NO_ERROR;
 }
 
-GLenum FramebufferState::glAttachTexture2D(GLenum target, GLenum attachment,
+GLenum FramebufferState::AttachTexture2D(GLenum target, GLenum attachment,
                                          GLenum textarget, GLuint texture, GLint level) {
     if (MG_Constants::Framebuffer::VALID_ATTACHMENTS.find(attachment) == MG_Constants::Framebuffer::VALID_ATTACHMENTS.end() ||
         MG_Constants::Texture::VALID_TARGETS.find(textarget) == MG_Constants::Texture::VALID_TARGETS.end())
@@ -83,7 +84,7 @@ GLenum FramebufferState::glAttachTexture2D(GLenum target, GLenum attachment,
     return GL_NO_ERROR;
 }
 
-GLenum FramebufferState::glValidateCompleteness(GLenum target) {
+GLenum FramebufferState::ValidateCompleteness(GLenum target) {
     if (target == GL_FRAMEBUFFER) target = GL_DRAW_FRAMEBUFFER;
     FramebufferObject* fbo = GetCurrentFBO(target);
     if (!fbo) return GL_INVALID_OPERATION;

MG/MG_GL/State/Framebuffer/FramebufferState.h

@@ -17,7 +17,7 @@ struct FramebufferAttachment {
 
 struct FramebufferObject {
     bool generated = false;
-    std::unordered_map<GLenum, FramebufferAttachment> attachments;
+    ankerl::unordered_map<GLenum, FramebufferAttachment> attachments;
     GLenum status = GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT;
     GLsizei width = 0;
     GLsizei height = 0;
@@ -30,15 +30,15 @@ public:
     GLenum CreateN(GLsizei n, GLuint* framebuffers);
     GLenum Delete(GLuint framebuffer);
     GLenum Bind(GLenum target, GLuint framebuffer);
-    GLenum glAttachTexture2D(GLenum target, GLenum attachment,
+    GLenum AttachTexture2D(GLenum target, GLenum attachment,
                            GLenum textarget, GLuint texture, GLint level);
-    GLenum glValidateCompleteness(GLenum target);
+    GLenum ValidateCompleteness(GLenum target);
     FramebufferObject* GetCurrentFBO(GLenum target);
     
-    std::unordered_map<GLenum, GLuint> currentBindings_; // READ/DRAW/FRAMEBUFFER
+    ankerl::unordered_map<GLenum, GLuint> currentBindings_; // READ/DRAW
     
 private:
-    std::unordered_map<GLuint, FramebufferObject> framebuffers_;
+    ankerl::unordered_map<GLuint, FramebufferObject> framebuffers_;
     std::set<GLuint> freeIds_;
     GLuint lastId_ = 0;
     bool ValidateHandle(GLuint framebuffer);

MG/MG_GL/State/Program/ProgramState.cpp

@@ -48,7 +48,7 @@ GLenum ProgramState::DeleteProgram(GLuint program) {
     }
 
     programs_.erase(program);
-    freeProgramIds_.insert(program);
+    //freeProgramIds_.insert(program);
     if (currentProgram_ == program)
         currentProgram_ = 0;
     MG_Util::Debug::LogD("MG_State: Program: DeleteProgram success, id=%u", program);
@@ -261,6 +261,7 @@ GLenum ProgramState::SetUniform(GLuint program, GLint location, GLsizei count, c
     }
 
     UniformValue& uniform = prog.uniformValues[uniformName];
+    
     uniform.setData(type, count, value);
     MG_Util::Debug::LogD("MG_State: Program: SetUniform success: %s set", uniformName.c_str());
     return GL_NO_ERROR;
@@ -303,7 +304,7 @@ GLenum ProgramState::SetUniformMatrix(GLuint program, GLint location, GLsizei co
     }
 
     UniformValue& uniform = prog.uniformValues[uniformName];
-    uniform.setData(matrixType, count * MG_Util::Program::GetMatrixElementCount(matrixType), value);
+    uniform.setData(matrixType, count, value);
     MG_Util::Debug::LogD("MG_State: Program: SetUniformMatrix success: %s set", uniformName.c_str());
     return GL_NO_ERROR;
 }
@@ -334,15 +335,15 @@ void ProgramState::UpdateUniform##suffix##Vector1(GLint location, GLsizei count,
     } \
 void ProgramState::UpdateUniform##suffix##Vector2(GLint location, GLsizei count, const type* value) { \
     MG_Util::Debug::LogD("MG_State: Program: UpdateUniform" #suffix "Vector2 called, location=%d, count=%d", location, count); \
-    SetUniform<type>(currentProgram_, location, count * 2, value, vecType);              \
+    SetUniform<type>(currentProgram_, location, count, value, vecType);              \
     } \
 void ProgramState::UpdateUniform##suffix##Vector3(GLint location, GLsizei count, const type* value) { \
     MG_Util::Debug::LogD("MG_State: Program: UpdateUniform" #suffix "Vector3 called, location=%d, count=%d", location, count); \
-    SetUniform<type>(currentProgram_, location, count * 3, value, vecType);              \
+    SetUniform<type>(currentProgram_, location, count, value, vecType);              \
     } \
 void ProgramState::UpdateUniform##suffix##Vector4(GLint location, GLsizei count, const type* value) { \
     MG_Util::Debug::LogD("MG_State: Program: UpdateUniform" #suffix "Vector4 called, location=%d, count=%d", location, count); \
-    SetUniform<type>(currentProgram_, location, count * 4, value, vecType);              \
+    SetUniform<type>(currentProgram_, location, count, value, vecType);              \
     }
 
 IMPLEMENT_UNIFORM_FUNCTIONS(GLfloat, Float, GL_FLOAT_VEC4)
@@ -462,16 +463,62 @@ void ProgramState::CleanupShaders_() {
 
 // UniformValue
 template<typename T>
-void UniformValue::setData(GLenum uniformType, GLsizei numElements, const T* values) {
+void UniformValue::setData(GLenum uniformType, GLsizei count_, const T* values) {
-    MG_Util::Debug::LogD("MG_State: Program: UniformValue::setData called, type=0x%X, count=%d", uniformType, numElements);
+    MG_Util::Debug::LogD("MG_State: Program: UniformValue::setData called, type=0x%X, count=%d", uniformType, count_);
     //type = uniformType;
-    count = numElements;
+    count = count_;
 
     floatData.clear();
     intData.clear();
     uintData.clear();
     boolData.clear();
 
+    switch (type) {
+        case GL_FLOAT:                           numElements = count_ * 1; break;
+        case GL_FLOAT_VEC2:                      numElements = count_ * 2; break;
+        case GL_FLOAT_VEC3:                      numElements = count_ * 3; break;
+        case GL_FLOAT_VEC4:                      numElements = count_ * 4; break;
+        case GL_INT:                             numElements = count_ * 1; break;
+        case GL_INT_VEC2:                        numElements = count_ * 2; break;
+        case GL_INT_VEC3:                        numElements = count_ * 3; break;
+        case GL_INT_VEC4:                        numElements = count_ * 4; break;
+        case GL_UNSIGNED_INT:                    numElements = count_ * 1; break;
+        case GL_UNSIGNED_INT_VEC2:               numElements = count_ * 2; break;
+        case GL_UNSIGNED_INT_VEC3:               numElements = count_ * 3; break;
+        case GL_UNSIGNED_INT_VEC4:               numElements = count_ * 4; break;
+        case GL_BOOL:                            numElements = count_ * 1; break;
+        case GL_BOOL_VEC2:                       numElements = count_ * 2; break;
+        case GL_BOOL_VEC3:                       numElements = count_ * 3; break;
+        case GL_BOOL_VEC4:                       numElements = count_ * 4; break;
+        case GL_FLOAT_MAT2:                      numElements = count_ * 4; break; // 2x2
+        case GL_FLOAT_MAT3:                      numElements = count_ * 9; break; // 3x3
+        case GL_FLOAT_MAT4:                      numElements = count_ * 16; break; // 4x4
+        case GL_FLOAT_MAT2x3:                    numElements = count_ * 6; break; // 2x3
+        case GL_FLOAT_MAT2x4:                    numElements = count_ * 8; break; // 2x4
+        case GL_FLOAT_MAT3x2:                    numElements = count_ * 6; break; // 3x2
+        case GL_FLOAT_MAT3x4:                    numElements = count_ * 12; break; // 3x4
+        case GL_FLOAT_MAT4x2:                    numElements = count_ * 8; break; // 4x2
+        case GL_FLOAT_MAT4x3:                    numElements = count_ * 12; break; // 4x3
+        case GL_SAMPLER_1D:
+        case GL_SAMPLER_2D:
+        case GL_SAMPLER_3D:
+        case GL_SAMPLER_CUBE:
+        case GL_SAMPLER_1D_SHADOW:
+        case GL_SAMPLER_2D_SHADOW:
+        case GL_SAMPLER_CUBE_SHADOW:
+        case GL_SAMPLER_1D_ARRAY:
+        case GL_SAMPLER_2D_ARRAY:
+        case GL_SAMPLER_1D_ARRAY_SHADOW:
+        case GL_SAMPLER_2D_ARRAY_SHADOW:
+        case GL_SAMPLER_BUFFER:
+        case GL_SAMPLER_2D_MULTISAMPLE:
+        case GL_SAMPLER_2D_MULTISAMPLE_ARRAY:    numElements = count_ * 1; break;
+        default:
+            MG_Util::Debug::LogW("MG_State: Program: UniformValue::setData warning: unsupported type 0x%X for numElements", uniformType);
+            numElements = 1;
+            return;
+    }
+
     for (GLsizei i = 0; i < numElements; ++i) {
         switch (uniformType) {
             case GL_FLOAT:

MG/MG_GL/State/Program/ProgramState.h

@@ -27,29 +27,31 @@ struct UniformValue {
     std::vector<GLuint> uintData;
     std::vector<GLboolean> boolData;
     GLsizei count;
+    GLsizei numElements;
 
     UniformValue() : type(0), count(0) {}
 
     template<typename T>
-    void setData(GLenum uniformType, GLsizei numElements, const T* values);
+    void setData(GLenum uniformType, GLsizei count_, const T* values);
 };
 
 struct ProgramObject {
     std::vector<GLuint> attachedShaders;
     UncertainBool linked;
+    bool dirty;
     GLint linkStatus;
     std::string infoLog;
-    std::unordered_map<std::string, GLint> attribBindings;
+    ankerl::unordered_map<std::string, GLint> attribBindings;
-    std::unordered_map<std::string, GLint> attribLocations;
+    ankerl::unordered_map<std::string, GLint> attribLocations;
-    std::unordered_map<std::string, GLint> uniformLocations;
+    ankerl::unordered_map<std::string, GLint> uniformLocations;
-    std::unordered_map<std::string, UniformValue> uniformValues;
+    ankerl::unordered_map<std::string, UniformValue> uniformValues;
     bool markedForDeletion;
 };
 
 class ProgramState {
 public:
-    std::unordered_map<GLuint, ShaderObject> shaders_;
+    ankerl::unordered_map<GLuint, ShaderObject> shaders_;
-    std::unordered_map<GLuint, ProgramObject> programs_;
+    ankerl::unordered_map<GLuint, ProgramObject> programs_;
     std::set<GLuint> freeShaderIds_;
     std::set<GLuint> freeProgramIds_;
     GLuint lastShaderId_ = 0;

MG/MG_GL/State/Program/ShaderObject.cpp

@@ -60,7 +60,8 @@ GLenum ProgramState::DeleteShader(GLuint shader) {
         MG_Util::Debug::LogD("MG_State: Program: DeleteShader info: shader %u marked for deferred deletion (in use)", shader);
     } else {
         shaders_.erase(shader);
-        freeShaderIds_.insert(shader);
+        // TODO: Prevent the object that uses a freeId from conflicting with legacy object in the backend.
+        //freeShaderIds_.insert(shader);
         MG_Util::Debug::LogD("MG_State: Program: DeleteShader success: shader %u deleted immediately", shader);
     }
     return GL_NO_ERROR;

MG/MG_GL/State/Texture/TextureState.cpp

@@ -610,7 +610,7 @@ GLenum TextureState::Delete(GLuint texture) {
     if (it != this->textures.end()) {
         InvalidateTextureInAllUnits_(texture);
         this->textures.erase(it);
-        freeID_.emplace_back(texture);
+        //freeID_.emplace_back(texture);
         MG_Util::Debug::LogD("MG_State: Texture: Delete succeeded for texture=%u", texture);
     } else {
         MG_Util::Debug::LogW("MG_State: Texture: Delete texture %u not found", texture);
@@ -632,7 +632,8 @@ GLenum TextureState::DeleteN(GLsizei n, const GLuint* textures) {
         if (it != this->textures.end()) {
             InvalidateTextureInAllUnits_(id);
             this->textures.erase(it);
-            freeID_.emplace_back(id);
+            // TODO: Prevent the object that uses a freeId from conflicting with legacy object in the backend.
+            //freeID_.emplace_back(id);
             MG_Util::Debug::LogD("MG_State: Texture: DeleteN deleted texture=%u", id);
         } else {
             MG_Util::Debug::LogW("MG_State: Texture: DeleteN texture %u not found", id);
@@ -872,10 +873,10 @@ GLenum TextureState::CheckUploadingTexture2DValidity_(GLenum target, GLint level
         return GL_INVALID_OPERATION;
     }
 
-    bool isDepthInternal = (internalFormat == GL_DEPTH_COMPONENT32F || internalFormat == GL_DEPTH_COMPONENT24
+    bool isDepthInternal = (internalFormat == GL_DEPTH_COMPONENT32 || internalFormat == GL_DEPTH_COMPONENT32F ||
-                            || internalFormat == GL_DEPTH_COMPONENT16 || internalFormat == GL_DEPTH32F_STENCIL8
+            internalFormat == GL_DEPTH_COMPONENT24 || internalFormat == GL_DEPTH_COMPONENT16 || 
-                            || internalFormat == GL_DEPTH24_STENCIL8 || internalFormat == GL_DEPTH_COMPONENT
+            internalFormat == GL_DEPTH32F_STENCIL8 || internalFormat == GL_DEPTH24_STENCIL8 || 
-                            || internalFormat == GL_DEPTH_STENCIL);
+            internalFormat == GL_DEPTH_COMPONENT || internalFormat == GL_DEPTH_STENCIL);
     bool isDepthFormat = (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL);
     if (isDepthInternal != isDepthFormat) {
         MG_Util::Debug::LogE("MG_State: Texture: CheckUploadingTexture2DValidity_ depth internal/format mismatch");

MG/MG_GL/State/Texture/TextureState.h

@@ -62,10 +62,9 @@ class TextureState {
     template <typename K, typename V>
     using unordered_map = ankerl::unordered_dense::map<K, V>;
 private:
-    GLuint activeTextureUnit_ = 0;
 
     GLuint lastUsedID_ = 1;
-//    std::unordered_set<GLuint> freeIDs_;
+//    ankerl::unordered_set<GLuint> freeIDs_;
     std::vector<GLuint> freeID_;
 
     unordered_map<GLenum, TextureObject> proxyTextures_;
@@ -96,6 +95,7 @@ public:
     GLenum QueryLevelPropertyIntVector(GLenum target, GLint level, GLenum pname, GLint* params);
 
     std::vector<TextureUnitState> textureUnits_;
+    GLuint activeTextureUnit_ = 0;
 private:
     size_t CalculatePixelDataSize_(GLenum format, GLenum type, GLsizei width, GLsizei height);
     void InvalidateTextureInAllUnits_(GLuint texture);

MG/MG_GL/State/VertexArray/VertexArrayState.h

@@ -24,7 +24,7 @@ struct VertexArrayObject {
     bool attribDirty = false;
     bool eboDirty = false;
     GLuint elementBuffer = 0;
-    std::unordered_map<GLuint, VertexAttribState> attribs;
+    ankerl::unordered_map<GLuint, VertexAttribState> attribs;
 };
 
 class VertexArrayState {
@@ -50,7 +50,7 @@ public:
     bool ValidateAllocatedHandle(GLuint array);
 
     GLuint currentVao_ = 0;
-    std::unordered_map<GLuint, VertexArrayObject> vaos_;
+    ankerl::unordered_map<GLuint, VertexArrayObject> vaos_;
 private:
     std::set<GLuint> freeIds_;
     GLuint lastId_ = 0;

MG/MG_RHI/GLES/Test/TestDrawing.cpp

@@ -48,8 +48,8 @@ namespace MG_RHI::GLES::Test {
             GLuint quadVBO = 0;
             GLint uTexLoc = -1;
             GLint uMVPLoc = -1;
-            std::unordered_map<GLuint, GLuint> textureCache;
+            ankerl::unordered_map<GLuint, GLuint> textureCache;
-            std::unordered_map<GLuint, bool> textureDirty;
+            ankerl::unordered_map<GLuint, bool> textureDirty;
         };
 
         static ScreenResources sRes;

MG/MG_UTIL/Debug/Debug.cpp

@@ -71,15 +71,23 @@ namespace MG_Util::Debug {
         std::string full_format = header + format + "\n";
 
 #ifdef __ANDROID__
+        if (MG_Global::Common::LogTarget & MG_Constants::Common::LOG_TARGET_ANDROID) {
             __android_log_vprint(androidLevel, MG_Constants::RenderName, full_format.c_str(), args);
+        }
 #endif
 
+        if (MG_Global::Common::LogTarget & MG_Constants::Common::LOG_TARGET_CONSOLE) {
             vprintf(full_format.c_str(), args);
+        }
+
+        if ((MG_Global::Common::LogTarget & MG_Constants::Common::LOG_TARGET_FILE) &&
+            MG_Global::Common::LOG_FILE_PATH != nullptr) {
             va_list args_copy;
             va_copy(args_copy, args);
             LogWrite(full_format.c_str(), args_copy);
             va_end(args_copy);
         }
+    }
     
 #define DECLARE_LOG_FUNCTION(name, level) \
 void Log##name(const char* format, ...) { \

MG/MG_UTIL/Program/DebugTool.cpp

@@ -54,7 +54,7 @@ namespace MG_Util::Program {
         std::ostringstream ss;
         ss << "[";
 
-        const size_t elemCount = std::min<size_t>(value.count, 16); // 限制最大显示元素
+        const size_t elemCount = std::min<size_t>(value.count, 16);
 
         switch(value.type) {
             case GL_FLOAT:

MG/MG_UTIL/Program/GLSLTool.cpp

@@ -108,7 +108,7 @@ namespace MG_Util::Program {
             return;
         }
 
-        std::unordered_set<GLint> used_locations;
+        ankerl::unordered_set<GLint> used_locations;
         GLint auto_location = 0;
         for (auto spirv: allSpirv) {
             spvc_parsed_ir ir = nullptr;
@@ -395,8 +395,6 @@ namespace MG_Util::Program {
                 prog.uniformLocations[name] = final_location;
                 UniformValue uniformValue;
                 uniformValue.type = gl_type;
-                uniformValue.count = spvc_type_get_array_dimension(type, 0) > 0 ?
-                                     spvc_type_get_array_dimension(type, 0) : 1;
                 prog.uniformValues[name] = uniformValue;
             }
         }

PlannedFunctions.md

@@ -4,7 +4,7 @@
 - [x] glGetAttribLocation
 - [x] glGetBufferParameteriv
 - [x] glGetError
-- [ ] glGetIntegerv
+- [x] glGetIntegerv
 - [x] glGetProgramiv
 - [x] glGetShaderiv
 - [x] glGetString
@@ -33,6 +33,8 @@
 - [x] glFramebufferTexture2D
 - [x] glGenFramebuffers
 
+　　~~glBlitFramebuffer~~
+
 ---
 
 ### **4. Shader & Program Management**
@@ -60,6 +62,10 @@
 - [x] glUnmapBuffer
 - [x] glVertexAttribIPointer
 - [x] glVertexAttribPointer
+- [x] glBufferSubData
+- [x] glMapBufferRange
+- [x] glFlushMappedBufferRange
+- [x] glCopyBufferSubData
 
 ---
 
@@ -90,28 +96,27 @@
 ---
 
 ### **8. Drawing Commands**
-- [ ] glDrawElements
+　　~~glDrawElements~~
-- [ ] glDrawArrays
 
 ## Abstraction Layer (MG_RHI)
 
 ### **1. Initialization & Query Functions**
 
-glGetAttribLocation~~
+　　~~glGetAttribLocation~~
 
-glGetBufferParameteriv~~
+　　~~glGetBufferParameteriv~~
 
-glGetError~~
+　　~~glGetError~~
 	
-- [ ] glGetIntegerv
+　　~~glGetIntegerv~~
 - [ ] glGetProgramiv
 - [ ] glGetShaderiv
 - [ ] glGetString
 - [ ] glGetStringi
 
-glGetTexLevelParameteriv~~
+　　~~glGetTexLevelParameteriv~~
 
-glGetUniformLocation~~
+　　~~glGetUniformLocation~~
 
 ---
 
@@ -133,6 +138,7 @@ glGetUniformLocation~~
 - [ ] glDeleteFramebuffers
 - [ ] glFramebufferTexture2D
 - [ ] glGenFramebuffers
+- [ ] glBlitFramebuffer
 
 ---
 
@@ -161,6 +167,10 @@ glGetUniformLocation~~
 - [ ] glUnmapBuffer
 - [ ] glVertexAttribIPointer
 - [ ] glVertexAttribPointer
+- [ ] glBufferSubData
+- [ ] glMapBufferRange
+- [ ] glFlushMappedBufferRange
+- [ ] glCopyBufferSubData
 
 ---
 
@@ -192,4 +202,3 @@ glGetUniformLocation~~
 
 ### **8. Drawing Commands**
 - [ ] glDrawElements
-- [ ] glDrawArrays

README.md

@@ -1,12 +1,19 @@
 # MobileGL
 
+> [!NOTE]
+> **Important Note**: This project will undergo a complete redesign and rewrite in several weeks. The current implementation will be replaced completely.
+
 ## Third party components
 
-**SPIRV-Cross** by **KhronosGroup**: [github](https://github.com/KhronosGroup/SPIRV-Cross)
+**SPIRV-Cross** by **KhronosGroup** - [Apache License 2.0](https://github.com/KhronosGroup/SPIRV-Cross/blob/master/LICENSE): [github](https://github.com/KhronosGroup/SPIRV-Cross)
 
-**glslang** by **KhronosGroup**: [github](https://github.com/KhronosGroup/glslang)
+**glslang** by **KhronosGroup** - [Various Licenses](https://github.com/KhronosGroup/glslang/blob/main/LICENSE.txt): [github](https://github.com/KhronosGroup/glslang)
 
-**GlslOptimizerV2** by **aiekick**: [github](https://github.com/aiekick/GlslOptimizerV2)
+*(Unused Currently)* **GlslOptimizerV2** by **aiekick** - [Apache License 2.0](https://github.com/aiekick/GlslOptimizerV2/blob/master/LICENSE): [github](https://github.com/aiekick/GlslOptimizerV2)
+
+**unordered_dense** by **Martin Leitner-Ankerl** - [MIT License](https://github.com/martinus/unordered_dense/blob/main/LICENSE): [github](https://github.com/martinus/unordered_dense)
+
+**OpenGL Mathematics (*GLM*)** by **G-Truc Creation** - [MIT License](https://github.com/g-truc/glm/blob/master/copying.txt): [github](https://github.com/g-truc/glm)
 
 ## Progress
 
@@ -21,13 +28,13 @@
 
 ---
 
-**Target**: **OpenGL implementation compatible with Minecraft 1.17 to 1.21.1**
+**Target**: **OpenGL implementation compatible with Minecraft 1.17 to 1.21.5**
 
-| Component                      | Development Progress\* |
+| Component                      | Development Progress* |
-|--------------------------------|------------------------|
+|--------------------------------|-----------------------|
-| **OpenGL State Manager**       | **59 / 62**            |
+| **OpenGL State Manager**       | **65 / 65**           |
-| **Abstraction Layer (MG_RHI)** | **0 / 57**             |
+| **Abstraction Layer (MG_RHI)** | **0 / 61**            |
 | **OpenGL ES Backend**          | **N/A** (of MG_RHI)   |
 | **Vulkan Backend**             | **planned**           |
 
-\* *The number of functions that have been implemented*
+* *The number of functions that have been implemented*