[Feat|Fix|Improvement] (All): Continue building the basic structure.

Feat: implement MG_Impl/Buffer
Feat: implement MG_State/ErrorState and integrate it into MG_State/GLContext
Feat: add buffer deletion management
Feat: introduce `INSERTION_POINT` (https://github.com/MobileGL-Dev/MobileGLCodeManager)
Feat: add tests about MG_Impl/Buffer and buffer deletion feature
Feat: add several converters
Fix: fix some compiling errors
Fix: fix some incorrect behaviors in MG_State/Buffer
Improvement: remove some current statements at the beginning of the source file, which will be added uniformly soon
Improvement: optimize some naming

MobileGL/MG_Impl/GLImpl/Buffer/GL_Buffer.cpp

@@ -0,0 +1,440 @@
+#include "../../../Includes.h"
+
+namespace MobileGL {
+	namespace MG_Impl::GLImpl {
+		void DeleteBuffers_State(GLsizei n, const GLuint* buffers) {
+			if (n < 0) {
+				MG_State::pGLContext->RecordError(ErrorCode::InvalidValue,
+					MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "DeleteBuffers_State",
+						"n must be non-negative."));
+				return;
+			}
+
+			if (!buffers) {
+				MG_State::pGLContext->RecordError(ErrorCode::InvalidValue,
+					MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "DeleteBuffers_State",
+						"Buffer names array cannot be null."));
+				return;
+			}
+
+			for (SizeT i = 0; i < static_cast<SizeT>(n); ++i) {
+				Uint bufferName = buffers[i];
+				if (bufferName == 0) continue;
+				if (!BufferImpl::ValidateBufferName(bufferName)) continue;
+				MG_State::pGLContext->MarkBufferObjectForDeletion(bufferName);
+			}
+
+		}
+		
+		void FlushMappedBufferRange_State(GLenum target, GLintptr offset, GLsizeiptr length) {
+			if (length < 0 || offset < 0) {
+				MG_State::pGLContext->RecordError(ErrorCode::InvalidValue,
+					MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "FlushMappedBufferRange_State",
+						"Offset and length must be non-negative."));
+				return;
+			}
+
+			BufferTarget bufferTarget = MG_Util::ConvertGLEnumToBufferTarget(target);
+			if (!BufferImpl::ValidateBufferTarget(bufferTarget)) return;
+
+			auto& bindingSlot = MG_State::pGLContext->GetBufferBindingSlot(bufferTarget);
+
+			auto bufferObject = bindingSlot.GetBoundObject();
+			if (!bufferObject) {
+				MG_State::pGLContext->RecordError(ErrorCode::InvalidOperation,
+					MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "FlushMappedBufferRange_State",
+						"Buffer target is bound to no buffer object."));
+				return;
+			}
+
+			if (!bufferObject->IsMapped()) {
+				MG_State::pGLContext->RecordError(ErrorCode::InvalidOperation,
+					MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "FlushMappedBufferRange_State",
+						"Cannot flush a buffer object that is not mapped."));
+				return;
+			}
+
+			if (offset + length > bufferObject->GetSize()) {
+				MG_State::pGLContext->RecordError(ErrorCode::InvalidValue,
+					MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "FlushMappedBufferRange_State",
+						"Offset and length exceed buffer size."));
+				return;
+			}
+
+			BufferMappingAccessBit mappingAccess = bufferObject->GetMappingAccess();
+			if(!Any(mappingAccess & BufferMappingAccessBit::FlushExplicit)) {
+				MG_State::pGLContext->RecordError(ErrorCode::InvalidOperation,
+					MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "FlushMappedBufferRange_State",
+						"Cannot flush a buffer object that is not mapped with GL_MAP_FLUSH_EXPLICIT_BIT."));
+				return;
+			}
+
+			bufferObject->FlushMemoryRange(static_cast<SizeT>(offset), static_cast<SizeT>(length));
+		}
+		
+		GLboolean UnmapBuffer_State(GLenum target) {
+			BufferTarget bufferTarget = MG_Util::ConvertGLEnumToBufferTarget(target);
+			if (!BufferImpl::ValidateBufferTarget(bufferTarget)) return GL_FALSE;
+
+			auto& bindingSlot = MG_State::pGLContext->GetBufferBindingSlot(bufferTarget);
+
+			auto bufferObject = bindingSlot.GetBoundObject();
+			if (!bufferObject) {
+				MG_State::pGLContext->RecordError(ErrorCode::InvalidOperation,
+					MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "UnmapBuffer_State",
+						"Buffer target is bound to no buffer object."));
+				return GL_FALSE;
+			}
+
+			if (!bufferObject->IsMapped()) {
+				MG_State::pGLContext->RecordError(ErrorCode::InvalidOperation,
+					MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "UnmapBuffer_State",
+						"Cannot unmap a buffer object that is not mapped."));
+				return GL_FALSE;
+			}
+
+			bufferObject->ReleaseMemory();
+			return GL_TRUE;
+		}
+		
+		void* MapBufferRange_State(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) {
+			if (length < 0 || offset < 0) {
+				MG_State::pGLContext->RecordError(ErrorCode::InvalidValue,
+					MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "MapBufferRange_State",
+						"Offset and length must be non-negative."));
+				return nullptr;
+			}
+
+			if (length == 0) {
+				MG_State::pGLContext->RecordError(ErrorCode::InvalidOperation,
+					MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "MapBufferRange_State",
+						"Length must be greater than zero."));
+				return nullptr;
+			}
+
+			BufferTarget bufferTarget = MG_Util::ConvertGLEnumToBufferTarget(target);
+			if (!BufferImpl::ValidateBufferTarget(bufferTarget)) return nullptr;
+
+			auto& bindingSlot = MG_State::pGLContext->GetBufferBindingSlot(bufferTarget);
+			auto bufferObject = bindingSlot.GetBoundObject();
+			if (!bufferObject) {
+				MG_State::pGLContext->RecordError(ErrorCode::InvalidOperation,
+					MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "MapBufferRange_State",
+						"Buffer target is bound to no buffer object."));
+				return nullptr;
+			}
+
+			if (offset + length > bufferObject->GetSize()) {
+				MG_State::pGLContext->RecordError(ErrorCode::InvalidValue,
+					MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "MapBufferRange_State",
+						"Offset and length exceed buffer size."));
+				return nullptr;
+			}
+
+			auto accessBits = MG_Util::ConvertGLEnumToBufferMappingAccess(access);
+			if (!BufferImpl::ValidateBufferMappingAccess(accessBits)) return nullptr;
+
+			if (!Any(accessBits & (BufferMappingAccessBit::Read | BufferMappingAccessBit::Write))) {
+				MG_State::pGLContext->RecordError(ErrorCode::InvalidOperation,
+					MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "MapBufferRange_State",
+						"At least one of GL_MAP_READ_BIT or GL_MAP_WRITE_BIT must be set."));
+				return nullptr;
+			}
+
+			if (Any(accessBits & BufferMappingAccessBit::Read)) {
+				const auto invalidFlags = BufferMappingAccessBit::InvalidateRange |
+					BufferMappingAccessBit::InvalidateBuffer |
+					BufferMappingAccessBit::Unsynchronized;
+
+				if (Any(accessBits & invalidFlags)) {
+					MG_State::pGLContext->RecordError(ErrorCode::InvalidOperation,
+						MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "MapBufferRange_State",
+							"GL_MAP_READ_BIT cannot be combined with invalidation or unsynchronized flags."));
+					return nullptr;
+				}
+			}
+
+			if (Any(accessBits & BufferMappingAccessBit::FlushExplicit)) {
+				if (!(Any(accessBits & BufferMappingAccessBit::Write))) {
+					MG_State::pGLContext->RecordError(ErrorCode::InvalidOperation,
+						MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "MapBufferRange_State",
+							"GL_MAP_FLUSH_EXPLICIT_BIT requires GL_MAP_WRITE_BIT."));
+					return nullptr;
+				}
+			}
+
+			const BufferMappingAccessBit storageFlags =
+				BufferMappingAccessBit::Persistent | BufferMappingAccessBit::Coherent;
+			BufferMappingAccessBit requiredFlags = accessBits & storageFlags;
+			if (Any(requiredFlags)) {
+				// TODO: check if the buffer data is created by BufferStorage and its flags after its implementation
+				MG_State::pGLContext->RecordError(ErrorCode::InvalidOperation,
+					MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "MapBufferRange_State",
+						"Access flags require matching storage flags in buffer."));
+				return nullptr;
+			}
+
+			if (bufferObject->IsMapped()) {
+				const auto invalidateFlags = BufferMappingAccessBit::InvalidateRange |
+					BufferMappingAccessBit::InvalidateBuffer;
+
+				if (!Any(accessBits & invalidateFlags)) {
+					MG_State::pGLContext->RecordError(ErrorCode::InvalidOperation,
+						MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "MapBufferRange_State",
+							"Cannot map a buffer object that is already mapped."));
+					return nullptr;
+				}
+			}
+
+			void* result = bufferObject->AcquireMemoryRange(
+				{ static_cast<SizeT>(offset), static_cast<SizeT>(offset + length) },
+				accessBits
+			);
+			if (!result) {
+				MG_State::pGLContext->RecordError(ErrorCode::OutOfMemory,
+					MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "MapBufferRange_State",
+						"Failed to map buffer due to insufficient memory."));
+				return nullptr;
+			}
+			return result;
+		}
+		
+		void* MapBuffer_State(GLenum target, GLenum access) {
+			bool readable = access == GL_READ_ONLY || access == GL_READ_WRITE;
+			bool writable = access == GL_WRITE_ONLY || access == GL_READ_WRITE;
+			if (access != GL_READ_ONLY && access != GL_WRITE_ONLY && access != GL_READ_WRITE) {
+				MG_State::pGLContext->RecordError(ErrorCode::InvalidEnum,
+					MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "MapBuffer_State",
+						"Access must be one of GL_READ_ONLY, GL_WRITE_ONLY, or GL_READ_WRITE."));
+				return nullptr;
+			}
+			
+			BufferTarget bufferTarget = MG_Util::ConvertGLEnumToBufferTarget(target);
+			if (!BufferImpl::ValidateBufferTarget(bufferTarget)) return nullptr;
+			auto& bindingSlot = MG_State::pGLContext->GetBufferBindingSlot(bufferTarget);
+			
+			auto bufferObject = bindingSlot.GetBoundObject();
+			if (!bufferObject) {
+				MG_State::pGLContext->RecordError(ErrorCode::InvalidOperation,
+					MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "MapBuffer_State",
+						"Buffer target is bound to no buffer object."));
+				return nullptr;
+			}
+			
+			if (bufferObject->IsMapped()) {
+				MG_State::pGLContext->RecordError(ErrorCode::InvalidOperation,
+					MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "MapBuffer_State",
+						"Cannot map a buffer object that is already mapped."));
+				return nullptr;
+			}
+
+			void* result = bufferObject->AcquireMemory(true, readable, writable);
+			if (!result) {
+				MG_State::pGLContext->RecordError(ErrorCode::OutOfMemory,
+					MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "MapBuffer_State",
+						"Failed to map buffer due to insufficient memory."));
+				return nullptr;
+			}
+			return result;
+		}
+		
+		void CopyBufferSubData_State(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) {
+			if (size < 0 || readOffset < 0 || writeOffset < 0) {
+				MG_State::pGLContext->RecordError(ErrorCode::InvalidValue,
+					MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "CopyBufferSubData_State",
+						"Offset and size must be non-negative."));
+				return;
+			}
+			
+			BufferTarget readBufferTarget = MG_Util::ConvertGLEnumToBufferTarget(readTarget);
+			BufferTarget writeBufferTarget = MG_Util::ConvertGLEnumToBufferTarget(writeTarget);
+			if (!BufferImpl::ValidateBufferTarget(readBufferTarget) || !BufferImpl::ValidateBufferTarget(writeBufferTarget)) return;
+			
+			auto& readBindingSlot = MG_State::pGLContext->GetBufferBindingSlot(readBufferTarget);
+			auto& writeBindingSlot = MG_State::pGLContext->GetBufferBindingSlot(writeBufferTarget);
+			auto readBufferObject = readBindingSlot.GetBoundObject();
+			auto writeBufferObject = writeBindingSlot.GetBoundObject();
+
+			if (!readBufferObject || !writeBufferObject) {
+				MG_State::pGLContext->RecordError(ErrorCode::InvalidOperation,
+					MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "CopyBufferSubData_State",
+						"One of the buffer targets is bound to no buffer object."));
+				return;
+			}
+
+			if (readOffset + size > readBufferObject->GetSize() || writeOffset + size > writeBufferObject->GetSize()) {
+				MG_State::pGLContext->RecordError(ErrorCode::InvalidValue,
+					MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "CopyBufferSubData_State",
+						"Offset and size must be within the bounds of the buffer objects."));
+				return;
+			}
+
+			if (readBufferObject == writeBufferObject) {
+				if ((readOffset <= writeOffset && readOffset + size > writeOffset) ||
+					(writeOffset <= readOffset && writeOffset + size > readOffset))
+				MG_State::pGLContext->RecordError(ErrorCode::InvalidValue,
+					MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "CopyBufferSubData_State",
+						"Source and destination buffers overlap in the specified ranges."));
+				return;
+			}
+
+			auto isIllegallyMapped = [](const SharedPtr<MG_State::GLState::BufferObject>& buffer) {
+				return buffer->IsMapped() && !Any(buffer->GetMappingAccess() & BufferMappingAccessBit::Persistent);
+				};
+			if (isIllegallyMapped(readBufferObject) || isIllegallyMapped(writeBufferObject)) {
+				MG_State::pGLContext->RecordError(ErrorCode::InvalidOperation,
+					MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "CopyBufferSubData_State",
+						"Cannot copy data from/to a mapped buffer object unless it was mapped with GL_MAP_PERSISTENT_BIT."));
+				return;
+			}
+
+			writeBufferObject->CopyDataFrom(readBufferObject, readOffset, writeOffset, size);
+		}
+		
+		void BufferSubData_State(GLenum target, GLintptr offset, GLsizeiptr size, const void* data) {
+			if (!data) {
+				MG_State::pGLContext->RecordError(ErrorCode::NoError, // somehow OpenGL does not generate an error for this
+					MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "BufferSubData_State",
+						"Data pointer cannot be null."));
+				return;
+			}
+
+			if (size < 0 || offset < 0) {
+				MG_State::pGLContext->RecordError(ErrorCode::InvalidValue,
+					MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "BufferSubData_State",
+						"Offset and size must be non-negative."));
+				return;
+			}
+
+			BufferTarget bufferTarget = MG_Util::ConvertGLEnumToBufferTarget(target);
+			if (!BufferImpl::ValidateBufferTarget(bufferTarget)) return;
+			auto& bindingSlot = MG_State::pGLContext->GetBufferBindingSlot(bufferTarget);
+
+			auto bufferObject = bindingSlot.GetBoundObject();
+			if (!bufferObject) {
+				MG_State::pGLContext->RecordError(ErrorCode::InvalidOperation,
+					MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "BufferSubData_State",
+						"Buffer target is bound to no buffer object."));
+				return;
+			}
+
+			SizeT bufferSize = bufferObject->GetSize();
+			Range1D mappedRange = bufferObject->GetMappedRange();
+			if ((offset < mappedRange.end) && (offset + size > mappedRange.start)) {
+				MG_State::pGLContext->RecordError(ErrorCode::InvalidValue,
+					MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "BufferSubData_State",
+						"Offset and size must not overlap with the mapped range of the buffer object."));
+				return;
+			}
+
+			BufferMappingAccessBit mappingAccess = bufferObject->GetMappingAccess();
+			if (bufferObject->IsMapped() && !Any(mappingAccess & BufferMappingAccessBit::Persistent)) {
+				Range1D mappedRange = bufferObject->GetMappedRange();
+				if (offset + size >= mappedRange.start) {
+					MG_State::pGLContext->RecordError(ErrorCode::InvalidOperation,
+						MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "BufferSubData_State",
+							"Cannot modify a mapped buffer object unless it was mapped with GL_MAP_PERSISTENT_BIT."));
+					return;
+				}
+			}
+
+			bufferObject->UploadSubData({ (void*)data, (SizeT)size }, offset);
+		}
+		
+		void BufferData_State(GLenum target, GLsizeiptr size, const void* data, GLenum usage) {
+			if (size < 0) {
+				MG_State::pGLContext->RecordError(ErrorCode::InvalidValue,
+					MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "BufferData_State",
+						"Size must be non-negative."));
+				return;
+			}
+
+			BufferUsage bufferUsage = MG_Util::ConvertGLEnumToBufferUsage(usage);
+			if (!BufferImpl::ValidateBufferUsage(bufferUsage)) return;
+
+			BufferTarget bufferTarget = MG_Util::ConvertGLEnumToBufferTarget(target);
+			if (!BufferImpl::ValidateBufferTarget(bufferTarget)) return;
+			auto& bindingSlot = MG_State::pGLContext->GetBufferBindingSlot(bufferTarget);
+
+			auto bufferObject = bindingSlot.GetBoundObject();
+			if (!bufferObject) {
+				MG_State::pGLContext->RecordError(ErrorCode::InvalidOperation,
+					MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "BufferData_State",
+						"Buffer target is bound to no buffer object."));
+				return;
+			}
+
+			bufferObject->SetUsage(bufferUsage);
+			bufferObject->Resize(size);
+			if (data) {
+				bufferObject->UploadData({ (void*)data, (SizeT)size }, 0);
+			}
+		}
+		
+		void BindBuffer_State(GLenum target, GLuint buffer) {
+			if (buffer != 0 && !BufferImpl::ValidateBufferName(buffer)) return;
+			BufferTarget bufferTarget = MG_Util::ConvertGLEnumToBufferTarget(target);
+			if (!BufferImpl::ValidateBufferTarget(bufferTarget)) return;
+
+			auto bufferObject = MG_State::pGLContext->GetBufferObject(buffer);
+			if (!bufferObject) {
+				MG_State::pGLContext->CreateBufferObject(buffer);
+				bufferObject = MG_State::pGLContext->GetBufferObject(buffer);
+			}
+
+			auto& bindingSlot = MG_State::pGLContext->GetBufferBindingSlot(bufferTarget);
+			bindingSlot.Bind(bufferObject);
+		}
+		
+		void GenBuffers_State(GLsizei n, GLuint* buffers) {
+			if (n < 0) {
+				MG_State::pGLContext->RecordError(ErrorCode::InvalidValue,
+					MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", "GenBuffers_State", "n must be non-negative"));
+				return;
+			}
+			auto bufferNames = MG_State::pGLContext->GenBufferNames(n);
+			Copy(bufferNames.data(), buffers, bufferNames.size());
+		}
+
+		/* @INSERTION_POINT:FUNCTION_IMPLEMENTATION@ */
+		void DeleteBuffers(GLsizei n, const GLuint* buffers) {
+			DeleteBuffers_State(n, buffers);
+		}
+		
+		void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) {
+			FlushMappedBufferRange_State(target, offset, length);
+		}
+		
+		GLboolean UnmapBuffer(GLenum target) {
+			return UnmapBuffer_State(target);
+		}
+		
+		void* MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) {
+			return MapBufferRange_State(target, offset, length, access);
+		}
+		
+		void* MapBuffer(GLenum target, GLenum access) {
+			return MapBuffer_State(target, access);
+		}
+		
+		void CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) {
+			CopyBufferSubData_State(readTarget, writeTarget, readOffset, writeOffset, size);
+		}
+		
+		void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data) {
+			BufferSubData_State(target, offset, size, data);
+		}
+		
+		void BufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage) {
+			BufferData_State(target, size, data, usage);
+		}
+		
+		void BindBuffer(GLenum target, GLuint buffer) {
+			BindBuffer_State(target, buffer);
+		}
+		
+		void GenBuffers(GLsizei n, GLuint* buffers) {
+			GenBuffers_State(n, buffers);
+		}
+	}
+}

MobileGL/MG_Impl/GLImpl/Buffer/GL_Buffer.h

@@ -0,0 +1,17 @@
+#pragma once
+
+namespace MobileGL {
+	namespace MG_Impl::GLImpl {
+		/* @INSERTION_POINT:FUNCTION_DECLARATION@ */
+		void DeleteBuffers(GLsizei n, const GLuint* buffers);
+		void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length);
+		GLboolean UnmapBuffer(GLenum target);
+		void* MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
+		void* MapBuffer(GLenum target, GLenum access);
+		void CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
+		void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data);
+		void BufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage);
+		void BindBuffer(GLenum target, GLuint buffer);
+		void GenBuffers(GLsizei n, GLuint* buffers);
+	}
+}

MobileGL/MG_Impl/GLImpl/Buffer/Validators.cpp

@@ -0,0 +1,71 @@
+#include "../../../Includes.h"
+
+namespace MobileGL::MG_Impl::GLImpl {
+	namespace BufferImpl {
+		bool ValidateBufferTarget(BufferTarget target) {
+			if (target != BufferTarget::Unknown)
+				return true;
+
+			using namespace MG_Util;
+			String bufferTargetStr = ConvertBufferTargetToString(target);
+			String glTargetStr = ConvertGLEnumToString(ConvertBufferTargetToGLEnum(target));
+			MG_State::pGLContext->RecordError(ErrorCode::InvalidEnum,
+				MakeShared<GenericErrorInfo>("MG_Impl/GLImpl/BufferImpl", "ValidateBufferTarget",
+					std::format("Target {} ({}) is not valid.", 
+						bufferTargetStr, glTargetStr)));
+			return false;
+		}
+
+		bool ValidateBufferName(Uint index) {
+			bool isValid = MG_State::pGLContext->ValidateBufferName(index);
+			if (isValid)
+				return true;
+			MG_State::pGLContext->RecordError(ErrorCode::InvalidOperation,
+				MakeShared<GenericErrorInfo>("MG_Impl/GLImpl/BufferImpl", "ValidateBufferName",
+					std::format("Buffer name {} is not valid.", index)));
+			return false;
+		}
+
+		bool ValidateBufferUsage(BufferUsage usage) {
+			if (usage != BufferUsage::Unknown) {
+				return true;
+			}
+			using namespace MG_Util;
+			String bufferUsageStr = ConvertBufferUsageToString(usage);
+			String glUsageStr = ConvertGLEnumToString(ConvertBufferUsageToGLEnum(usage));
+			MG_State::pGLContext->RecordError(ErrorCode::InvalidEnum,
+				MakeShared<GenericErrorInfo>("MG_Impl/GLImpl/BufferImpl", "ValidateBufferUsage",
+					std::format("Usage {} ({}) is not one of the allowable values.", 
+						bufferUsageStr, glUsageStr)));
+			return false;
+		}
+
+		bool ValidateBufferMappingAccess(BufferMappingAccessBit accessBits) {
+			if (accessBits == BufferMappingAccessBit::Null) {
+				MG_State::pGLContext->RecordError(ErrorCode::InvalidEnum,
+					MakeShared<GenericErrorInfo>("MG_Impl/GLImpl/BufferImpl", "ValidateBufferMappingAccess",
+						"Access bits cannot be null."));
+				return false;
+			}
+
+			const BufferMappingAccessBit validBits =
+				BufferMappingAccessBit::Read | 
+				BufferMappingAccessBit::Write | 
+				BufferMappingAccessBit::InvalidateRange | 
+				BufferMappingAccessBit::InvalidateBuffer | 
+				BufferMappingAccessBit::FlushExplicit | 
+				BufferMappingAccessBit::Unsynchronized | 
+				BufferMappingAccessBit::Persistent | 
+				BufferMappingAccessBit::Coherent;
+
+			if ((accessBits & validBits) != accessBits) {
+				MG_State::pGLContext->RecordError(ErrorCode::InvalidEnum,
+					MakeShared<GenericErrorInfo>("MG_Impl/GLImpl/BufferImpl", "ValidateBufferMappingAccess",
+						"Access bits cannot contain invalid flags."));
+				return false;
+			}
+
+			return true;
+		}
+	}
+}

MobileGL/MG_Impl/GLImpl/Buffer/Validators.h

@@ -0,0 +1,10 @@
+#pragma once
+
+namespace MobileGL::MG_Impl::GLImpl {
+	namespace BufferImpl {
+		bool ValidateBufferTarget(BufferTarget target);
+		bool ValidateBufferName(Uint index);
+		bool ValidateBufferUsage(BufferUsage usage);
+		bool ValidateBufferMappingAccess(BufferMappingAccessBit accessBits);
+	}
+}

MobileGL/MG_Impl/GLImpl/Exporting/Definitions.cpp

@@ -27,12 +27,12 @@ MOBILEGL_GL_API type gl##name(__VA_ARGS__) {
 
 DECLARE_GL_FUNCTION_HEAD(const GLubyte*, GetStringi, GLenum name, GLuint index) DECLARE_GL_FUNCTION_END(const GLubyte*, GetStringi, name, index)
 DECLARE_GL_FUNCTION_HEAD(const GLubyte*, GetString, GLenum name) DECLARE_GL_FUNCTION_END(const GLubyte*, GetString, name)
-DECLARE_GL_FUNCTION_STUB_HEAD(void*, MapBuffer, GLenum target, GLenum access) DECLARE_GL_FUNCTION_STUB_END(void*, MapBuffer, target, access)
+DECLARE_GL_FUNCTION_HEAD(void*, MapBuffer, GLenum target, GLenum access) DECLARE_GL_FUNCTION_END(void*, MapBuffer, target, access)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ClearDepth, GLclampd depth) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ClearDepth, depth)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ActiveTexture, GLenum texture) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ActiveTexture, texture)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, AttachShader, GLuint program, GLuint shader) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, AttachShader, program, shader)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, BindAttribLocation, GLuint program, GLuint index, const GLchar* name) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BindAttribLocation, program, index, name)
-DECLARE_GL_FUNCTION_STUB_HEAD(void, BindBuffer, GLenum target, GLuint buffer) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BindBuffer, target, buffer)
+DECLARE_GL_FUNCTION_HEAD(void, BindBuffer, GLenum target, GLuint buffer) DECLARE_GL_FUNCTION_END_NO_RETURN(void, BindBuffer, target, buffer)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, BindFramebuffer, GLenum target, GLuint framebuffer) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BindFramebuffer, target, framebuffer)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, BindRenderbuffer, GLenum target, GLuint renderbuffer) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BindRenderbuffer, target, renderbuffer)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, BindTexture, GLenum target, GLuint texture) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BindTexture, target, texture)
@@ -41,8 +41,8 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, BlendEquation, GLenum mode) DECLARE_GL_FUNCT
 DECLARE_GL_FUNCTION_STUB_HEAD(void, BlendEquationSeparate, GLenum modeRGB, GLenum modeAlpha) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BlendEquationSeparate, modeRGB, modeAlpha)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, BlendFunc, GLenum sfactor, GLenum dfactor) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BlendFunc, sfactor, dfactor)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, BlendFuncSeparate, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BlendFuncSeparate, sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha)
-DECLARE_GL_FUNCTION_STUB_HEAD(void, BufferData, GLenum target, GLsizeiptr size, const void* data, GLenum usage) DECLARE_GL_FUNCTION_STUB_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, 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_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_STUB_HEAD(GLenum, CheckFramebufferStatus, GLenum target) DECLARE_GL_FUNCTION_STUB_END(GLenum, CheckFramebufferStatus, target)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, Clear, GLbitfield mask) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, Clear, mask)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ClearColor, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ClearColor, red, green, blue, alpha)
@@ -57,7 +57,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, CopyTexSubImage2D, GLenum target, GLint leve
 DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, CreateProgram) DECLARE_GL_FUNCTION_STUB_END(GLuint, CreateProgram)
 DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, CreateShader, GLenum type) DECLARE_GL_FUNCTION_STUB_END(GLuint, CreateShader, type)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, CullFace, GLenum mode) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, CullFace, mode)
-DECLARE_GL_FUNCTION_STUB_HEAD(void, DeleteBuffers, GLsizei n, const GLuint* buffers) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DeleteBuffers, n, buffers)
+DECLARE_GL_FUNCTION_HEAD(void, DeleteBuffers, GLsizei n, const GLuint* buffers) DECLARE_GL_FUNCTION_END_NO_RETURN(void, DeleteBuffers, n, buffers)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DeleteFramebuffers, GLsizei n, const GLuint* framebuffers) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DeleteFramebuffers, n, framebuffers)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DeleteProgram, GLuint program) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DeleteProgram, program)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DeleteRenderbuffers, GLsizei n, const GLuint* renderbuffers) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DeleteRenderbuffers, n, renderbuffers)
@@ -89,7 +89,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, GetAttachedShaders, GLuint program, GLsizei
 DECLARE_GL_FUNCTION_STUB_HEAD(GLint, GetAttribLocation, GLuint program, const GLchar* name) DECLARE_GL_FUNCTION_STUB_END(GLint, GetAttribLocation, program, name)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetBooleanv, GLenum pname, GLboolean* data) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetBooleanv, pname, data)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetBufferParameteriv, GLenum target, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetBufferParameteriv, target, pname, params)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLenum, GetError) DECLARE_GL_FUNCTION_STUB_END(GLenum, GetError)
+DECLARE_GL_FUNCTION_HEAD(GLenum, GetError) DECLARE_GL_FUNCTION_END(GLenum, GetError)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetFloatv, GLenum pname, GLfloat* data) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetFloatv, pname, data)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetFramebufferAttachmentParameteriv, GLenum target, GLenum attachment, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetFramebufferAttachmentParameteriv, target, attachment, pname, params)
 DECLARE_GL_FUNCTION_HEAD(void, GetIntegerv, GLenum pname, GLint* data) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetIntegerv, pname, data)
@@ -184,7 +184,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, BeginQuery, GLenum target, GLuint id) DECLAR
 DECLARE_GL_FUNCTION_STUB_HEAD(void, EndQuery, GLenum target) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, EndQuery, target)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetQueryiv, GLenum target, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetQueryiv, target, pname, params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetQueryObjectuiv, GLuint id, GLenum pname, GLuint* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetQueryObjectuiv, id, pname, params)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, UnmapBuffer, GLenum target) DECLARE_GL_FUNCTION_STUB_END(GLboolean, UnmapBuffer, target)
+DECLARE_GL_FUNCTION_HEAD(GLboolean, UnmapBuffer, GLenum target) DECLARE_GL_FUNCTION_END(GLboolean, UnmapBuffer, target)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetBufferPointerv, GLenum target, GLenum pname, void** params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetBufferPointerv, target, pname, params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DrawBuffers, GLsizei n, const GLenum* bufs) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DrawBuffers, n, bufs)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, UniformMatrix2x3fv, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, UniformMatrix2x3fv, location, count, transpose, value)
@@ -197,7 +197,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, BlitFramebuffer, GLint srcX0, GLint srcY0, G
 //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_STUB_HEAD(void, BindVertexArray, GLuint array) DECLARE_GL_FUNCTION_STUB_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_STUB_HEAD(void, GenVertexArrays, GLsizei n, GLuint* arrays) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GenVertexArrays, n, arrays)
@@ -230,7 +230,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)
@@ -2792,4 +2792,4 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, ReplacementCodeuiTexCoord2fVertex3fvSUN, con
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN, GLuint rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN, rc, s, t, nx, ny, nz, x, y, z)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN, const GLuint* rc, const GLfloat* tc, const GLfloat* n, const GLfloat* v) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN, rc, tc, n, v)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN, GLuint rc, GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN, rc, s, t, r, g, b, a, nx, ny, nz, x, y, z)
-DECLARE_GL_FUNCTION_STUB_HEAD(void, ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN, const GLuint* rc, const GLfloat* tc, const GLfloat* c, const GLfloat* n, const GLfloat* v) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN, rc, tc, c, n, v)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN, const GLuint* rc, const GLfloat* tc, const GLfloat* c, const GLfloat* n, const GLfloat* v) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN, rc, tc, c, n, v)

MobileGL/MG_Impl/GLImpl/Getter/GL_Getter.cpp

@@ -2,11 +2,16 @@
 
 namespace MobileGL {
 	namespace MG_Impl::GLImpl {
+        /* @INSERTION_POINT:FUNCTION_IMPLEMENTATION@ */
         const GLubyte* GetString(GLenum name) {
+            static String vendorString;
+            static String versionStr;
+            static String rendererString;
+            static String shadingLanguageVersion;
+            static String extensionsString;
             MGLOG_D("glGetString, name: %s", MG_Util::ConvertGLEnumToString(name).c_str());
             switch (name) {
             case GL_VENDOR:
-                static String vendorString;
                 if (vendorString.empty()) {
                     if (MG_Config::RendererInfoPtr->ExtraVendor.has_value()) {
                         vendorString = std::format("{}{}",
@@ -17,7 +22,6 @@ namespace MobileGL {
                 }
                 return (const GLubyte*)vendorString.c_str();
             case GL_VERSION: {
-                static String versionStr;
                 if (versionStr.empty()) {
                     versionStr = std::format("{} {}, {} Backend, Version {}",
                         MG_Config::RendererInfoPtr->RendererGLInfo.TargetGLVersion.toString().c_str(),
@@ -30,7 +34,6 @@ namespace MobileGL {
 
             case GL_RENDERER:
             {
-                static String rendererString;
                 if (rendererString.empty()) {
                     String deviceInfo;
                     rendererString = std::format("{} ({}) ({})",
@@ -41,7 +44,6 @@ namespace MobileGL {
                 return (const GLubyte*)rendererString.c_str();
             }
             case GL_SHADING_LANGUAGE_VERSION:
-                static String shadingLanguageVersion;
                 if (shadingLanguageVersion.empty()) {
                     shadingLanguageVersion = std::format("{} MobileGL",
                         MG_Config::RendererInfoPtr->RendererGLInfo.TargetGLSLVersion.toString(
@@ -49,7 +51,6 @@ namespace MobileGL {
                 }
                 return (const GLubyte*)shadingLanguageVersion.c_str();
             case GL_EXTENSIONS:
-                static String extensionsString;
                 if (extensionsString.empty()) {
                     for (auto& ext : MG_Config::RendererInfoPtr->RendererGLInfo.Extensions) {
                         extensionsString += MG_Util::ConvertetGLExtToString(ext);
@@ -124,5 +125,10 @@ namespace MobileGL {
                 break;
             }
         }
+
+        GLenum GetError() {
+			ErrorCode errorCode = MG_State::pGLContext->PopGLError().value_or(Error{ ErrorCode::NoError, nullptr }).code;
+            return MG_Util::ConvertErrorCodeToGLEnum(errorCode);
+        }
 	}
 }

MobileGL/MG_Impl/GLImpl/Getter/GL_Getter.h

@@ -2,8 +2,10 @@
 
 namespace MobileGL {
 	namespace MG_Impl::GLImpl {
+		/* @INSERTION_POINT:FUNCTION_DECLARATION@ */
 		const GLubyte* GetString(GLenum name);
 		const GLubyte* GetStringi(GLenum name, GLuint index);
 		void GetIntegerv(GLenum pname, GLint* params);
+		GLenum GetError();
 	}
 }