make some changes to opengl api gen, discussing on rewrite of all opengl binding, making it neat and structral

src/StgSharp.Common/HighPerformance/Memory/BufferStack.cs

@@ -6,6 +6,7 @@
 // -----------------------------------------------------------------------------
 
 using System;
+using System.Buffers;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
@@ -92,6 +93,50 @@ namespace StgSharp.HighPerformance.Memory
             return true;
         }
 
+        /// <summary>
+        /// Fills the stack in place via a caller-supplied callback, mirroring
+        /// <c>CapacityFixedStack&lt;T&gt;.FillRange</c>.
+        /// </summary>
+        /// <remarks>
+        /// Preferred over building a temporary span and handing it to
+        /// <see cref="BufferStackBuilder.Create{T}(ReadOnlySpan{T})"/>:
+        /// <list type="bullet">
+        /// <item>The caller no longer needs a scratch buffer at all — the
+        /// callback writes straight into this stack's native storage, so there
+        /// is no <c>stackalloc</c> to size and no copy afterwards.</item>
+        /// <item><c>Span&lt;T&gt;</c> does not implicitly convert to
+        /// <c>ReadOnlySpan&lt;T&gt;</c> in a way that participates in generic
+        /// type inference before C# 14, so <c>Create(span)</c> fails with
+        /// CS0411 on older compilers. Passing the element type through the
+        /// enclosing instance sidesteps inference entirely.</item>
+        /// </list>
+        /// </remarks>
+        internal unsafe void FillRange(
+                             SpanAction<T, nuint> filling,
+                             nuint buffer
+        )
+        {
+            if (filling is null) {
+                return;
+            }
+
+            Header* header = (Header*)_buffer;
+            T* dataStart = (T*)(_buffer + sizeof(Header));
+
+            // Hand out only the unused tail, matching CapacityFixedStack:
+            // filling is an append, not a rewrite of live entries.
+            int start = (int)header->Top;
+            int room = (int)header->Capacity - start;
+            if (room <= 0) {
+                return;
+            }
+
+            filling(new Span<T>(dataStart + start, room), buffer);
+
+            header->Top = header->Capacity;
+            _count = header->Capacity;
+        }
+
         // Internal method for efficient bulk initialization
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal unsafe void InitializeFromSpan(

src/StgSharp.Common/HighPerformance/Memory/ConcurrentBufferStack.cs

@@ -8,6 +8,7 @@
 using StgSharp.Threading;
 
 using System;
+using System.Buffers;
 using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -253,6 +254,49 @@ namespace StgSharp.HighPerformance.Memory
             }
         }
 
+        /// <summary>
+        /// Fills the stack in place via a caller-supplied callback, mirroring
+        /// <c>CapacityFixedStack&lt;T&gt;.FillRange</c>.
+        /// </summary>
+        /// <remarks>
+        /// Intended for construction only, and therefore takes no lock — the
+        /// instance is not yet published to other threads at that point. Do not
+        /// call it on a stack that is already in concurrent use.
+        /// <para>
+        /// Preferred over building a temporary span and handing it to
+        /// <see cref="BufferStackBuilder.CreateConcurrent{T}(ReadOnlySpan{T})"/>
+        /// for the same two reasons as the non-concurrent variant: the callback
+        /// writes straight into native storage (no scratch buffer, no copy),
+        /// and passing the element type through the enclosing instance avoids
+        /// the <c>Span</c>-to-<c>ReadOnlySpan</c> inference gap that yields
+        /// CS0411 before C# 14.
+        /// </para>
+        /// </remarks>
+        internal unsafe void FillRange(
+                             SpanAction<T, nuint> filling,
+                             nuint buffer
+        )
+        {
+            if (filling is null) {
+                return;
+            }
+
+            Header* header = (Header*)_buffer;
+            T* dataStart = (T*)(_buffer + sizeof(Header));
+
+            // Append into the unused tail only, matching CapacityFixedStack.
+            int start = header->Top;
+            int room = header->Capacity - start;
+            if (room <= 0) {
+                return;
+            }
+
+            filling(new Span<T>(dataStart + start, room), buffer);
+
+            header->Top = header->Capacity;
+            Volatile.Write(ref _count, header->Capacity);
+        }
+
         // Internal method for efficient bulk initialization
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal unsafe void InitializeFromSpan(

src/StgSharp.Common/HighPerformance/Memory/SlabAllocator.Chunked.cs

@@ -40,15 +40,28 @@ namespace StgSharp.HighPerformance.Memory
                 > 64 => 64,
                 _ => (int)count
             };
-            Span<nuint> span = stackalloc nuint[initCount];
-            for (int i = 0; i < initCount; i++) {
-                span[i] = _currentBuffer + ((nuint)(i * _elementSize));
-            }
             _buffers = new(4);
             _buffers.Push(_currentBuffer);
-            _recycle = BufferStackBuilder.Create(span);
+
+            // Fill through a callback rather than building a scratch span and
+            // passing it to BufferStackBuilder.Create: no stackalloc, no copy,
+            // and no reliance on Span-to-ReadOnlySpan inference (CS0411 before
+            // C# 14). Same shape as FixedSlabAllocator.
+            int elementSize = _elementSize;
+            _recycle = new(initCount);
+            _recycle.FillRange(init, _currentBuffer);
             _currentCapacity = count;
             _currentIndex = (nuint)initCount;
+
+            void init(
+                 Span<nuint> arr,
+                 nuint buffer
+            )
+            {
+                for (int i = 0; i < arr.Length; i++) {
+                    arr[i] = buffer + ((nuint)(i * elementSize));
+                }
+            }
         }
 
         public override nuint Allocate()

src/StgSharp.Common/HighPerformance/Memory/SlabAllocator.ChunkedConcurrent.cs

@@ -44,14 +44,26 @@ namespace StgSharp.HighPerformance.Memory
                 > 64 => 64,
                 _ => (int)count
             };
-            Span<nuint> span = stackalloc nuint[initCount];
-            for (int i = 0; i < initCount; i++) {
-                span[i] = _currentBuffer + (nuint)(i * _elementSize);
-            }
             _buffers = new(4);
-            _recycle = BufferStackBuilder.CreateConcurrent(span);
+
+            // Callback fill instead of scratch span + CreateConcurrent: avoids
+            // the stackalloc and the copy, and sidesteps the CS0411 inference
+            // gap. Safe without locking — not yet published to other threads.
+            int elementSize = _elementSize;
+            _recycle = new(initCount);
+            _recycle.FillRange(init, _currentBuffer);
             _currentCapacity = count;
             _currentIndex = (nuint)initCount;
+
+            void init(
+                 Span<nuint> arr,
+                 nuint buffer
+            )
+            {
+                for (int i = 0; i < arr.Length; i++) {
+                    arr[i] = buffer + (nuint)(i * elementSize);
+                }
+            }
         }
 
         public override nuint Allocate()

src/StgSharp.Common/HighPerformance/Memory/SlabAllocator.SequencialConcurrent.cs

@@ -43,12 +43,26 @@ namespace StgSharp.HighPerformance.Memory
                 > 64 => 64,
                 _ => ((int)_capacity) / 4
             };
-            Span<nuint> span = stackalloc nuint[initCount];
-            for (int i = 0; i < initCount; i++) {
-                span[i] = (nuint)i;
-            }
-            _stack = BufferStackBuilder.CreateConcurrent(span);
+            // Callback fill instead of scratch span + CreateConcurrent: avoids
+            // the stackalloc and the copy, and sidesteps the CS0411 inference
+            // gap. Safe without locking — not yet published to other threads.
+            //
+            // Note this variant stores *indices*, not addresses, so the buffer
+            // argument is unused here; it is kept to match the shared
+            // SpanAction<T, nuint> shape.
+            _stack = new(initCount);
+            _stack.FillRange(init, 0);
             _highestAllocated += (nuint)initCount;
+
+            static void init(
+                        Span<nuint> arr,
+                        nuint _
+            )
+            {
+                for (int i = 0; i < arr.Length; i++) {
+                    arr[i] = (nuint)i;
+                }
+            }
         }
 
         internal T* BasePointer => _buffer;

src/StgSharp.Graphics/OpenGL/Api/OpenGLFunction.Buffer.cs

@@ -0,0 +1,165 @@
+// -----------------------------------------------------------------------------
+// file="OpenGLFunction.Buffer"
+// Project: StgSharp
+// Copyright (c) Nitload.
+// SPDX-License-Identifier: MIT
+// -----------------------------------------------------------------------------
+
+using StgSharp.Mathematics.Numeric;
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public unsafe partial class OpenGLFunction
+    {
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BindBuffer(
+                    BufferType bufferType,
+                    GlHandle handle
+        )
+        {
+            _context->glBindBuffer((uint)bufferType, handle.Value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void DeleteBuffer(
+                           GlHandle handle
+        )
+        {
+            _context->glDeleteBuffers(1, (uint*)&handle);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void DeleteBuffers(
+                           GlHandle[] handle
+        )
+        {
+            if ((handle == null) || (handle.Length == 0)) {
+                throw new ArgumentNullException(nameof(handle));
+            }
+            fixed (GlHandle* hptr = handle)
+            {
+                uint* iptr = (uint*)hptr;
+                for (int i = 0; i < handle.Length; i++) {
+                    _context->glDeleteBuffers(1, iptr + i);
+                }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe GlHandle[] GenBuffers(
+                                 int count
+        )
+        {
+            GlHandle[] h = new GlHandle[count];
+            fixed (GlHandle* hptr = h)
+            {
+                for (int i = 0; i < count; i++) {
+                    _context->glGenBuffers(count, ((uint*)hptr) + i);
+                }
+            }
+            return h;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void SetBufferData<T>(
+                           BufferType bufferType,
+                           T bufferData,
+                           BufferUsage usage
+        ) where T : unmanaged, INumber<T>
+        {
+            int size = Marshal.SizeOf<T>();
+            T* p = &bufferData;
+            _context->glBufferData((uint)bufferType, size, (nint*)p, (uint)usage);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void SetBufferData<T>(
+                           BufferType bufferType,
+                           [NotNull] T[] bufferArray,
+                           BufferUsage usage
+        ) where T : unmanaged, INumber<T>
+        {
+            int size = bufferArray.Length * Marshal.SizeOf<T>();
+            if (bufferArray == null) {
+                return;
+            }
+
+            fixed (void* bufferPtr = bufferArray) {
+                _context->glBufferData((uint)bufferType, size, (nint*)bufferPtr, (uint)usage);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void SetBufferData<T>(
+                           BufferType bufferType,
+                           ReadOnlySpan<T> bufferSpan,
+                           BufferUsage usage
+        ) where T : unmanaged, INumber<T>
+        {
+            int size = bufferSpan.Length * Marshal.SizeOf<T>();
+            if (bufferSpan.IsEmpty) {
+                return;
+            }
+
+            fixed (void* bufferPtr = bufferSpan) {
+                _context->glBufferData((uint)bufferType, size, (IntPtr*)bufferPtr, (uint)usage);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void SetBufferData<T>(
+                           BufferType bufferType,
+                           Span<T> bufferArray,
+                           BufferUsage usage
+        ) where T : unmanaged, INumber<T>
+        {
+            int size = bufferArray.Length * Marshal.SizeOf<T>();
+            if (bufferArray.IsEmpty) {
+                return;
+            }
+
+            fixed (void* bufferPtr = bufferArray) {
+                _context->glBufferData((uint)bufferType, size, (IntPtr*)bufferPtr, (uint)usage);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void SetBufferVectorData<T>(
+                           BufferType bufferType,
+                           ReadOnlySpan<T> bufferSpan,
+                           BufferUsage usage
+        ) where T : unmanaged, IUnmanagedVector<T>
+        {
+            int size = bufferSpan.Length * Marshal.SizeOf<T>();
+
+            fixed (void* bufferPtr = bufferSpan) {
+                _context->glBufferData((uint)bufferType, size, (IntPtr*)bufferPtr, (uint)usage);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void SetBufferVectorData<T>(
+                           BufferType bufferType,
+                           T[] bufferArray,
+                           BufferUsage usage
+        ) where T : unmanaged, IUnmanagedVector<T>
+        {
+            int size = bufferArray.Length * Marshal.SizeOf(typeof(T));
+            if (bufferArray == null) {
+                return;
+            }
+            fixed (void* bufferPtr = bufferArray) {
+                _context->glBufferData((uint)bufferType, (nuint)size, (IntPtr*)bufferPtr,
+                                       (uint)usage);
+            }
+        }
+
+    }
+}

src/StgSharp.Graphics/OpenGL/Api/OpenGLFunction.Context.cs

@@ -0,0 +1,76 @@
+// -----------------------------------------------------------------------------
+// file="OpenGLFunction.Context"
+// Project: StgSharp
+// Copyright (c) Nitload.
+// SPDX-License-Identifier: MIT
+// -----------------------------------------------------------------------------
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Threading;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public unsafe partial class OpenGLFunction
+    {
+
+        private static readonly Dictionary<IntPtr, OpenGLFunction> contextToGLMap = [];
+        private static readonly ThreadLocal<OpenGLFunction> _currentGL = new();
+        private OpenglContext* _context;
+
+        private readonly Lazy<int> _attachmentColorRange;
+
+        private OpenGLFunction()
+        {
+            textureUnitCountGetter = glConst.MAX_TEXTURE_IMAGE_UNITS;
+            UnusedTextureImageUint = [];
+            _attachmentColorRange = new Lazy<int>(
+                () => GetMaskInteger(glConst.MAX_COLOR_ATTACHMENTS));
+        }
+
+        public int AttachmentColorRange => _attachmentColorRange.Value;
+
+        public static OpenGLFunction CurrentGL
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => _currentGL.Value!;
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            internal set => _currentGL.Value = value;
+        }
+
+        internal IntPtr ContextHandle => (IntPtr)_context;
+
+        protected ref OpenglContext Context
+        {
+            get
+            {
+                #if DEBUG
+                ArgumentNullException.ThrowIfNull(_context, nameof(_context));
+                #endif
+                return ref (*_context);
+            }
+        }
+
+        internal static OpenGLFunction BuildGlFunctionPackage(
+                                       IntPtr handle
+        )
+        {
+            if (contextToGLMap.TryGetValue(handle, out OpenGLFunction pack)) {
+                return pack;
+            }
+            pack = new OpenGLFunction
+            {
+                _context = (OpenglContext*)handle
+            };
+            contextToGLMap.Add(handle, pack);
+            return pack;
+        }
+
+        ~OpenGLFunction()
+        {
+            _ = contextToGLMap.Remove(ContextHandle);
+        }
+
+    }
+}

src/StgSharp.Graphics/OpenGL/Api/OpenGLFunction.Diagnostics.cs

@@ -0,0 +1,72 @@
+// -----------------------------------------------------------------------------
+// file="OpenGLFunction.Diagnostics"
+// Project: StgSharp
+// Copyright (c) Nitload.
+// SPDX-License-Identifier: MIT
+// -----------------------------------------------------------------------------
+
+using System;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public unsafe partial class OpenGLFunction
+    {
+
+        [Conditional("DEBUG")]
+        public void Assert(
+                    bool shouldReportWhenNormal
+        )
+        {
+            uint code = _context->glGetError();
+            if (code != glConst.NO_ERROR) {
+                throw new GlExecutionException(code);
+            }
+            if (shouldReportWhenNormal) {
+                Console.WriteLine("OpenGL runs normally");
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ClearError()
+        {
+            uint code = 0;
+            for (int i = 0; i < 1024; i++)
+            {
+                code = _context->glGetError();
+                if (code == 0) {
+                    return;
+                }
+
+                // Console.WriteLine(code);
+            }
+            foreach (ProcessThread thread in Process.GetCurrentProcess().Threads) {
+                Debugger.Break();
+            }
+            throw new GlErrorOverflowException(1024, code);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void ClearGraphicError()
+        {
+            while (_context->glGetError() != 0) { }
+        }
+
+        public unsafe int GetMaskInteger(
+                          uint statusCode
+        )
+        {
+            int ret = 0;
+            _context->glGetIntegerv(statusCode, &ret);
+            return ret;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WaitAccomplishment()
+        {
+            _context->glFinish();
+        }
+
+    }
+}

src/StgSharp.Graphics/OpenGL/Api/OpenGLFunction.Drawing.cs

@@ -0,0 +1,105 @@
+// -----------------------------------------------------------------------------
+// file="OpenGLFunction.Drawing"
+// Project: StgSharp
+// Copyright (c) Nitload.
+// SPDX-License-Identifier: MIT
+// -----------------------------------------------------------------------------
+
+using System;
+using System.Runtime.CompilerServices;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public unsafe partial class OpenGLFunction
+    {
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Clear(
+                    MaskBufferBit mask
+        )
+        {
+            _context->glClear((uint)mask);
+        }
+
+        public void DepthMaskAccess(
+                    bool isWrite
+        )
+        {
+            _context->glDepthMask(isWrite ? (byte)1 : (byte)0);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Disable(
+                    glOperation operation
+        )
+        {
+            _context->glDisable((uint)operation);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void DrawArrays(
+                           GeometryType mode,
+                           int first,
+                           int count
+        )
+        {
+            _context->glDrawArrays((uint)mode, first, count);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void DrawElements(
+                           GeometryType mode,
+                           int count,
+                           TypeCode type,
+                           IntPtr ptr
+        )
+        {
+            uint a = type switch
+            {
+                TypeCode.UInt32 => glConst.UNSIGNED_INT,
+                TypeCode.UInt16 => glConst.UNSIGNED_SHORT,
+                TypeCode.Byte => glConst.UNSIGNED_BYTE,
+                _ => throw new ArgumentException(
+                    $"Parameter error in parameter {nameof(type)} method DrawElements. Only {typeof(uint).Name},{typeof(ushort).Name},{typeof(byte).Name} types are supported.")
+            };
+            _context->glDrawElements((uint)mode, count, a, (nint*)ptr);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void DrawElementsInstanced(
+                    GeometryType mode,
+                    int count,
+                    TypeCode type,
+                    IntPtr ptr,
+                    int amount
+        )
+        {
+            uint a = type switch
+            {
+                TypeCode.UInt32 => glConst.UNSIGNED_INT,
+                TypeCode.UInt16 => glConst.UNSIGNED_SHORT,
+                TypeCode.Byte => glConst.UNSIGNED_BYTE,
+                _ => throw new ArgumentException(
+                    $"Parameter error in parameter {nameof(type)} method DrawElements. Only {typeof(uint).Name},{typeof(ushort).Name},{typeof(byte).Name} types are supported.")
+            };
+            _context->glDrawElementsInstanced((uint)mode, count, a, (nint*)ptr, amount);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Enable(
+                    glOperation operation
+        )
+        {
+            _context->glEnable((uint)operation);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void PolygonMode(
+                    FaceMode mode
+        )
+        {
+            _context->glPolygonMode(glConst.FRONT_AND_BACK, (uint)mode);
+        }
+
+    }
+}

src/StgSharp.Graphics/OpenGL/Api/OpenGLFunction.Framebuffer.cs

@@ -0,0 +1,122 @@
+// -----------------------------------------------------------------------------
+// file="OpenGLFunction.Framebuffer"
+// Project: StgSharp
+// Copyright (c) Nitload.
+// SPDX-License-Identifier: MIT
+// -----------------------------------------------------------------------------
+
+using System;
+using System.Runtime.CompilerServices;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public unsafe partial class OpenGLFunction
+    {
+
+        /// <summary>Generate framebuffer object handles into the supplied storage.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GenFrameBuffers(
+                    Span<GlHandle> framebuffers
+        )
+        {
+            fixed (GlHandle* framebuffersPtr = framebuffers) {
+                Context.glGenFramebuffers(framebuffers.Length, (uint*)framebuffersPtr);
+            }
+        }
+
+        /// <summary>
+        ///   Bind a framebuffer object to a framebuffer target.
+        /// </summary>
+        /// <param name="target">The framebuffer target of the binding operation.</param>
+        /// <param name="handle">The framebuffer object handle to bind.</param>
+        /// <seealso href="https://docs.gl/gl3/glBindFramebuffer" />
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BindFrameBuffer(
+                    FrameBufferTarget target,
+                    GlHandle handle
+        )
+        {
+            _context->glBindFramebuffer((uint)target, handle.Value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BindRenderBuffer(
+                    GlHandle handle
+        )
+        {
+            _context->glBindRenderbuffer(glConst.RENDERBUFFER, handle.Value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public FrameBufferStatus CheckFrameBufferStatus(
+                                 FrameBufferTarget target
+        )
+        {
+            return (FrameBufferStatus)_context->glCheckFramebufferStatus((uint)target);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void CombineFrameBufferRenderBuffer(
+                    FrameBufferAttachment attachment,
+                    GlHandle rboHandle
+        )
+        {
+            _context->glFramebufferRenderbuffer(glConst.FRAMEBUFFER, (uint)attachment,
+                                                glConst.RENDERBUFFER, rboHandle.Value);
+        }
+
+        /// <summary>Delete one renderbuffer object.</summary>
+        public unsafe void DeleteRenderBuffer(
+                           GlHandle bufferHandle
+        )
+        {
+            _context->glDeleteRenderbuffers(1, &bufferHandle.Value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void FrameBufferTexture2d(
+                    FrameBufferTarget target,
+                    uint attachment,
+                    Texture2DTarget texTarget,
+                    GlHandle textureHandle,
+                    int level
+        )
+        {
+            _context->glFramebufferTexture2D((uint)target, attachment, (uint)texTarget,
+                                             textureHandle.Value, level);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe GlHandle[] GenRenderBuffer(
+                                 int count
+        )
+        {
+            GlHandle[] h = new GlHandle[count];
+            fixed (GlHandle* hptr = h) {
+                _context->glGenRenderbuffers(count, (uint*)hptr);
+            }
+            return h;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void SetRenderBufferStorage(
+                           RenderBufferInternalFormat internalFormat,
+                           (int width, int height) size
+        )
+        {
+            _context->glRenderbufferStorage(glConst.RENDERBUFFER, (uint)internalFormat, size.width,
+                                            size.height);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void SetRenderBufferStorage(
+                           RenderBufferInternalFormat internalFormat,
+                           (uint width, uint height) size
+        )
+        {
+            _context->glRenderbufferStorage(glConst.RENDERBUFFER, (uint)internalFormat,
+                                            (int)size.width, (int)size.height);
+        }
+
+    }
+}

src/StgSharp.Graphics/OpenGL/Api/OpenGLFunction.Shader.cs

@@ -0,0 +1,131 @@
+// -----------------------------------------------------------------------------
+// file="OpenGLFunction.Shader"
+// Project: StgSharp
+// Copyright (c) Nitload.
+// SPDX-License-Identifier: MIT
+// -----------------------------------------------------------------------------
+
+using StgSharp.Graphics;
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public unsafe partial class OpenGLFunction
+    {
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe GlHandle CreateGraphicProgram()
+        {
+            return GlHandle.Create(_context->glCreateProgram());
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe GlHandle[] CreateProgram(
+                                 int count
+        )
+        {
+            GlHandle[] h = new GlHandle[count];
+            for (int i = 0; i < count; i++) {
+                h.SetValue(i, _context->glCreateProgram());
+            }
+            return h;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public GlHandle[] CreateShaderSet(
+                          int count,
+                          ShaderType type
+        )
+        {
+            GlHandle[] ret = new GlHandle[count];
+            uint t = (uint)type;
+            for (int i = 0; i < count; i++)
+            {
+                uint id = _context->glCreateShader(t);
+                if (id == 0)
+                {
+                    uint error = _context->glGetError();
+                    throw new InvalidOperationException($"Failed in creating shader: {error}");
+                }
+                ret[i] = GlHandle.Create(id);
+            }
+            return ret;
+        }
+
+        public string GetShaderStatus(
+                      Shader s,
+                      int index,
+                      int key
+        )
+        {
+            IntPtr sptr = IntPtr.Zero;
+            if (GraphicFramework.glCheckShaderStatus(ref Context, s.handle[index].Value, key,
+                                                     ref sptr) == 0) {
+                return Marshal.PtrToStringAnsi(sptr) ?? string.Empty;
+            }
+            return string.Empty;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe GlHandle GetUniformLocation(
+                               GlHandle program,
+                               string name
+        )
+        {
+            byte[] code = Encoding.UTF8.GetBytes(name);
+            fixed (byte* ptr = code)
+            {
+                int ret = _context->glGetUniformLocation(program.Value, ptr);
+                #if DEBUG
+                if (ret is glConst.INVALID_OPERATION or glConst.INVALID_VALUE)
+                {
+                    throw new InvalidOperationException();
+                }
+                if (ret == -1) {
+                    throw new UniformEmptyReferenceException(nameof(program), name);
+                }
+                #endif
+                return GlHandle.CreateSigned(ret);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void LoadShaderSource(
+                           GlHandle shaderHandle,
+                           byte[] codeStream
+        )
+        {
+            fixed (byte* streamPtr = codeStream) {
+                _context->glShaderSource(shaderHandle.Value, 1, &streamPtr, (int*)0);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void LoadShaderSource(
+                           GlHandle shaderHandle,
+                           ReadOnlySpan<char> codeStream
+        )
+        {
+            fixed (char* streamPtr = codeStream) {
+                _context->glShaderSource(shaderHandle.Value, 1, (byte**)&streamPtr, (int*)0);
+            }
+        }
+
+        public unsafe void LoadShaderSource(
+                           GlHandle shaderHandle,
+                           ReadOnlySpan<byte> codeStream
+        )
+        {
+            fixed (byte* streamPtr = codeStream)
+            {
+                byte* bptr = streamPtr;
+                _context->glShaderSource(shaderHandle.Value, 1, &bptr, (int*)0);
+            }
+        }
+
+    }
+}

src/StgSharp.Graphics/OpenGL/Api/OpenGLFunction.Texture.cs

@@ -0,0 +1,149 @@
+// -----------------------------------------------------------------------------
+// file="OpenGLFunction.Texture"
+// Project: StgSharp
+// Copyright (c) Nitload.
+// SPDX-License-Identifier: MIT
+// -----------------------------------------------------------------------------
+
+using StgSharp.Graphics;
+
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public unsafe partial class OpenGLFunction
+    {
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ActiveTextureUnit(
+                    uint type
+        )
+        {
+            _context->glActiveTexture(type);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe GlHandle[] GenTextures(
+                                 int count
+        )
+        {
+            GlHandle[] h = new GlHandle[count];
+            fixed (GlHandle* hptr = h) {
+                _context->glGenTextures(count, (uint*)hptr);
+            }
+            return h;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void GetTextureImage<T>(
+                           Texture2DTarget target,
+                           int level,
+                           ImageChannel channel,
+                           PixelChannelLayout channelLayout,
+                           T[] dataStream
+        ) where T : unmanaged, INumber<T>
+        {
+            fixed (T* tptr = dataStream) {
+                _context->glGetTexImage((uint)target, level, (uint)channel, (uint)channelLayout,
+                                        (nint*)tptr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetTextureLevelProperty(
+                    uint textureTypeMask,
+                    int level,
+                    uint propertyMask,
+                    out int propertyValue
+        )
+        {
+            fixed (int* iptr = &propertyValue) {
+                _context->glGetTexLevelParameteriv(textureTypeMask, level, propertyMask, iptr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadPixels(
+                    (int X, int Y) beginPosition,
+                    (int width, int height) size,
+                    FrameBufferChannel format,
+                    PixelChannelLayout dataType,
+                    ref byte[] stream
+        )
+        {
+            fixed (byte* bptr = stream) {
+                _context->glReadPixels(beginPosition.X, beginPosition.Y, size.width, size.height,
+                                       (uint)format, (uint)dataType, (nint*)bptr);
+            }
+        }
+
+        public void RereadImage(
+                    in Image i,
+                    (int X, int Y) beginPosition,
+                    FrameBufferChannel format,
+                    PixelChannelLayout dataType
+        )
+        {
+            byte[] pixels = i.PixelBuffer;
+            if (!pixels.CheckArrayFormat(dataType)) {
+                throw new GlArrayFormatException(dataType, "i.PixelArray");
+            }
+            fixed (byte* bptr = pixels) {
+                _context->glReadPixels(beginPosition.X, beginPosition.Y, i.Width, i.Height,
+                                       (uint)format, (uint)dataType, (nint*)bptr);
+            }
+            i.PixelUpdateCount++;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void TextureImage2d<T>(
+                    Texture2DTarget target,
+                    int level,
+                    ImageChannel sourceChannel,
+                    int width,
+                    int height,
+                    ImageChannel targetChannel,
+                    PixelChannelLayout type,
+                    T[] pixels
+        ) where T : unmanaged, INumber<T>
+        {
+            fixed (T* tptr = pixels)
+            {
+                T* ptr = ((pixels == null) || (pixels.Length == 0)) ? (T*)IntPtr.Zero : tptr;
+                _context->glTexImage2D((uint)target, level, (int)sourceChannel, width, height, 0,
+                                       (uint)targetChannel, (uint)type, (nint*)tptr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void TextureImage2d<T>(
+                    Texture2DTarget target,
+                    int level,
+                    ImageChannel sourceChannel,
+                    int width,
+                    int height,
+                    ImageChannel targetChannel,
+                    PixelChannelLayout type,
+                    Span<T> pixelSpan
+        ) where T : unmanaged, INumber<T>
+        {
+            fixed (T* tPtr = pixelSpan) {
+                _context->glTexImage2D((uint)target, level, (int)sourceChannel, width, height, 0,
+                                       (uint)targetChannel, (uint)type, (nint*)tPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void TextureParameter(
+                    int target,
+                    uint pname,
+                    int param
+        )
+        {
+            _context->glTexParameteri((uint)target, pname, param);
+        }
+
+    }
+}

src/StgSharp.Graphics/OpenGL/Api/OpenGLFunction.TextureUnits.cs

@@ -1,12 +1,10 @@
 // -----------------------------------------------------------------------------
-// file="glFunction.SourceManager"
+// file="OpenGLFunction.TextureUnits"
 // Project: StgSharp
 // Copyright (c) Nitload.
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-using StgSharp;
-
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
@@ -70,4 +68,4 @@ namespace StgSharp.Graphics.OpenGL
         }
 
     }
-}
+}

src/StgSharp.Graphics/OpenGL/Api/OpenGLFunction.Uniform.cs

@@ -0,0 +1,29 @@
+// -----------------------------------------------------------------------------
+// file="OpenGLFunction.Uniform"
+// Project: StgSharp
+// Copyright (c) Nitload.
+// SPDX-License-Identifier: MIT
+// -----------------------------------------------------------------------------
+
+using StgSharp.Mathematics.Graphics;
+
+using System;
+using System.Runtime.CompilerServices;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public unsafe partial class OpenGLFunction
+    {
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(
+                    Uniform<float, float, float, float> uniform,
+                    Vec4 vec
+        )
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glUniform4fv(uniform.id.SignedValue, 1, (float*)&vec);
+        }
+
+    }
+}

src/StgSharp.Graphics/OpenGL/Api/OpenGLFunction.VertexArray.cs

@@ -0,0 +1,77 @@
+// -----------------------------------------------------------------------------
+// file="OpenGLFunction.VertexArray"
+// Project: StgSharp
+// Copyright (c) Nitload.
+// SPDX-License-Identifier: MIT
+// -----------------------------------------------------------------------------
+
+using StgSharp.Graphics;
+
+using System;
+using System.Runtime.CompilerServices;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public unsafe partial class OpenGLFunction
+    {
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BindVertexArray(
+                    GlHandle handle
+        )
+        {
+            _context->glBindVertexArray(handle.Value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void DeleteVertexArrays(
+                           GlHandle[] arrays
+        )
+        {
+            fixed (GlHandle* hptr = arrays)
+            {
+                uint* iptr = (uint*)hptr;
+                for (int i = 0; i < arrays.Length; i++) {
+                    _context->glDeleteVertexArrays(1, iptr + i);
+                }
+            }
+        }
+
+        public unsafe GlHandle[] GenVertexArrays(
+                                 int count
+        )
+        {
+            GlHandle[] h = new GlHandle[count];
+            fixed (GlHandle* hptr = h) {
+                _context->glGenVertexArrays(count, (uint*)hptr);
+            }
+            return h;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetVertexAttribute(
+                    uint index,
+                    int size,
+                    TypeCode t,
+                    bool normalized,
+                    int stride,
+                    int pointer
+        )
+        {
+            uint type = GraphicFramework.GLtype[(int)t];
+            _context->glVertexAttribPointer(index, size, type, (byte)(normalized ? 1 : 0), stride,
+                                            (nint*)pointer);
+            _context->glEnableVertexAttribArray(index);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void VertexAttributeDivisor(
+                    uint layoutIndex,
+                    uint divisor
+        )
+        {
+            _context->glVertexAttribDivisor(layoutIndex, divisor);
+        }
+
+    }
+}

src/StgSharp.Graphics/OpenGL/Generated/OpenGLFunction.Raw.v4_0.g.cs

@@ -0,0 +1,238 @@
+// <auto-generated>
+// Generated by StgSharp.GenerateGL on 2026-08-25 09:22:55Z
+// Version: 4.0
+// </auto-generated>
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using StgSharp.Graphics.OpenGL;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public unsafe partial class OpenGLFunction
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BeginQueryIndexed(uint target, uint index, uint id)
+        {
+            Context.glBeginQueryIndexed(target, index, id);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BindTransformFeedback(uint target, uint id)
+        {
+            Context.glBindTransformFeedback(target, id);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BlendEquationSeparate(uint buf, uint modeRGB, uint modeAlpha)
+        {
+            Context.glBlendEquationSeparatei(buf, modeRGB, modeAlpha);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BlendEquation(uint buf, uint mode)
+        {
+            Context.glBlendEquationi(buf, mode);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BlendFuncSeparate(uint buf, uint srcRGB, uint dstRGB, uint srcAlpha, uint dstAlpha)
+        {
+            Context.glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BlendFunc(uint buf, uint src, uint dst)
+        {
+            Context.glBlendFunci(buf, src, dst);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void DeleteTransformFeedbacks(ReadOnlySpan<uint> ids)
+        {
+            fixed (uint* idsPtr = ids)
+            {
+                Context.glDeleteTransformFeedbacks(checked((int)ids.Length), idsPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void DrawArraysIndirect(uint mode, void* indirect)
+        {
+            Context.glDrawArraysIndirect(mode, indirect);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void DrawElementsIndirect(uint mode, uint type, void* indirect)
+        {
+            Context.glDrawElementsIndirect(mode, type, indirect);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void DrawTransformFeedback(uint mode, uint id)
+        {
+            Context.glDrawTransformFeedback(mode, id);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void DrawTransformFeedbackStream(uint mode, uint id, uint stream)
+        {
+            Context.glDrawTransformFeedbackStream(mode, id, stream);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void EndQueryIndexed(uint target, uint index)
+        {
+            Context.glEndQueryIndexed(target, index);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GenTransformFeedbacks(Span<uint> ids)
+        {
+            fixed (uint* idsPtr = ids)
+            {
+                Context.glGenTransformFeedbacks(checked((int)ids.Length), idsPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetActiveSubroutineName(GlHandle program, uint shadertype, uint index, out int length, Span<byte> name)
+        {
+            length = default;
+            fixed (int* lengthPtr = &length)
+            {
+                fixed (byte* namePtr = name)
+                {
+                    Context.glGetActiveSubroutineName(program.Value, shadertype, index, checked((int)name.Length), lengthPtr, namePtr);
+                }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetActiveSubroutineUniformName(GlHandle program, uint shadertype, uint index, out int length, Span<byte> name)
+        {
+            length = default;
+            fixed (int* lengthPtr = &length)
+            {
+                fixed (byte* namePtr = name)
+                {
+                    Context.glGetActiveSubroutineUniformName(program.Value, shadertype, index, checked((int)name.Length), lengthPtr, namePtr);
+                }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetActiveSubroutineUniformiv(GlHandle program, uint shadertype, uint index, uint pname, Span<int> values)
+        {
+            fixed (int* valuesPtr = values)
+            {
+                Context.glGetActiveSubroutineUniformiv(program.Value, shadertype, index, pname, valuesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetProgramStageiv(GlHandle program, uint shadertype, uint pname, out int values)
+        {
+            values = default;
+            fixed (int* valuesPtr = &values)
+            {
+                Context.glGetProgramStageiv(program.Value, shadertype, pname, valuesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetQueryIndexediv(uint target, uint index, uint pname, Span<int> @params)
+        {
+            fixed (int* @paramsPtr = @params)
+            {
+                Context.glGetQueryIndexediv(target, index, pname, @paramsPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint GetSubroutineIndex(GlHandle program, uint shadertype, ReadOnlySpan<byte> name)
+        {
+            fixed (byte* namePtr = name)
+            {
+                return Context.glGetSubroutineIndex(program.Value, shadertype, namePtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public int GetSubroutineUniformLocation(GlHandle program, uint shadertype, ReadOnlySpan<byte> name)
+        {
+            fixed (byte* namePtr = name)
+            {
+                return Context.glGetSubroutineUniformLocation(program.Value, shadertype, namePtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetUniformSubroutineuiv(uint shadertype, int location, out uint @params)
+        {
+            @params = default;
+            fixed (uint* @paramsPtr = &@params)
+            {
+                Context.glGetUniformSubroutineuiv(shadertype, location, @paramsPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetUniform(GlHandle program, int location, Span<double> @params)
+        {
+            fixed (double* @paramsPtr = @params)
+            {
+                Context.glGetUniformdv(program.Value, location, @paramsPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public byte IsTransformFeedback(uint id)
+        {
+            return Context.glIsTransformFeedback(id);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void MinSampleShading(float value)
+        {
+            Context.glMinSampleShading(value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void PatchParameter(uint pname, ReadOnlySpan<float> values)
+        {
+            fixed (float* valuesPtr = values)
+            {
+                Context.glPatchParameterfv(pname, valuesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void PatchParameter(uint pname, int value)
+        {
+            Context.glPatchParameteri(pname, value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void PauseTransformFeedback()
+        {
+            Context.glPauseTransformFeedback();
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ResumeTransformFeedback()
+        {
+            Context.glResumeTransformFeedback();
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void UniformSubroutinesuiv(uint shadertype, ReadOnlySpan<uint> indices)
+        {
+            fixed (uint* indicesPtr = indices)
+            {
+                Context.glUniformSubroutinesuiv(shadertype, checked((int)indices.Length), indicesPtr);
+            }
+        }
+
+    }
+}

src/StgSharp.Graphics/OpenGL/Generated/OpenGLFunction.Raw.v4_1.g.cs

@@ -0,0 +1,286 @@
+// <auto-generated>
+// Generated by StgSharp.GenerateGL on 2026-08-25 09:22:55Z
+// Version: 4.1
+// </auto-generated>
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using StgSharp.Graphics.OpenGL;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public unsafe partial class OpenGLFunction
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ActiveShaderProgram(uint pipeline, GlHandle program)
+        {
+            Context.glActiveShaderProgram(pipeline, program.Value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BindProgramPipeline(uint pipeline)
+        {
+            Context.glBindProgramPipeline(pipeline);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ClearDepth(float d)
+        {
+            Context.glClearDepthf(d);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public GlHandle CreateShaderProgramv(uint type, int count, byte** strings)
+        {
+            return GlHandle.Create(Context.glCreateShaderProgramv(type, count, strings));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void DeleteProgramPipelines(ReadOnlySpan<uint> pipelines)
+        {
+            fixed (uint* pipelinesPtr = pipelines)
+            {
+                Context.glDeleteProgramPipelines(checked((int)pipelines.Length), pipelinesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void DepthRangeArrayv(uint first, int count, ReadOnlySpan<double> v)
+        {
+            fixed (double* vPtr = v)
+            {
+                Context.glDepthRangeArrayv(first, count, vPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void DepthRangeIndexed(uint index, double n, double f)
+        {
+            Context.glDepthRangeIndexed(index, n, f);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void DepthRange(float n, float f)
+        {
+            Context.glDepthRangef(n, f);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GenProgramPipelines(Span<uint> pipelines)
+        {
+            fixed (uint* pipelinesPtr = pipelines)
+            {
+                Context.glGenProgramPipelines(checked((int)pipelines.Length), pipelinesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetDoublei_v(uint target, uint index, Span<double> data)
+        {
+            fixed (double* dataPtr = data)
+            {
+                Context.glGetDoublei_v(target, index, dataPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetFloati_v(uint target, uint index, Span<float> data)
+        {
+            fixed (float* dataPtr = data)
+            {
+                Context.glGetFloati_v(target, index, dataPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetProgramBinary(GlHandle program, int bufSize, out int length, out uint binaryFormat, void* binary)
+        {
+            length = default;
+            binaryFormat = default;
+            fixed (int* lengthPtr = &length)
+            {
+                fixed (uint* binaryFormatPtr = &binaryFormat)
+                {
+                    Context.glGetProgramBinary(program.Value, bufSize, lengthPtr, binaryFormatPtr, binary);
+                }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetProgramPipelineInfoLog(uint pipeline, out int length, Span<byte> infoLog)
+        {
+            length = default;
+            fixed (int* lengthPtr = &length)
+            {
+                fixed (byte* infoLogPtr = infoLog)
+                {
+                    Context.glGetProgramPipelineInfoLog(pipeline, checked((int)infoLog.Length), lengthPtr, infoLogPtr);
+                }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetProgramPipelineiv(uint pipeline, uint pname, Span<int> @params)
+        {
+            fixed (int* @paramsPtr = @params)
+            {
+                Context.glGetProgramPipelineiv(pipeline, pname, @paramsPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetShaderPrecisionFormat(uint shadertype, uint precisiontype, Span<int> range, out int precision)
+        {
+            precision = default;
+            if (range.Length < 2) {
+                throw new ArgumentException("Span is shorter than the OpenGL length expression '2'.", nameof(range));
+            }
+            fixed (int* rangePtr = range)
+            {
+                fixed (int* precisionPtr = &precision)
+                {
+                    Context.glGetShaderPrecisionFormat(shadertype, precisiontype, rangePtr, precisionPtr);
+                }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetVertexAttribLdv(uint index, uint pname, Span<double> @params)
+        {
+            fixed (double* @paramsPtr = @params)
+            {
+                Context.glGetVertexAttribLdv(index, pname, @paramsPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public byte IsProgramPipeline(uint pipeline)
+        {
+            return Context.glIsProgramPipeline(pipeline);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ProgramBinary(GlHandle program, uint binaryFormat, void* binary, int length)
+        {
+            Context.glProgramBinary(program.Value, binaryFormat, binary, length);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ProgramParameter(GlHandle program, uint pname, int value)
+        {
+            Context.glProgramParameteri(program.Value, pname, value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReleaseShaderCompiler()
+        {
+            Context.glReleaseShaderCompiler();
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ScissorArrayv(uint first, int count, ReadOnlySpan<int> v)
+        {
+            fixed (int* vPtr = v)
+            {
+                Context.glScissorArrayv(first, count, vPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ScissorIndexed(uint index, int left, int bottom, int width, int height)
+        {
+            Context.glScissorIndexed(index, left, bottom, width, height);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ScissorIndexed(uint index, ReadOnlySpan<int> v)
+        {
+            if (v.Length < 4) {
+                throw new ArgumentException("Span is shorter than the OpenGL length expression '4'.", nameof(v));
+            }
+            fixed (int* vPtr = v)
+            {
+                Context.glScissorIndexedv(index, vPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ShaderBinary(ReadOnlySpan<uint> shaders, uint binaryFormat, void* binary, int length)
+        {
+            fixed (uint* shadersPtr = shaders)
+            {
+                Context.glShaderBinary(checked((int)shaders.Length), shadersPtr, binaryFormat, binary, length);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void UseProgramStages(uint pipeline, uint stages, GlHandle program)
+        {
+            Context.glUseProgramStages(pipeline, stages, program.Value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ValidateProgramPipeline(uint pipeline)
+        {
+            Context.glValidateProgramPipeline(pipeline);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void VertexAttribL(uint index, double x)
+        {
+            Context.glVertexAttribL1d(index, x);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void VertexAttribL(uint index, double x, double y)
+        {
+            Context.glVertexAttribL2d(index, x, y);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void VertexAttribL(uint index, double x, double y, double z)
+        {
+            Context.glVertexAttribL3d(index, x, y, z);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void VertexAttribL(uint index, double x, double y, double z, double w)
+        {
+            Context.glVertexAttribL4d(index, x, y, z, w);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void VertexAttribLPointer(uint index, int size, uint type, int stride, void* pointer)
+        {
+            Context.glVertexAttribLPointer(index, size, type, stride, pointer);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ViewportArrayv(uint first, int count, ReadOnlySpan<float> v)
+        {
+            fixed (float* vPtr = v)
+            {
+                Context.glViewportArrayv(first, count, vPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ViewportIndexed(uint index, float x, float y, float w, float h)
+        {
+            Context.glViewportIndexedf(index, x, y, w, h);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ViewportIndexed(uint index, ReadOnlySpan<float> v)
+        {
+            if (v.Length < 4) {
+                throw new ArgumentException("Span is shorter than the OpenGL length expression '4'.", nameof(v));
+            }
+            fixed (float* vPtr = v)
+            {
+                Context.glViewportIndexedfv(index, vPtr);
+            }
+        }
+
+    }
+}

src/StgSharp.Graphics/OpenGL/Generated/OpenGLFunction.Raw.v4_2.g.cs

@@ -0,0 +1,93 @@
+// <auto-generated>
+// Generated by StgSharp.GenerateGL on 2026-08-25 09:22:55Z
+// Version: 4.2
+// </auto-generated>
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using StgSharp.Graphics.OpenGL;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public unsafe partial class OpenGLFunction
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BindImageTexture(uint unit, GlHandle texture, int level, byte layered, int layer, uint access, uint format)
+        {
+            Context.glBindImageTexture(unit, texture.Value, level, layered, layer, access, format);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void DrawArraysInstancedBaseInstance(uint mode, int first, int count, int instancecount, uint baseinstance)
+        {
+            Context.glDrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void DrawElementsInstancedBaseInstance(uint mode, int count, uint type, void* indices, int instancecount, uint baseinstance)
+        {
+            Context.glDrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void DrawElementsInstancedBaseVertexBaseInstance(uint mode, int count, uint type, void* indices, int instancecount, int basevertex, uint baseinstance)
+        {
+            Context.glDrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void DrawTransformFeedbackInstanced(uint mode, uint id, int instancecount)
+        {
+            Context.glDrawTransformFeedbackInstanced(mode, id, instancecount);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void DrawTransformFeedbackStreamInstanced(uint mode, uint id, uint stream, int instancecount)
+        {
+            Context.glDrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetActiveAtomicCounterBufferiv(GlHandle program, GlHandle bufferIndex, uint pname, Span<int> @params)
+        {
+            fixed (int* @paramsPtr = @params)
+            {
+                Context.glGetActiveAtomicCounterBufferiv(program.Value, bufferIndex.Value, pname, @paramsPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetInternalformativ(uint target, uint internalformat, uint pname, Span<int> @params)
+        {
+            fixed (int* @paramsPtr = @params)
+            {
+                Context.glGetInternalformativ(target, internalformat, pname, checked((int)@params.Length), @paramsPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void MemoryBarrier(uint barriers)
+        {
+            Context.glMemoryBarrier(barriers);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void TexStorage1D(uint target, int levels, uint internalformat, int width)
+        {
+            Context.glTexStorage1D(target, levels, internalformat, width);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void TexStorage2D(uint target, int levels, uint internalformat, int width, int height)
+        {
+            Context.glTexStorage2D(target, levels, internalformat, width, height);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void TexStorage3D(uint target, int levels, uint internalformat, int width, int height, int depth)
+        {
+            Context.glTexStorage3D(target, levels, internalformat, width, height, depth);
+        }
+
+    }
+}

src/StgSharp.Graphics/OpenGL/Generated/OpenGLFunction.Raw.v4_3.g.cs

@@ -0,0 +1,379 @@
+// <auto-generated>
+// Generated by StgSharp.GenerateGL on 2026-08-25 09:22:55Z
+// Version: 4.3
+// </auto-generated>
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using StgSharp.Graphics.OpenGL;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public unsafe partial class OpenGLFunction
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BindVertexBuffer(uint bindingindex, GlHandle buffer, nint offset, int stride)
+        {
+            Context.glBindVertexBuffer(bindingindex, buffer.Value, offset, stride);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ClearBufferData(uint target, uint internalformat, uint format, uint type, void* data)
+        {
+            Context.glClearBufferData(target, internalformat, format, type, data);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ClearBufferSubData(uint target, uint internalformat, nint offset, nint size, uint format, uint type, void* data)
+        {
+            Context.glClearBufferSubData(target, internalformat, offset, size, format, type, data);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void CopyImageSubData(uint srcName, uint srcTarget, int srcLevel, int srcX, int srcY, int srcZ, uint dstName, uint dstTarget, int dstLevel, int dstX, int dstY, int dstZ, int srcWidth, int srcHeight, int srcDepth)
+        {
+            Context.glCopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void DebugMessageCallback(IntPtr callback, void* userParam)
+        {
+            Context.glDebugMessageCallback(callback, userParam);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void DebugMessageControl(uint source, uint type, uint severity, ReadOnlySpan<uint> ids, byte enabled)
+        {
+            fixed (uint* idsPtr = ids)
+            {
+                Context.glDebugMessageControl(source, type, severity, checked((int)ids.Length), idsPtr, enabled);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void DebugMessageInsert(uint source, uint type, uint id, uint severity, int length, ReadOnlySpan<byte> buf)
+        {
+            fixed (byte* bufPtr = buf)
+            {
+                Context.glDebugMessageInsert(source, type, id, severity, length, bufPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void DispatchCompute(uint num_groups_x, uint num_groups_y, uint num_groups_z)
+        {
+            Context.glDispatchCompute(num_groups_x, num_groups_y, num_groups_z);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void DispatchComputeIndirect(nint indirect)
+        {
+            Context.glDispatchComputeIndirect(indirect);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void FramebufferParameter(uint target, uint pname, int param)
+        {
+            Context.glFramebufferParameteri(target, pname, param);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint GetDebugMessageLog(Span<uint> sources, Span<uint> types, Span<uint> ids, Span<uint> severities, Span<int> lengths, Span<byte> messageLog)
+        {
+            if (types.Length != sources.Length) {
+                throw new ArgumentException("Span lengths controlled by count must match.", nameof(types));
+            }
+            if (ids.Length != sources.Length) {
+                throw new ArgumentException("Span lengths controlled by count must match.", nameof(ids));
+            }
+            if (severities.Length != sources.Length) {
+                throw new ArgumentException("Span lengths controlled by count must match.", nameof(severities));
+            }
+            if (lengths.Length != sources.Length) {
+                throw new ArgumentException("Span lengths controlled by count must match.", nameof(lengths));
+            }
+            fixed (uint* sourcesPtr = sources)
+            {
+                fixed (uint* typesPtr = types)
+                {
+                    fixed (uint* idsPtr = ids)
+                    {
+                        fixed (uint* severitiesPtr = severities)
+                        {
+                            fixed (int* lengthsPtr = lengths)
+                            {
+                                fixed (byte* messageLogPtr = messageLog)
+                                {
+                                    return Context.glGetDebugMessageLog(checked((uint)sources.Length), checked((int)messageLog.Length), sourcesPtr, typesPtr, idsPtr, severitiesPtr, lengthsPtr, messageLogPtr);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetFramebufferParameteriv(uint target, uint pname, Span<int> @params)
+        {
+            fixed (int* @paramsPtr = @params)
+            {
+                Context.glGetFramebufferParameteriv(target, pname, @paramsPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetInternalformati64v(uint target, uint internalformat, uint pname, Span<long> @params)
+        {
+            fixed (long* @paramsPtr = @params)
+            {
+                Context.glGetInternalformati64v(target, internalformat, pname, checked((int)@params.Length), @paramsPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetObjectLabel(uint identifier, uint name, out int length, Span<byte> label)
+        {
+            length = default;
+            fixed (int* lengthPtr = &length)
+            {
+                fixed (byte* labelPtr = label)
+                {
+                    Context.glGetObjectLabel(identifier, name, checked((int)label.Length), lengthPtr, labelPtr);
+                }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetObjectPtrLabel(void* ptr, out int length, Span<byte> label)
+        {
+            length = default;
+            fixed (int* lengthPtr = &length)
+            {
+                fixed (byte* labelPtr = label)
+                {
+                    Context.glGetObjectPtrLabel(ptr, checked((int)label.Length), lengthPtr, labelPtr);
+                }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetPointerv(uint pname, void** @params)
+        {
+            Context.glGetPointerv(pname, @params);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetProgramInterfaceiv(GlHandle program, uint programInterface, uint pname, Span<int> @params)
+        {
+            fixed (int* @paramsPtr = @params)
+            {
+                Context.glGetProgramInterfaceiv(program.Value, programInterface, pname, @paramsPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint GetProgramResourceIndex(GlHandle program, uint programInterface, ReadOnlySpan<byte> name)
+        {
+            fixed (byte* namePtr = name)
+            {
+                return Context.glGetProgramResourceIndex(program.Value, programInterface, namePtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public int GetProgramResourceLocation(GlHandle program, uint programInterface, ReadOnlySpan<byte> name)
+        {
+            fixed (byte* namePtr = name)
+            {
+                return Context.glGetProgramResourceLocation(program.Value, programInterface, namePtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public int GetProgramResourceLocationIndex(GlHandle program, uint programInterface, ReadOnlySpan<byte> name)
+        {
+            fixed (byte* namePtr = name)
+            {
+                return Context.glGetProgramResourceLocationIndex(program.Value, programInterface, namePtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetProgramResourceName(GlHandle program, uint programInterface, uint index, out int length, Span<byte> name)
+        {
+            length = default;
+            fixed (int* lengthPtr = &length)
+            {
+                fixed (byte* namePtr = name)
+                {
+                    Context.glGetProgramResourceName(program.Value, programInterface, index, checked((int)name.Length), lengthPtr, namePtr);
+                }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetProgramResourceiv(GlHandle program, uint programInterface, uint index, ReadOnlySpan<uint> props, out int length, Span<int> @params)
+        {
+            length = default;
+            fixed (uint* propsPtr = props)
+            {
+                fixed (int* lengthPtr = &length)
+                {
+                    fixed (int* @paramsPtr = @params)
+                    {
+                        Context.glGetProgramResourceiv(program.Value, programInterface, index, checked((int)props.Length), propsPtr, checked((int)@params.Length), lengthPtr, @paramsPtr);
+                    }
+                }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void InvalidateBufferData(GlHandle buffer)
+        {
+            Context.glInvalidateBufferData(buffer.Value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void InvalidateBufferSubData(GlHandle buffer, nint offset, nint length)
+        {
+            Context.glInvalidateBufferSubData(buffer.Value, offset, length);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void InvalidateFramebuffer(uint target, ReadOnlySpan<uint> attachments)
+        {
+            fixed (uint* attachmentsPtr = attachments)
+            {
+                Context.glInvalidateFramebuffer(target, checked((int)attachments.Length), attachmentsPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void InvalidateSubFramebuffer(uint target, ReadOnlySpan<uint> attachments, int x, int y, int width, int height)
+        {
+            fixed (uint* attachmentsPtr = attachments)
+            {
+                Context.glInvalidateSubFramebuffer(target, checked((int)attachments.Length), attachmentsPtr, x, y, width, height);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void InvalidateTexImage(GlHandle texture, int level)
+        {
+            Context.glInvalidateTexImage(texture.Value, level);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void InvalidateTexSubImage(GlHandle texture, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth)
+        {
+            Context.glInvalidateTexSubImage(texture.Value, level, xoffset, yoffset, zoffset, width, height, depth);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void MultiDrawArraysIndirect(uint mode, void* indirect, int drawcount, int stride)
+        {
+            Context.glMultiDrawArraysIndirect(mode, indirect, drawcount, stride);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void MultiDrawElementsIndirect(uint mode, uint type, void* indirect, int drawcount, int stride)
+        {
+            Context.glMultiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ObjectLabel(uint identifier, uint name, int length, ReadOnlySpan<byte> label)
+        {
+            fixed (byte* labelPtr = label)
+            {
+                Context.glObjectLabel(identifier, name, length, labelPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ObjectPtrLabel(void* ptr, int length, ReadOnlySpan<byte> label)
+        {
+            fixed (byte* labelPtr = label)
+            {
+                Context.glObjectPtrLabel(ptr, length, labelPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void PopDebugGroup()
+        {
+            Context.glPopDebugGroup();
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void PushDebugGroup(uint source, uint id, int length, ReadOnlySpan<byte> message)
+        {
+            fixed (byte* messagePtr = message)
+            {
+                Context.glPushDebugGroup(source, id, length, messagePtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ShaderStorageBlockBinding(GlHandle program, uint storageBlockIndex, uint storageBlockBinding)
+        {
+            Context.glShaderStorageBlockBinding(program.Value, storageBlockIndex, storageBlockBinding);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void TexBufferRange(uint target, uint internalformat, GlHandle buffer, nint offset, nint size)
+        {
+            Context.glTexBufferRange(target, internalformat, buffer.Value, offset, size);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void TexStorage2DMultisample(uint target, int samples, uint internalformat, int width, int height, byte fixedsamplelocations)
+        {
+            Context.glTexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void TexStorage3DMultisample(uint target, int samples, uint internalformat, int width, int height, int depth, byte fixedsamplelocations)
+        {
+            Context.glTexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void TextureView(GlHandle texture, uint target, GlHandle origtexture, uint internalformat, uint minlevel, uint numlevels, uint minlayer, uint numlayers)
+        {
+            Context.glTextureView(texture.Value, target, origtexture.Value, internalformat, minlevel, numlevels, minlayer, numlayers);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void VertexAttribBinding(uint attribindex, uint bindingindex)
+        {
+            Context.glVertexAttribBinding(attribindex, bindingindex);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void VertexAttribFormat(uint attribindex, int size, uint type, byte normalized, uint relativeoffset)
+        {
+            Context.glVertexAttribFormat(attribindex, size, type, normalized, relativeoffset);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void VertexAttribIFormat(uint attribindex, int size, uint type, uint relativeoffset)
+        {
+            Context.glVertexAttribIFormat(attribindex, size, type, relativeoffset);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void VertexAttribLFormat(uint attribindex, int size, uint type, uint relativeoffset)
+        {
+            Context.glVertexAttribLFormat(attribindex, size, type, relativeoffset);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void VertexBindingDivisor(uint bindingindex, uint divisor)
+        {
+            Context.glVertexBindingDivisor(bindingindex, divisor);
+        }
+
+    }
+}

src/StgSharp.Graphics/OpenGL/Generated/OpenGLFunction.Raw.v4_4.g.cs

@@ -0,0 +1,111 @@
+// <auto-generated>
+// Generated by StgSharp.GenerateGL on 2026-08-25 09:22:55Z
+// Version: 4.4
+// </auto-generated>
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using StgSharp.Graphics.OpenGL;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public unsafe partial class OpenGLFunction
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BindBuffersBase(uint target, uint first, ReadOnlySpan<uint> buffers)
+        {
+            fixed (uint* buffersPtr = buffers)
+            {
+                Context.glBindBuffersBase(target, first, checked((int)buffers.Length), buffersPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BindBuffersRange(uint target, uint first, ReadOnlySpan<uint> buffers, ReadOnlySpan<nint> offsets, ReadOnlySpan<nint> sizes)
+        {
+            if (offsets.Length != buffers.Length) {
+                throw new ArgumentException("Span lengths controlled by count must match.", nameof(offsets));
+            }
+            if (sizes.Length != buffers.Length) {
+                throw new ArgumentException("Span lengths controlled by count must match.", nameof(sizes));
+            }
+            fixed (uint* buffersPtr = buffers)
+            {
+                fixed (nint* offsetsPtr = offsets)
+                {
+                    fixed (nint* sizesPtr = sizes)
+                    {
+                        Context.glBindBuffersRange(target, first, checked((int)buffers.Length), buffersPtr, offsetsPtr, sizesPtr);
+                    }
+                }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BindImageTextures(uint first, ReadOnlySpan<uint> textures)
+        {
+            fixed (uint* texturesPtr = textures)
+            {
+                Context.glBindImageTextures(first, checked((int)textures.Length), texturesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BindSamplers(uint first, ReadOnlySpan<uint> samplers)
+        {
+            fixed (uint* samplersPtr = samplers)
+            {
+                Context.glBindSamplers(first, checked((int)samplers.Length), samplersPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BindTextures(uint first, ReadOnlySpan<uint> textures)
+        {
+            fixed (uint* texturesPtr = textures)
+            {
+                Context.glBindTextures(first, checked((int)textures.Length), texturesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BindVertexBuffers(uint first, ReadOnlySpan<uint> buffers, ReadOnlySpan<nint> offsets, ReadOnlySpan<int> strides)
+        {
+            if (offsets.Length != buffers.Length) {
+                throw new ArgumentException("Span lengths controlled by count must match.", nameof(offsets));
+            }
+            if (strides.Length != buffers.Length) {
+                throw new ArgumentException("Span lengths controlled by count must match.", nameof(strides));
+            }
+            fixed (uint* buffersPtr = buffers)
+            {
+                fixed (nint* offsetsPtr = offsets)
+                {
+                    fixed (int* stridesPtr = strides)
+                    {
+                        Context.glBindVertexBuffers(first, checked((int)buffers.Length), buffersPtr, offsetsPtr, stridesPtr);
+                    }
+                }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BufferStorage(uint target, nint size, void* data, uint flags)
+        {
+            Context.glBufferStorage(target, size, data, flags);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ClearTexImage(GlHandle texture, int level, uint format, uint type, void* data)
+        {
+            Context.glClearTexImage(texture.Value, level, format, type, data);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ClearTexSubImage(GlHandle texture, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, uint format, uint type, void* data)
+        {
+            Context.glClearTexSubImage(texture.Value, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
+        }
+
+    }
+}

src/StgSharp.Graphics/OpenGL/Generated/OpenGLFunction.Raw.v4_5.g.cs

@@ -0,0 +1,822 @@
+// <auto-generated>
+// Generated by StgSharp.GenerateGL on 2026-08-25 09:22:55Z
+// Version: 4.5
+// </auto-generated>
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using StgSharp.Graphics.OpenGL;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public unsafe partial class OpenGLFunction
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BindTextureUnit(uint unit, GlHandle texture)
+        {
+            Context.glBindTextureUnit(unit, texture.Value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BlitNamedFramebuffer(GlHandle readFramebuffer, GlHandle drawFramebuffer, int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, uint mask, uint filter)
+        {
+            Context.glBlitNamedFramebuffer(readFramebuffer.Value, drawFramebuffer.Value, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint CheckNamedFramebufferStatus(GlHandle framebuffer, uint target)
+        {
+            return Context.glCheckNamedFramebufferStatus(framebuffer.Value, target);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ClearNamedBufferData(GlHandle buffer, uint internalformat, uint format, uint type, void* data)
+        {
+            Context.glClearNamedBufferData(buffer.Value, internalformat, format, type, data);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ClearNamedBufferSubData(GlHandle buffer, uint internalformat, nint offset, nint size, uint format, uint type, void* data)
+        {
+            Context.glClearNamedBufferSubData(buffer.Value, internalformat, offset, size, format, type, data);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ClearNamedFramebuffer(GlHandle framebuffer, uint buffer, int drawbuffer, float depth, int stencil)
+        {
+            Context.glClearNamedFramebufferfi(framebuffer.Value, buffer, drawbuffer, depth, stencil);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ClearNamedFramebuffer(GlHandle framebuffer, uint buffer, int drawbuffer, ReadOnlySpan<float> value)
+        {
+            fixed (float* valuePtr = value)
+            {
+                Context.glClearNamedFramebufferfv(framebuffer.Value, buffer, drawbuffer, valuePtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ClearNamedFramebuffer(GlHandle framebuffer, uint buffer, int drawbuffer, ReadOnlySpan<int> value)
+        {
+            fixed (int* valuePtr = value)
+            {
+                Context.glClearNamedFramebufferiv(framebuffer.Value, buffer, drawbuffer, valuePtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ClearNamedFramebuffer(GlHandle framebuffer, uint buffer, int drawbuffer, ReadOnlySpan<uint> value)
+        {
+            fixed (uint* valuePtr = value)
+            {
+                Context.glClearNamedFramebufferuiv(framebuffer.Value, buffer, drawbuffer, valuePtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ClipControl(uint origin, uint depth)
+        {
+            Context.glClipControl(origin, depth);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void CompressedTextureSubImage1D(GlHandle texture, int level, int xoffset, int width, uint format, int imageSize, void* data)
+        {
+            Context.glCompressedTextureSubImage1D(texture.Value, level, xoffset, width, format, imageSize, data);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void CompressedTextureSubImage2D(GlHandle texture, int level, int xoffset, int yoffset, int width, int height, uint format, int imageSize, void* data)
+        {
+            Context.glCompressedTextureSubImage2D(texture.Value, level, xoffset, yoffset, width, height, format, imageSize, data);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void CompressedTextureSubImage3D(GlHandle texture, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, uint format, int imageSize, void* data)
+        {
+            Context.glCompressedTextureSubImage3D(texture.Value, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void CopyNamedBufferSubData(GlHandle readBuffer, GlHandle writeBuffer, nint readOffset, nint writeOffset, nint size)
+        {
+            Context.glCopyNamedBufferSubData(readBuffer.Value, writeBuffer.Value, readOffset, writeOffset, size);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void CopyTextureSubImage1D(GlHandle texture, int level, int xoffset, int x, int y, int width)
+        {
+            Context.glCopyTextureSubImage1D(texture.Value, level, xoffset, x, y, width);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void CopyTextureSubImage2D(GlHandle texture, int level, int xoffset, int yoffset, int x, int y, int width, int height)
+        {
+            Context.glCopyTextureSubImage2D(texture.Value, level, xoffset, yoffset, x, y, width, height);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void CopyTextureSubImage3D(GlHandle texture, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height)
+        {
+            Context.glCopyTextureSubImage3D(texture.Value, level, xoffset, yoffset, zoffset, x, y, width, height);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void CreateBuffers(Span<uint> buffers)
+        {
+            fixed (uint* buffersPtr = buffers)
+            {
+                Context.glCreateBuffers(checked((int)buffers.Length), buffersPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void CreateFramebuffers(Span<uint> framebuffers)
+        {
+            fixed (uint* framebuffersPtr = framebuffers)
+            {
+                Context.glCreateFramebuffers(checked((int)framebuffers.Length), framebuffersPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void CreateProgramPipelines(Span<uint> pipelines)
+        {
+            fixed (uint* pipelinesPtr = pipelines)
+            {
+                Context.glCreateProgramPipelines(checked((int)pipelines.Length), pipelinesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void CreateQueries(uint target, Span<uint> ids)
+        {
+            fixed (uint* idsPtr = ids)
+            {
+                Context.glCreateQueries(target, checked((int)ids.Length), idsPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void CreateRenderbuffers(Span<uint> renderbuffers)
+        {
+            fixed (uint* renderbuffersPtr = renderbuffers)
+            {
+                Context.glCreateRenderbuffers(checked((int)renderbuffers.Length), renderbuffersPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void CreateSamplers(Span<uint> samplers)
+        {
+            fixed (uint* samplersPtr = samplers)
+            {
+                Context.glCreateSamplers(checked((int)samplers.Length), samplersPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void CreateTextures(uint target, Span<uint> textures)
+        {
+            fixed (uint* texturesPtr = textures)
+            {
+                Context.glCreateTextures(target, checked((int)textures.Length), texturesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void CreateTransformFeedbacks(Span<uint> ids)
+        {
+            fixed (uint* idsPtr = ids)
+            {
+                Context.glCreateTransformFeedbacks(checked((int)ids.Length), idsPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void CreateVertexArrays(Span<uint> arrays)
+        {
+            fixed (uint* arraysPtr = arrays)
+            {
+                Context.glCreateVertexArrays(checked((int)arrays.Length), arraysPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void DisableVertexArrayAttrib(uint vaobj, uint index)
+        {
+            Context.glDisableVertexArrayAttrib(vaobj, index);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void EnableVertexArrayAttrib(uint vaobj, uint index)
+        {
+            Context.glEnableVertexArrayAttrib(vaobj, index);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void FlushMappedNamedBufferRange(GlHandle buffer, nint offset, nint length)
+        {
+            Context.glFlushMappedNamedBufferRange(buffer.Value, offset, length);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GenerateTextureMipmap(GlHandle texture)
+        {
+            Context.glGenerateTextureMipmap(texture.Value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetCompressedTextureImage(GlHandle texture, int level, int bufSize, void* pixels)
+        {
+            Context.glGetCompressedTextureImage(texture.Value, level, bufSize, pixels);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetCompressedTextureSubImage(GlHandle texture, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, int bufSize, void* pixels)
+        {
+            Context.glGetCompressedTextureSubImage(texture.Value, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint GetGraphicsResetStatus()
+        {
+            return Context.glGetGraphicsResetStatus();
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetNamedBufferParameter(GlHandle buffer, uint pname, Span<long> @params)
+        {
+            fixed (long* @paramsPtr = @params)
+            {
+                Context.glGetNamedBufferParameteri64v(buffer.Value, pname, @paramsPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetNamedBufferParameter(GlHandle buffer, uint pname, Span<int> @params)
+        {
+            fixed (int* @paramsPtr = @params)
+            {
+                Context.glGetNamedBufferParameteriv(buffer.Value, pname, @paramsPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetNamedBufferPointerv(GlHandle buffer, uint pname, void** @params)
+        {
+            Context.glGetNamedBufferPointerv(buffer.Value, pname, @params);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetNamedBufferSubData(GlHandle buffer, nint offset, nint size, void* data)
+        {
+            Context.glGetNamedBufferSubData(buffer.Value, offset, size, data);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetNamedFramebufferAttachmentParameteriv(GlHandle framebuffer, uint attachment, uint pname, Span<int> @params)
+        {
+            fixed (int* @paramsPtr = @params)
+            {
+                Context.glGetNamedFramebufferAttachmentParameteriv(framebuffer.Value, attachment, pname, @paramsPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetNamedFramebufferParameteriv(GlHandle framebuffer, uint pname, Span<int> param)
+        {
+            fixed (int* paramPtr = param)
+            {
+                Context.glGetNamedFramebufferParameteriv(framebuffer.Value, pname, paramPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetNamedRenderbufferParameteriv(GlHandle renderbuffer, uint pname, Span<int> @params)
+        {
+            fixed (int* @paramsPtr = @params)
+            {
+                Context.glGetNamedRenderbufferParameteriv(renderbuffer.Value, pname, @paramsPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetQueryBufferObject(uint id, GlHandle buffer, uint pname, nint offset)
+        {
+            Context.glGetQueryBufferObjecti64v(id, buffer.Value, pname, offset);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetQueryBufferObjectiv(uint id, GlHandle buffer, uint pname, nint offset)
+        {
+            Context.glGetQueryBufferObjectiv(id, buffer.Value, pname, offset);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetQueryBufferObjectui64v(uint id, GlHandle buffer, uint pname, nint offset)
+        {
+            Context.glGetQueryBufferObjectui64v(id, buffer.Value, pname, offset);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetQueryBufferObjectuiv(uint id, GlHandle buffer, uint pname, nint offset)
+        {
+            Context.glGetQueryBufferObjectuiv(id, buffer.Value, pname, offset);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetTextureImage(GlHandle texture, int level, uint format, uint type, int bufSize, void* pixels)
+        {
+            Context.glGetTextureImage(texture.Value, level, format, type, bufSize, pixels);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetTextureLevelParameter(GlHandle texture, int level, uint pname, Span<float> @params)
+        {
+            fixed (float* @paramsPtr = @params)
+            {
+                Context.glGetTextureLevelParameterfv(texture.Value, level, pname, @paramsPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetTextureLevelParameter(GlHandle texture, int level, uint pname, Span<int> @params)
+        {
+            fixed (int* @paramsPtr = @params)
+            {
+                Context.glGetTextureLevelParameteriv(texture.Value, level, pname, @paramsPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetTextureParameterI(GlHandle texture, uint pname, Span<int> @params)
+        {
+            fixed (int* @paramsPtr = @params)
+            {
+                Context.glGetTextureParameterIiv(texture.Value, pname, @paramsPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetTextureParameterI(GlHandle texture, uint pname, Span<uint> @params)
+        {
+            fixed (uint* @paramsPtr = @params)
+            {
+                Context.glGetTextureParameterIuiv(texture.Value, pname, @paramsPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetTextureParameter(GlHandle texture, uint pname, Span<float> @params)
+        {
+            fixed (float* @paramsPtr = @params)
+            {
+                Context.glGetTextureParameterfv(texture.Value, pname, @paramsPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetTextureParameter(GlHandle texture, uint pname, Span<int> @params)
+        {
+            fixed (int* @paramsPtr = @params)
+            {
+                Context.glGetTextureParameteriv(texture.Value, pname, @paramsPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetTextureSubImage(GlHandle texture, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, uint format, uint type, int bufSize, void* pixels)
+        {
+            Context.glGetTextureSubImage(texture.Value, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetTransformFeedbacki64_v(uint xfb, uint pname, uint index, Span<long> param)
+        {
+            fixed (long* paramPtr = param)
+            {
+                Context.glGetTransformFeedbacki64_v(xfb, pname, index, paramPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetTransformFeedbacki_v(uint xfb, uint pname, uint index, Span<int> param)
+        {
+            fixed (int* paramPtr = param)
+            {
+                Context.glGetTransformFeedbacki_v(xfb, pname, index, paramPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetTransformFeedbackiv(uint xfb, uint pname, Span<int> param)
+        {
+            fixed (int* paramPtr = param)
+            {
+                Context.glGetTransformFeedbackiv(xfb, pname, paramPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetVertexArrayIndexed64iv(uint vaobj, uint index, uint pname, Span<long> param)
+        {
+            fixed (long* paramPtr = param)
+            {
+                Context.glGetVertexArrayIndexed64iv(vaobj, index, pname, paramPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetVertexArrayIndexediv(uint vaobj, uint index, uint pname, Span<int> param)
+        {
+            fixed (int* paramPtr = param)
+            {
+                Context.glGetVertexArrayIndexediv(vaobj, index, pname, paramPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetVertexArrayiv(uint vaobj, uint pname, Span<int> param)
+        {
+            fixed (int* paramPtr = param)
+            {
+                Context.glGetVertexArrayiv(vaobj, pname, paramPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetnCompressedTexImage(uint target, int lod, int bufSize, void* pixels)
+        {
+            Context.glGetnCompressedTexImage(target, lod, bufSize, pixels);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetnTexImage(uint target, int level, uint format, uint type, int bufSize, void* pixels)
+        {
+            Context.glGetnTexImage(target, level, format, type, bufSize, pixels);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetnUniform(GlHandle program, int location, int bufSize, Span<double> @params)
+        {
+            if (@params.Length < checked((int)bufSize / 8)) {
+                throw new ArgumentException("Span is shorter than the OpenGL length expression 'bufSize / 8'.", nameof(@params));
+            }
+            fixed (double* @paramsPtr = @params)
+            {
+                Context.glGetnUniformdv(program.Value, location, bufSize, @paramsPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetnUniform(GlHandle program, int location, int bufSize, Span<float> @params)
+        {
+            if (@params.Length < checked((int)bufSize / 4)) {
+                throw new ArgumentException("Span is shorter than the OpenGL length expression 'bufSize / 4'.", nameof(@params));
+            }
+            fixed (float* @paramsPtr = @params)
+            {
+                Context.glGetnUniformfv(program.Value, location, bufSize, @paramsPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetnUniform(GlHandle program, int location, int bufSize, Span<int> @params)
+        {
+            if (@params.Length < checked((int)bufSize / 4)) {
+                throw new ArgumentException("Span is shorter than the OpenGL length expression 'bufSize / 4'.", nameof(@params));
+            }
+            fixed (int* @paramsPtr = @params)
+            {
+                Context.glGetnUniformiv(program.Value, location, bufSize, @paramsPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetnUniform(GlHandle program, int location, int bufSize, Span<uint> @params)
+        {
+            if (@params.Length < checked((int)bufSize / 4)) {
+                throw new ArgumentException("Span is shorter than the OpenGL length expression 'bufSize / 4'.", nameof(@params));
+            }
+            fixed (uint* @paramsPtr = @params)
+            {
+                Context.glGetnUniformuiv(program.Value, location, bufSize, @paramsPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void InvalidateNamedFramebufferData(GlHandle framebuffer, ReadOnlySpan<uint> attachments)
+        {
+            fixed (uint* attachmentsPtr = attachments)
+            {
+                Context.glInvalidateNamedFramebufferData(framebuffer.Value, checked((int)attachments.Length), attachmentsPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void InvalidateNamedFramebufferSubData(GlHandle framebuffer, ReadOnlySpan<uint> attachments, int x, int y, int width, int height)
+        {
+            fixed (uint* attachmentsPtr = attachments)
+            {
+                Context.glInvalidateNamedFramebufferSubData(framebuffer.Value, checked((int)attachments.Length), attachmentsPtr, x, y, width, height);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void* MapNamedBuffer(GlHandle buffer, uint access)
+        {
+            return Context.glMapNamedBuffer(buffer.Value, access);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void* MapNamedBufferRange(GlHandle buffer, nint offset, nint length, uint access)
+        {
+            return Context.glMapNamedBufferRange(buffer.Value, offset, length, access);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void MemoryBarrierByRegion(uint barriers)
+        {
+            Context.glMemoryBarrierByRegion(barriers);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void NamedBufferData(GlHandle buffer, nint size, void* data, uint usage)
+        {
+            Context.glNamedBufferData(buffer.Value, size, data, usage);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void NamedBufferStorage(GlHandle buffer, nint size, void* data, uint flags)
+        {
+            Context.glNamedBufferStorage(buffer.Value, size, data, flags);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void NamedBufferSubData(GlHandle buffer, nint offset, nint size, void* data)
+        {
+            Context.glNamedBufferSubData(buffer.Value, offset, size, data);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void NamedFramebufferDrawBuffer(GlHandle framebuffer, uint buf)
+        {
+            Context.glNamedFramebufferDrawBuffer(framebuffer.Value, buf);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void NamedFramebufferDrawBuffers(GlHandle framebuffer, ReadOnlySpan<uint> bufs)
+        {
+            fixed (uint* bufsPtr = bufs)
+            {
+                Context.glNamedFramebufferDrawBuffers(framebuffer.Value, checked((int)bufs.Length), bufsPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void NamedFramebufferParameter(GlHandle framebuffer, uint pname, int param)
+        {
+            Context.glNamedFramebufferParameteri(framebuffer.Value, pname, param);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void NamedFramebufferReadBuffer(GlHandle framebuffer, uint src)
+        {
+            Context.glNamedFramebufferReadBuffer(framebuffer.Value, src);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void NamedFramebufferRenderbuffer(GlHandle framebuffer, uint attachment, uint renderbuffertarget, GlHandle renderbuffer)
+        {
+            Context.glNamedFramebufferRenderbuffer(framebuffer.Value, attachment, renderbuffertarget, renderbuffer.Value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void NamedFramebufferTexture(GlHandle framebuffer, uint attachment, GlHandle texture, int level)
+        {
+            Context.glNamedFramebufferTexture(framebuffer.Value, attachment, texture.Value, level);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void NamedFramebufferTextureLayer(GlHandle framebuffer, uint attachment, GlHandle texture, int level, int layer)
+        {
+            Context.glNamedFramebufferTextureLayer(framebuffer.Value, attachment, texture.Value, level, layer);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void NamedRenderbufferStorage(GlHandle renderbuffer, uint internalformat, int width, int height)
+        {
+            Context.glNamedRenderbufferStorage(renderbuffer.Value, internalformat, width, height);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void NamedRenderbufferStorageMultisample(GlHandle renderbuffer, int samples, uint internalformat, int width, int height)
+        {
+            Context.glNamedRenderbufferStorageMultisample(renderbuffer.Value, samples, internalformat, width, height);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadnPixels(int x, int y, int width, int height, uint format, uint type, int bufSize, void* data)
+        {
+            Context.glReadnPixels(x, y, width, height, format, type, bufSize, data);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void TextureBarrier()
+        {
+            Context.glTextureBarrier();
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void TextureBuffer(GlHandle texture, uint internalformat, GlHandle buffer)
+        {
+            Context.glTextureBuffer(texture.Value, internalformat, buffer.Value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void TextureBufferRange(GlHandle texture, uint internalformat, GlHandle buffer, nint offset, nint size)
+        {
+            Context.glTextureBufferRange(texture.Value, internalformat, buffer.Value, offset, size);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void TextureParameterI(GlHandle texture, uint pname, ReadOnlySpan<int> @params)
+        {
+            fixed (int* @paramsPtr = @params)
+            {
+                Context.glTextureParameterIiv(texture.Value, pname, @paramsPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void TextureParameterI(GlHandle texture, uint pname, ReadOnlySpan<uint> @params)
+        {
+            fixed (uint* @paramsPtr = @params)
+            {
+                Context.glTextureParameterIuiv(texture.Value, pname, @paramsPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void TextureParameter(GlHandle texture, uint pname, float param)
+        {
+            Context.glTextureParameterf(texture.Value, pname, param);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void TextureParameter(GlHandle texture, uint pname, ReadOnlySpan<float> param)
+        {
+            fixed (float* paramPtr = param)
+            {
+                Context.glTextureParameterfv(texture.Value, pname, paramPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void TextureParameter(GlHandle texture, uint pname, int param)
+        {
+            Context.glTextureParameteri(texture.Value, pname, param);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void TextureParameter(GlHandle texture, uint pname, ReadOnlySpan<int> param)
+        {
+            fixed (int* paramPtr = param)
+            {
+                Context.glTextureParameteriv(texture.Value, pname, paramPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void TextureStorage1D(GlHandle texture, int levels, uint internalformat, int width)
+        {
+            Context.glTextureStorage1D(texture.Value, levels, internalformat, width);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void TextureStorage2D(GlHandle texture, int levels, uint internalformat, int width, int height)
+        {
+            Context.glTextureStorage2D(texture.Value, levels, internalformat, width, height);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void TextureStorage2DMultisample(GlHandle texture, int samples, uint internalformat, int width, int height, byte fixedsamplelocations)
+        {
+            Context.glTextureStorage2DMultisample(texture.Value, samples, internalformat, width, height, fixedsamplelocations);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void TextureStorage3D(GlHandle texture, int levels, uint internalformat, int width, int height, int depth)
+        {
+            Context.glTextureStorage3D(texture.Value, levels, internalformat, width, height, depth);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void TextureStorage3DMultisample(GlHandle texture, int samples, uint internalformat, int width, int height, int depth, byte fixedsamplelocations)
+        {
+            Context.glTextureStorage3DMultisample(texture.Value, samples, internalformat, width, height, depth, fixedsamplelocations);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void TextureSubImage1D(GlHandle texture, int level, int xoffset, int width, uint format, uint type, void* pixels)
+        {
+            Context.glTextureSubImage1D(texture.Value, level, xoffset, width, format, type, pixels);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void TextureSubImage2D(GlHandle texture, int level, int xoffset, int yoffset, int width, int height, uint format, uint type, void* pixels)
+        {
+            Context.glTextureSubImage2D(texture.Value, level, xoffset, yoffset, width, height, format, type, pixels);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void TextureSubImage3D(GlHandle texture, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, uint format, uint type, void* pixels)
+        {
+            Context.glTextureSubImage3D(texture.Value, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void TransformFeedbackBufferBase(uint xfb, uint index, GlHandle buffer)
+        {
+            Context.glTransformFeedbackBufferBase(xfb, index, buffer.Value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void TransformFeedbackBufferRange(uint xfb, uint index, GlHandle buffer, nint offset, nint size)
+        {
+            Context.glTransformFeedbackBufferRange(xfb, index, buffer.Value, offset, size);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public byte UnmapNamedBuffer(GlHandle buffer)
+        {
+            return Context.glUnmapNamedBuffer(buffer.Value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void VertexArrayAttribBinding(uint vaobj, uint attribindex, uint bindingindex)
+        {
+            Context.glVertexArrayAttribBinding(vaobj, attribindex, bindingindex);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void VertexArrayAttribFormat(uint vaobj, uint attribindex, int size, uint type, byte normalized, uint relativeoffset)
+        {
+            Context.glVertexArrayAttribFormat(vaobj, attribindex, size, type, normalized, relativeoffset);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void VertexArrayAttribIFormat(uint vaobj, uint attribindex, int size, uint type, uint relativeoffset)
+        {
+            Context.glVertexArrayAttribIFormat(vaobj, attribindex, size, type, relativeoffset);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void VertexArrayAttribLFormat(uint vaobj, uint attribindex, int size, uint type, uint relativeoffset)
+        {
+            Context.glVertexArrayAttribLFormat(vaobj, attribindex, size, type, relativeoffset);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void VertexArrayBindingDivisor(uint vaobj, uint bindingindex, uint divisor)
+        {
+            Context.glVertexArrayBindingDivisor(vaobj, bindingindex, divisor);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void VertexArrayElementBuffer(uint vaobj, GlHandle buffer)
+        {
+            Context.glVertexArrayElementBuffer(vaobj, buffer.Value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void VertexArrayVertexBuffer(uint vaobj, uint bindingindex, GlHandle buffer, nint offset, int stride)
+        {
+            Context.glVertexArrayVertexBuffer(vaobj, bindingindex, buffer.Value, offset, stride);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void VertexArrayVertexBuffers(uint vaobj, uint first, ReadOnlySpan<uint> buffers, ReadOnlySpan<nint> offsets, ReadOnlySpan<int> strides)
+        {
+            if (offsets.Length != buffers.Length) {
+                throw new ArgumentException("Span lengths controlled by count must match.", nameof(offsets));
+            }
+            if (strides.Length != buffers.Length) {
+                throw new ArgumentException("Span lengths controlled by count must match.", nameof(strides));
+            }
+            fixed (uint* buffersPtr = buffers)
+            {
+                fixed (nint* offsetsPtr = offsets)
+                {
+                    fixed (int* stridesPtr = strides)
+                    {
+                        Context.glVertexArrayVertexBuffers(vaobj, first, checked((int)buffers.Length), buffersPtr, offsetsPtr, stridesPtr);
+                    }
+                }
+            }
+        }
+
+    }
+}

src/StgSharp.Graphics/OpenGL/Generated/OpenGLFunction.Raw.v4_6.g.cs

@@ -0,0 +1,51 @@
+// <auto-generated>
+// Generated by StgSharp.GenerateGL on 2026-08-25 09:22:55Z
+// Version: 4.6
+// </auto-generated>
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using StgSharp.Graphics.OpenGL;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public unsafe partial class OpenGLFunction
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void MultiDrawArraysIndirectCount(uint mode, void* indirect, nint drawcount, int maxdrawcount, int stride)
+        {
+            Context.glMultiDrawArraysIndirectCount(mode, indirect, drawcount, maxdrawcount, stride);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void MultiDrawElementsIndirectCount(uint mode, uint type, void* indirect, nint drawcount, int maxdrawcount, int stride)
+        {
+            Context.glMultiDrawElementsIndirectCount(mode, type, indirect, drawcount, maxdrawcount, stride);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void PolygonOffsetClamp(float factor, float units, float clamp)
+        {
+            Context.glPolygonOffsetClamp(factor, units, clamp);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SpecializeShader(GlHandle shader, ReadOnlySpan<byte> pEntryPoint, ReadOnlySpan<uint> pConstantIndex, ReadOnlySpan<uint> pConstantValue)
+        {
+            if (pConstantValue.Length != pConstantIndex.Length) {
+                throw new ArgumentException("Span lengths controlled by numSpecializationConstants must match.", nameof(pConstantValue));
+            }
+            fixed (byte* pEntryPointPtr = pEntryPoint)
+            {
+                fixed (uint* pConstantIndexPtr = pConstantIndex)
+                {
+                    fixed (uint* pConstantValuePtr = pConstantValue)
+                    {
+                        Context.glSpecializeShader(shader.Value, pEntryPointPtr, checked((uint)pConstantIndex.Length), pConstantIndexPtr, pConstantValuePtr);
+                    }
+                }
+            }
+        }
+
+    }
+}

src/StgSharp.Graphics/OpenGL/Generated/OpenGLFunction.Uniform.v3_3.g.cs

@@ -0,0 +1,261 @@
+// <auto-generated>
+// Generated by StgSharp.GenerateGL on 2026-08-25 09:22:55Z
+// Uniform overloads introduced in OpenGL 3.3
+// </auto-generated>
+using System;
+using System.Runtime.CompilerServices;
+using StgSharp.Mathematics.Graphics;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public unsafe partial class OpenGLFunction
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<float> uniform, float v0)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glUniform1f(uniform.id.SignedValue, v0);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<float> uniform, ReadOnlySpan<float> values)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            fixed (float* valuesPtr = values) {
+                Context.glUniform1fv(uniform.id.SignedValue, values.Length, valuesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<int> uniform, int v0)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glUniform1i(uniform.id.SignedValue, v0);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<int> uniform, ReadOnlySpan<int> values)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            fixed (int* valuesPtr = values) {
+                Context.glUniform1iv(uniform.id.SignedValue, values.Length, valuesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<uint> uniform, uint v0)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glUniform1ui(uniform.id.SignedValue, v0);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<uint> uniform, ReadOnlySpan<uint> values)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            fixed (uint* valuesPtr = values) {
+                Context.glUniform1uiv(uniform.id.SignedValue, values.Length, valuesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<float, float> uniform, float v0, float v1)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glUniform2f(uniform.id.SignedValue, v0, v1);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<float, float> uniform, ReadOnlySpan<float> values)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            if ((values.Length % 2) != 0) {
+                throw new ArgumentException("Uniform data length must be divisible by 2.", nameof(values));
+            }
+            fixed (float* valuesPtr = values) {
+                Context.glUniform2fv(uniform.id.SignedValue, values.Length / 2, valuesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<int, int> uniform, int v0, int v1)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glUniform2i(uniform.id.SignedValue, v0, v1);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<int, int> uniform, ReadOnlySpan<int> values)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            if ((values.Length % 2) != 0) {
+                throw new ArgumentException("Uniform data length must be divisible by 2.", nameof(values));
+            }
+            fixed (int* valuesPtr = values) {
+                Context.glUniform2iv(uniform.id.SignedValue, values.Length / 2, valuesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<uint, uint> uniform, uint v0, uint v1)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glUniform2ui(uniform.id.SignedValue, v0, v1);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<uint, uint> uniform, ReadOnlySpan<uint> values)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            if ((values.Length % 2) != 0) {
+                throw new ArgumentException("Uniform data length must be divisible by 2.", nameof(values));
+            }
+            fixed (uint* valuesPtr = values) {
+                Context.glUniform2uiv(uniform.id.SignedValue, values.Length / 2, valuesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<float, float, float> uniform, float v0, float v1, float v2)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glUniform3f(uniform.id.SignedValue, v0, v1, v2);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<float, float, float> uniform, ReadOnlySpan<float> values)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            if ((values.Length % 3) != 0) {
+                throw new ArgumentException("Uniform data length must be divisible by 3.", nameof(values));
+            }
+            fixed (float* valuesPtr = values) {
+                Context.glUniform3fv(uniform.id.SignedValue, values.Length / 3, valuesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<int, int, int> uniform, int v0, int v1, int v2)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glUniform3i(uniform.id.SignedValue, v0, v1, v2);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<int, int, int> uniform, ReadOnlySpan<int> values)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            if ((values.Length % 3) != 0) {
+                throw new ArgumentException("Uniform data length must be divisible by 3.", nameof(values));
+            }
+            fixed (int* valuesPtr = values) {
+                Context.glUniform3iv(uniform.id.SignedValue, values.Length / 3, valuesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<uint, uint, uint> uniform, uint v0, uint v1, uint v2)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glUniform3ui(uniform.id.SignedValue, v0, v1, v2);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<uint, uint, uint> uniform, ReadOnlySpan<uint> values)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            if ((values.Length % 3) != 0) {
+                throw new ArgumentException("Uniform data length must be divisible by 3.", nameof(values));
+            }
+            fixed (uint* valuesPtr = values) {
+                Context.glUniform3uiv(uniform.id.SignedValue, values.Length / 3, valuesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<float, float, float, float> uniform, float v0, float v1, float v2, float v3)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glUniform4f(uniform.id.SignedValue, v0, v1, v2, v3);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<float, float, float, float> uniform, ReadOnlySpan<float> values)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            if ((values.Length % 4) != 0) {
+                throw new ArgumentException("Uniform data length must be divisible by 4.", nameof(values));
+            }
+            fixed (float* valuesPtr = values) {
+                Context.glUniform4fv(uniform.id.SignedValue, values.Length / 4, valuesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<int, int, int, int> uniform, int v0, int v1, int v2, int v3)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glUniform4i(uniform.id.SignedValue, v0, v1, v2, v3);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<int, int, int, int> uniform, ReadOnlySpan<int> values)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            if ((values.Length % 4) != 0) {
+                throw new ArgumentException("Uniform data length must be divisible by 4.", nameof(values));
+            }
+            fixed (int* valuesPtr = values) {
+                Context.glUniform4iv(uniform.id.SignedValue, values.Length / 4, valuesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<uint, uint, uint, uint> uniform, uint v0, uint v1, uint v2, uint v3)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glUniform4ui(uniform.id.SignedValue, v0, v1, v2, v3);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<uint, uint, uint, uint> uniform, ReadOnlySpan<uint> values)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            if ((values.Length % 4) != 0) {
+                throw new ArgumentException("Uniform data length must be divisible by 4.", nameof(values));
+            }
+            fixed (uint* valuesPtr = values) {
+                Context.glUniform4uiv(uniform.id.SignedValue, values.Length / 4, valuesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<Vec2> uniform, Vec2 value)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glUniform2fv(uniform.id.SignedValue, 1, (float*)&value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<Vec3> uniform, Vec3 value)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glUniform3fv(uniform.id.SignedValue, 1, (float*)&value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<Vec4> uniform, Vec4 value)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glUniform4fv(uniform.id.SignedValue, 1, (float*)&value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<GraphicsMatrix> uniform, GraphicsMatrix value, bool transpose = false)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glUniformMatrix4fv(uniform.id.SignedValue, 1, transpose ? (byte)1 : (byte)0, (float*)&value);
+        }
+
+    }
+}

src/StgSharp.Graphics/OpenGL/Generated/OpenGLFunction.Uniform.v4_0.g.cs

@@ -0,0 +1,87 @@
+// <auto-generated>
+// Generated by StgSharp.GenerateGL on 2026-08-25 09:22:55Z
+// Uniform overloads introduced in OpenGL 4.0
+// </auto-generated>
+using System;
+using System.Runtime.CompilerServices;
+using StgSharp.Mathematics.Graphics;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public unsafe partial class OpenGLFunction
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<double> uniform, double v0)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glUniform1d(uniform.id.SignedValue, v0);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<double> uniform, ReadOnlySpan<double> values)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            fixed (double* valuesPtr = values) {
+                Context.glUniform1dv(uniform.id.SignedValue, values.Length, valuesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<double, double> uniform, double v0, double v1)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glUniform2d(uniform.id.SignedValue, v0, v1);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<double, double> uniform, ReadOnlySpan<double> values)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            if ((values.Length % 2) != 0) {
+                throw new ArgumentException("Uniform data length must be divisible by 2.", nameof(values));
+            }
+            fixed (double* valuesPtr = values) {
+                Context.glUniform2dv(uniform.id.SignedValue, values.Length / 2, valuesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<double, double, double> uniform, double v0, double v1, double v2)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glUniform3d(uniform.id.SignedValue, v0, v1, v2);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<double, double, double> uniform, ReadOnlySpan<double> values)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            if ((values.Length % 3) != 0) {
+                throw new ArgumentException("Uniform data length must be divisible by 3.", nameof(values));
+            }
+            fixed (double* valuesPtr = values) {
+                Context.glUniform3dv(uniform.id.SignedValue, values.Length / 3, valuesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<double, double, double, double> uniform, double v0, double v1, double v2, double v3)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glUniform4d(uniform.id.SignedValue, v0, v1, v2, v3);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(Uniform<double, double, double, double> uniform, ReadOnlySpan<double> values)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            if ((values.Length % 4) != 0) {
+                throw new ArgumentException("Uniform data length must be divisible by 4.", nameof(values));
+            }
+            fixed (double* valuesPtr = values) {
+                Context.glUniform4dv(uniform.id.SignedValue, values.Length / 4, valuesPtr);
+            }
+        }
+
+    }
+}

src/StgSharp.Graphics/OpenGL/Generated/OpenGLFunction.Uniform.v4_1.g.cs

@@ -0,0 +1,334 @@
+// <auto-generated>
+// Generated by StgSharp.GenerateGL on 2026-08-25 09:22:55Z
+// Uniform overloads introduced in OpenGL 4.1
+// </auto-generated>
+using System;
+using System.Runtime.CompilerServices;
+using StgSharp.Mathematics.Graphics;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public unsafe partial class OpenGLFunction
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<double> uniform, double v0)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glProgramUniform1d(program.Value, uniform.id.SignedValue, v0);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<double> uniform, ReadOnlySpan<double> values)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            fixed (double* valuesPtr = values) {
+                Context.glProgramUniform1dv(program.Value, uniform.id.SignedValue, values.Length, valuesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<float> uniform, float v0)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glProgramUniform1f(program.Value, uniform.id.SignedValue, v0);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<float> uniform, ReadOnlySpan<float> values)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            fixed (float* valuesPtr = values) {
+                Context.glProgramUniform1fv(program.Value, uniform.id.SignedValue, values.Length, valuesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<int> uniform, int v0)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glProgramUniform1i(program.Value, uniform.id.SignedValue, v0);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<int> uniform, ReadOnlySpan<int> values)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            fixed (int* valuesPtr = values) {
+                Context.glProgramUniform1iv(program.Value, uniform.id.SignedValue, values.Length, valuesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<uint> uniform, uint v0)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glProgramUniform1ui(program.Value, uniform.id.SignedValue, v0);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<uint> uniform, ReadOnlySpan<uint> values)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            fixed (uint* valuesPtr = values) {
+                Context.glProgramUniform1uiv(program.Value, uniform.id.SignedValue, values.Length, valuesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<double, double> uniform, double v0, double v1)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glProgramUniform2d(program.Value, uniform.id.SignedValue, v0, v1);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<double, double> uniform, ReadOnlySpan<double> values)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            if ((values.Length % 2) != 0) {
+                throw new ArgumentException("Uniform data length must be divisible by 2.", nameof(values));
+            }
+            fixed (double* valuesPtr = values) {
+                Context.glProgramUniform2dv(program.Value, uniform.id.SignedValue, values.Length / 2, valuesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<float, float> uniform, float v0, float v1)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glProgramUniform2f(program.Value, uniform.id.SignedValue, v0, v1);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<float, float> uniform, ReadOnlySpan<float> values)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            if ((values.Length % 2) != 0) {
+                throw new ArgumentException("Uniform data length must be divisible by 2.", nameof(values));
+            }
+            fixed (float* valuesPtr = values) {
+                Context.glProgramUniform2fv(program.Value, uniform.id.SignedValue, values.Length / 2, valuesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<int, int> uniform, int v0, int v1)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glProgramUniform2i(program.Value, uniform.id.SignedValue, v0, v1);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<int, int> uniform, ReadOnlySpan<int> values)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            if ((values.Length % 2) != 0) {
+                throw new ArgumentException("Uniform data length must be divisible by 2.", nameof(values));
+            }
+            fixed (int* valuesPtr = values) {
+                Context.glProgramUniform2iv(program.Value, uniform.id.SignedValue, values.Length / 2, valuesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<uint, uint> uniform, uint v0, uint v1)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glProgramUniform2ui(program.Value, uniform.id.SignedValue, v0, v1);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<uint, uint> uniform, ReadOnlySpan<uint> values)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            if ((values.Length % 2) != 0) {
+                throw new ArgumentException("Uniform data length must be divisible by 2.", nameof(values));
+            }
+            fixed (uint* valuesPtr = values) {
+                Context.glProgramUniform2uiv(program.Value, uniform.id.SignedValue, values.Length / 2, valuesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<double, double, double> uniform, double v0, double v1, double v2)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glProgramUniform3d(program.Value, uniform.id.SignedValue, v0, v1, v2);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<double, double, double> uniform, ReadOnlySpan<double> values)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            if ((values.Length % 3) != 0) {
+                throw new ArgumentException("Uniform data length must be divisible by 3.", nameof(values));
+            }
+            fixed (double* valuesPtr = values) {
+                Context.glProgramUniform3dv(program.Value, uniform.id.SignedValue, values.Length / 3, valuesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<float, float, float> uniform, float v0, float v1, float v2)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glProgramUniform3f(program.Value, uniform.id.SignedValue, v0, v1, v2);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<float, float, float> uniform, ReadOnlySpan<float> values)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            if ((values.Length % 3) != 0) {
+                throw new ArgumentException("Uniform data length must be divisible by 3.", nameof(values));
+            }
+            fixed (float* valuesPtr = values) {
+                Context.glProgramUniform3fv(program.Value, uniform.id.SignedValue, values.Length / 3, valuesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<int, int, int> uniform, int v0, int v1, int v2)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glProgramUniform3i(program.Value, uniform.id.SignedValue, v0, v1, v2);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<int, int, int> uniform, ReadOnlySpan<int> values)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            if ((values.Length % 3) != 0) {
+                throw new ArgumentException("Uniform data length must be divisible by 3.", nameof(values));
+            }
+            fixed (int* valuesPtr = values) {
+                Context.glProgramUniform3iv(program.Value, uniform.id.SignedValue, values.Length / 3, valuesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<uint, uint, uint> uniform, uint v0, uint v1, uint v2)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glProgramUniform3ui(program.Value, uniform.id.SignedValue, v0, v1, v2);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<uint, uint, uint> uniform, ReadOnlySpan<uint> values)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            if ((values.Length % 3) != 0) {
+                throw new ArgumentException("Uniform data length must be divisible by 3.", nameof(values));
+            }
+            fixed (uint* valuesPtr = values) {
+                Context.glProgramUniform3uiv(program.Value, uniform.id.SignedValue, values.Length / 3, valuesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<double, double, double, double> uniform, double v0, double v1, double v2, double v3)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glProgramUniform4d(program.Value, uniform.id.SignedValue, v0, v1, v2, v3);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<double, double, double, double> uniform, ReadOnlySpan<double> values)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            if ((values.Length % 4) != 0) {
+                throw new ArgumentException("Uniform data length must be divisible by 4.", nameof(values));
+            }
+            fixed (double* valuesPtr = values) {
+                Context.glProgramUniform4dv(program.Value, uniform.id.SignedValue, values.Length / 4, valuesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<float, float, float, float> uniform, float v0, float v1, float v2, float v3)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glProgramUniform4f(program.Value, uniform.id.SignedValue, v0, v1, v2, v3);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<float, float, float, float> uniform, ReadOnlySpan<float> values)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            if ((values.Length % 4) != 0) {
+                throw new ArgumentException("Uniform data length must be divisible by 4.", nameof(values));
+            }
+            fixed (float* valuesPtr = values) {
+                Context.glProgramUniform4fv(program.Value, uniform.id.SignedValue, values.Length / 4, valuesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<int, int, int, int> uniform, int v0, int v1, int v2, int v3)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glProgramUniform4i(program.Value, uniform.id.SignedValue, v0, v1, v2, v3);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<int, int, int, int> uniform, ReadOnlySpan<int> values)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            if ((values.Length % 4) != 0) {
+                throw new ArgumentException("Uniform data length must be divisible by 4.", nameof(values));
+            }
+            fixed (int* valuesPtr = values) {
+                Context.glProgramUniform4iv(program.Value, uniform.id.SignedValue, values.Length / 4, valuesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<uint, uint, uint, uint> uniform, uint v0, uint v1, uint v2, uint v3)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glProgramUniform4ui(program.Value, uniform.id.SignedValue, v0, v1, v2, v3);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<uint, uint, uint, uint> uniform, ReadOnlySpan<uint> values)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            if ((values.Length % 4) != 0) {
+                throw new ArgumentException("Uniform data length must be divisible by 4.", nameof(values));
+            }
+            fixed (uint* valuesPtr = values) {
+                Context.glProgramUniform4uiv(program.Value, uniform.id.SignedValue, values.Length / 4, valuesPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<Vec2> uniform, Vec2 value)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glProgramUniform2fv(program.Value, uniform.id.SignedValue, 1, (float*)&value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<Vec3> uniform, Vec3 value)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glProgramUniform3fv(program.Value, uniform.id.SignedValue, 1, (float*)&value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<Vec4> uniform, Vec4 value)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glProgramUniform4fv(program.Value, uniform.id.SignedValue, 1, (float*)&value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetUniformValue(GlHandle program, Uniform<GraphicsMatrix> uniform, GraphicsMatrix value, bool transpose = false)
+        {
+            ArgumentNullException.ThrowIfNull(uniform);
+            Context.glProgramUniformMatrix4fv(program.Value, uniform.id.SignedValue, 1, transpose ? (byte)1 : (byte)0, (float*)&value);
+        }
+
+    }
+}

src/StgSharp.Graphics/OpenGL/Generated/OpenglContext.g.cs

@@ -1,10 +1,7 @@
-// -----------------------------------------------------------------------------
-// file="glContext"
-// Project: StgSharp
-// Copyright (c) Nitload.
-// SPDX-License-Identifier: MIT
-// -----------------------------------------------------------------------------
-
+// <auto-generated>
+// Generated by StgSharp.GenerateGL on 2026-08-25 09:22:55Z
+// Aggregated GL3+ commands
+// </auto-generated>
 using System;
 using System.Runtime.CompilerServices;
 
@@ -12,7 +9,6 @@ namespace StgSharp.Graphics.OpenGL
 {
     public unsafe partial struct OpenglContext
     {
-
         internal unsafe delegate*<uint, uint, void> glActiveShaderProgram;
         internal unsafe delegate*<uint, void> glActiveTexture;
         internal unsafe delegate*<uint, uint, void> glAttachShader;
@@ -23,9 +19,9 @@ namespace StgSharp.Graphics.OpenGL
         internal unsafe delegate*<uint, uint, byte*, void> glBindAttribLocation;
         internal unsafe delegate*<uint, uint, void> glBindBuffer;
         internal unsafe delegate*<uint, uint, uint, void> glBindBufferBase;
-        internal unsafe delegate*<uint, uint, uint, nint, nuint, void> glBindBufferRange;
+        internal unsafe delegate*<uint, uint, uint, nint, nint, void> glBindBufferRange;
         internal unsafe delegate*<uint, uint, int, uint*, void> glBindBuffersBase;
-        internal unsafe delegate*<uint, uint, int, uint*, nint*, nuint*, void> glBindBuffersRange;
+        internal unsafe delegate*<uint, uint, int, uint*, nint*, nint*, void> glBindBuffersRange;
         internal unsafe delegate*<uint, uint, byte*, void> glBindFragDataLocation;
         internal unsafe delegate*<uint, uint, uint, byte*, void> glBindFragDataLocationIndexed;
         internal unsafe delegate*<uint, uint, void> glBindFramebuffer;
@@ -36,65 +32,65 @@ namespace StgSharp.Graphics.OpenGL
         internal unsafe delegate*<uint, uint, void> glBindSampler;
         internal unsafe delegate*<uint, int, uint*, void> glBindSamplers;
         internal unsafe delegate*<uint, uint, void> glBindTexture;
-        internal unsafe delegate*<uint, int, uint*, void> glBindTextures;
         internal unsafe delegate*<uint, uint, void> glBindTextureUnit;
+        internal unsafe delegate*<uint, int, uint*, void> glBindTextures;
         internal unsafe delegate*<uint, uint, void> glBindTransformFeedback;
         internal unsafe delegate*<uint, void> glBindVertexArray;
         internal unsafe delegate*<uint, uint, nint, int, void> glBindVertexBuffer;
         internal unsafe delegate*<uint, int, uint*, nint*, int*, void> glBindVertexBuffers;
         internal unsafe delegate*<float, float, float, float, void> glBlendColor;
         internal unsafe delegate*<uint, void> glBlendEquation;
-        internal unsafe delegate*<uint, uint, void> glBlendEquationi;
         internal unsafe delegate*<uint, uint, void> glBlendEquationSeparate;
         internal unsafe delegate*<uint, uint, uint, void> glBlendEquationSeparatei;
+        internal unsafe delegate*<uint, uint, void> glBlendEquationi;
         internal unsafe delegate*<uint, uint, void> glBlendFunc;
-        internal unsafe delegate*<uint, uint, uint, void> glBlendFunci;
         internal unsafe delegate*<uint, uint, uint, uint, void> glBlendFuncSeparate;
         internal unsafe delegate*<uint, uint, uint, uint, uint, void> glBlendFuncSeparatei;
+        internal unsafe delegate*<uint, uint, uint, void> glBlendFunci;
         internal unsafe delegate*<int, int, int, int, int, int, int, int, uint, uint, void> glBlitFramebuffer;
         internal unsafe delegate*<uint, uint, int, int, int, int, int, int, int, int, uint, uint, void> glBlitNamedFramebuffer;
-        internal unsafe delegate*<uint, nuint, IntPtr*, uint, void> glBufferData;
-        internal unsafe delegate*<uint, nuint, IntPtr*, uint, void> glBufferStorage;
-        internal unsafe delegate*<uint, nint, nuint, IntPtr*, void> glBufferSubData;
+        internal unsafe delegate*<uint, nint, void*, uint, void> glBufferData;
+        internal unsafe delegate*<uint, nint, void*, uint, void> glBufferStorage;
+        internal unsafe delegate*<uint, nint, nint, void*, void> glBufferSubData;
         internal unsafe delegate*<uint, uint> glCheckFramebufferStatus;
         internal unsafe delegate*<uint, uint, uint> glCheckNamedFramebufferStatus;
         internal unsafe delegate*<uint, uint, void> glClampColor;
         internal unsafe delegate*<uint, void> glClear;
-        internal unsafe delegate*<uint, uint, uint, uint, IntPtr*, void> glClearBufferData;
+        internal unsafe delegate*<uint, uint, uint, uint, void*, void> glClearBufferData;
+        internal unsafe delegate*<uint, uint, nint, nint, uint, uint, void*, void> glClearBufferSubData;
         internal unsafe delegate*<uint, int, float, int, void> glClearBufferfi;
         internal unsafe delegate*<uint, int, float*, void> glClearBufferfv;
         internal unsafe delegate*<uint, int, int*, void> glClearBufferiv;
-        internal unsafe delegate*<uint, uint, nint, nuint, uint, uint, IntPtr*, void> glClearBufferSubData;
         internal unsafe delegate*<uint, int, uint*, void> glClearBufferuiv;
         internal unsafe delegate*<float, float, float, float, void> glClearColor;
         internal unsafe delegate*<double, void> glClearDepth;
         internal unsafe delegate*<float, void> glClearDepthf;
-        internal unsafe delegate*<uint, uint, uint, uint, IntPtr*, void> glClearNamedBufferData;
-        internal unsafe delegate*<uint, uint, nint, nuint, uint, uint, IntPtr*, void> glClearNamedBufferSubData;
+        internal unsafe delegate*<uint, uint, uint, uint, void*, void> glClearNamedBufferData;
+        internal unsafe delegate*<uint, uint, nint, nint, uint, uint, void*, void> glClearNamedBufferSubData;
         internal unsafe delegate*<uint, uint, int, float, int, void> glClearNamedFramebufferfi;
         internal unsafe delegate*<uint, uint, int, float*, void> glClearNamedFramebufferfv;
         internal unsafe delegate*<uint, uint, int, int*, void> glClearNamedFramebufferiv;
         internal unsafe delegate*<uint, uint, int, uint*, void> glClearNamedFramebufferuiv;
         internal unsafe delegate*<int, void> glClearStencil;
-        internal unsafe delegate*<uint, int, uint, uint, IntPtr*, void> glClearTexImage;
-        internal unsafe delegate*<uint, int, int, int, int, int, int, int, uint, uint, IntPtr*, void> glClearTexSubImage;
-        internal unsafe delegate*<glSync, uint, IntPtr, uint> glClientWaitSync;
+        internal unsafe delegate*<uint, int, uint, uint, void*, void> glClearTexImage;
+        internal unsafe delegate*<uint, int, int, int, int, int, int, int, uint, uint, void*, void> glClearTexSubImage;
+        internal unsafe delegate*<glSync, uint, ulong, uint> glClientWaitSync;
         internal unsafe delegate*<uint, uint, void> glClipControl;
         internal unsafe delegate*<byte, byte, byte, byte, void> glColorMask;
         internal unsafe delegate*<uint, byte, byte, byte, byte, void> glColorMaski;
         internal unsafe delegate*<uint, void> glCompileShader;
-        internal unsafe delegate*<uint, int, uint, int, int, int, IntPtr*, void> glCompressedTexImage1D;
-        internal unsafe delegate*<uint, int, uint, int, int, int, int, IntPtr*, void> glCompressedTexImage2D;
-        internal unsafe delegate*<uint, int, uint, int, int, int, int, int, IntPtr*, void> glCompressedTexImage3D;
-        internal unsafe delegate*<uint, int, int, int, uint, int, IntPtr*, void> glCompressedTexSubImage1D;
-        internal unsafe delegate*<uint, int, int, int, int, int, uint, int, IntPtr*, void> glCompressedTexSubImage2D;
-        internal unsafe delegate*<uint, int, int, int, int, int, int, int, uint, int, IntPtr*, void> glCompressedTexSubImage3D;
-        internal unsafe delegate*<uint, int, int, int, uint, int, IntPtr*, void> glCompressedTextureSubImage1D;
-        internal unsafe delegate*<uint, int, int, int, int, int, uint, int, IntPtr*, void> glCompressedTextureSubImage2D;
-        internal unsafe delegate*<uint, int, int, int, int, int, int, int, uint, int, IntPtr*, void> glCompressedTextureSubImage3D;
-        internal unsafe delegate*<uint, uint, nint, nint, nuint, void> glCopyBufferSubData;
+        internal unsafe delegate*<uint, int, uint, int, int, int, void*, void> glCompressedTexImage1D;
+        internal unsafe delegate*<uint, int, uint, int, int, int, int, void*, void> glCompressedTexImage2D;
+        internal unsafe delegate*<uint, int, uint, int, int, int, int, int, void*, void> glCompressedTexImage3D;
+        internal unsafe delegate*<uint, int, int, int, uint, int, void*, void> glCompressedTexSubImage1D;
+        internal unsafe delegate*<uint, int, int, int, int, int, uint, int, void*, void> glCompressedTexSubImage2D;
+        internal unsafe delegate*<uint, int, int, int, int, int, int, int, uint, int, void*, void> glCompressedTexSubImage3D;
+        internal unsafe delegate*<uint, int, int, int, uint, int, void*, void> glCompressedTextureSubImage1D;
+        internal unsafe delegate*<uint, int, int, int, int, int, uint, int, void*, void> glCompressedTextureSubImage2D;
+        internal unsafe delegate*<uint, int, int, int, int, int, int, int, uint, int, void*, void> glCompressedTextureSubImage3D;
+        internal unsafe delegate*<uint, uint, nint, nint, nint, void> glCopyBufferSubData;
         internal unsafe delegate*<uint, uint, int, int, int, int, uint, uint, int, int, int, int, int, int, int, void> glCopyImageSubData;
-        internal unsafe delegate*<uint, uint, nint, nint, nuint, void> glCopyNamedBufferSubData;
+        internal unsafe delegate*<uint, uint, nint, nint, nint, void> glCopyNamedBufferSubData;
         internal unsafe delegate*<uint, int, uint, int, int, int, int, void> glCopyTexImage1D;
         internal unsafe delegate*<uint, int, uint, int, int, int, int, int, void> glCopyTexImage2D;
         internal unsafe delegate*<uint, int, int, int, int, int, void> glCopyTexSubImage1D;
@@ -111,12 +107,12 @@ namespace StgSharp.Graphics.OpenGL
         internal unsafe delegate*<int, uint*, void> glCreateRenderbuffers;
         internal unsafe delegate*<int, uint*, void> glCreateSamplers;
         internal unsafe delegate*<uint, uint> glCreateShader;
-        internal unsafe delegate*<uint, int, byte*, uint> glCreateShaderProgramv;
+        internal unsafe delegate*<uint, int, byte**, uint> glCreateShaderProgramv;
         internal unsafe delegate*<uint, int, uint*, void> glCreateTextures;
         internal unsafe delegate*<int, uint*, void> glCreateTransformFeedbacks;
         internal unsafe delegate*<int, uint*, void> glCreateVertexArrays;
         internal unsafe delegate*<uint, void> glCullFace;
-        internal unsafe delegate*<IntPtr, IntPtr*, void> glDebugMessageCallback;
+        internal unsafe delegate*<IntPtr, void*, void> glDebugMessageCallback;
         internal unsafe delegate*<uint, uint, uint, int, uint*, byte, void> glDebugMessageControl;
         internal unsafe delegate*<uint, uint, uint, uint, int, byte*, void> glDebugMessageInsert;
         internal unsafe delegate*<int, uint*, void> glDeleteBuffers;
@@ -135,38 +131,38 @@ namespace StgSharp.Graphics.OpenGL
         internal unsafe delegate*<byte, void> glDepthMask;
         internal unsafe delegate*<double, double, void> glDepthRange;
         internal unsafe delegate*<uint, int, double*, void> glDepthRangeArrayv;
-        internal unsafe delegate*<float, float, void> glDepthRangef;
         internal unsafe delegate*<uint, double, double, void> glDepthRangeIndexed;
+        internal unsafe delegate*<float, float, void> glDepthRangef;
         internal unsafe delegate*<uint, uint, void> glDetachShader;
         internal unsafe delegate*<uint, void> glDisable;
-        internal unsafe delegate*<uint, uint, void> glDisablei;
         internal unsafe delegate*<uint, uint, void> glDisableVertexArrayAttrib;
         internal unsafe delegate*<uint, void> glDisableVertexAttribArray;
+        internal unsafe delegate*<uint, uint, void> glDisablei;
         internal unsafe delegate*<uint, uint, uint, void> glDispatchCompute;
         internal unsafe delegate*<nint, void> glDispatchComputeIndirect;
         internal unsafe delegate*<uint, int, int, void> glDrawArrays;
-        internal unsafe delegate*<uint, IntPtr*, void> glDrawArraysIndirect;
+        internal unsafe delegate*<uint, void*, void> glDrawArraysIndirect;
         internal unsafe delegate*<uint, int, int, int, void> glDrawArraysInstanced;
         internal unsafe delegate*<uint, int, int, int, uint, void> glDrawArraysInstancedBaseInstance;
         internal unsafe delegate*<uint, void> glDrawBuffer;
         internal unsafe delegate*<int, uint*, void> glDrawBuffers;
-        internal unsafe delegate*<uint, int, uint, IntPtr*, void> glDrawElements;
-        internal unsafe delegate*<uint, int, uint, IntPtr*, int, void> glDrawElementsBaseVertex;
-        internal unsafe delegate*<uint, uint, IntPtr*, void> glDrawElementsIndirect;
-        internal unsafe delegate*<uint, int, uint, IntPtr*, int, void> glDrawElementsInstanced;
-        internal unsafe delegate*<uint, int, uint, IntPtr*, int, uint, void> glDrawElementsInstancedBaseInstance;
-        internal unsafe delegate*<uint, int, uint, IntPtr*, int, int, void> glDrawElementsInstancedBaseVertex;
-        internal unsafe delegate*<uint, int, uint, IntPtr*, int, int, uint, void> glDrawElementsInstancedBaseVertexBaseInstance;
-        internal unsafe delegate*<uint, uint, uint, int, uint, IntPtr*, void> glDrawRangeElements;
-        internal unsafe delegate*<uint, uint, uint, int, uint, IntPtr*, int, void> glDrawRangeElementsBaseVertex;
+        internal unsafe delegate*<uint, int, uint, void*, void> glDrawElements;
+        internal unsafe delegate*<uint, int, uint, void*, int, void> glDrawElementsBaseVertex;
+        internal unsafe delegate*<uint, uint, void*, void> glDrawElementsIndirect;
+        internal unsafe delegate*<uint, int, uint, void*, int, void> glDrawElementsInstanced;
+        internal unsafe delegate*<uint, int, uint, void*, int, uint, void> glDrawElementsInstancedBaseInstance;
+        internal unsafe delegate*<uint, int, uint, void*, int, int, void> glDrawElementsInstancedBaseVertex;
+        internal unsafe delegate*<uint, int, uint, void*, int, int, uint, void> glDrawElementsInstancedBaseVertexBaseInstance;
+        internal unsafe delegate*<uint, uint, uint, int, uint, void*, void> glDrawRangeElements;
+        internal unsafe delegate*<uint, uint, uint, int, uint, void*, int, void> glDrawRangeElementsBaseVertex;
         internal unsafe delegate*<uint, uint, void> glDrawTransformFeedback;
         internal unsafe delegate*<uint, uint, int, void> glDrawTransformFeedbackInstanced;
         internal unsafe delegate*<uint, uint, uint, void> glDrawTransformFeedbackStream;
         internal unsafe delegate*<uint, uint, uint, int, void> glDrawTransformFeedbackStreamInstanced;
         internal unsafe delegate*<uint, void> glEnable;
-        internal unsafe delegate*<uint, uint, void> glEnablei;
         internal unsafe delegate*<uint, uint, void> glEnableVertexArrayAttrib;
         internal unsafe delegate*<uint, void> glEnableVertexAttribArray;
+        internal unsafe delegate*<uint, uint, void> glEnablei;
         internal unsafe delegate*<void> glEndConditionalRender;
         internal unsafe delegate*<uint, void> glEndQuery;
         internal unsafe delegate*<uint, uint, void> glEndQueryIndexed;
@@ -174,8 +170,8 @@ namespace StgSharp.Graphics.OpenGL
         internal unsafe delegate*<uint, uint, glSync> glFenceSync;
         internal unsafe delegate*<void> glFinish;
         internal unsafe delegate*<void> glFlush;
-        internal unsafe delegate*<uint, nint, nuint, void> glFlushMappedBufferRange;
-        internal unsafe delegate*<uint, nint, nuint, void> glFlushMappedNamedBufferRange;
+        internal unsafe delegate*<uint, nint, nint, void> glFlushMappedBufferRange;
+        internal unsafe delegate*<uint, nint, nint, void> glFlushMappedNamedBufferRange;
         internal unsafe delegate*<uint, uint, int, void> glFramebufferParameteri;
         internal unsafe delegate*<uint, uint, uint, uint, void> glFramebufferRenderbuffer;
         internal unsafe delegate*<uint, uint, uint, int, void> glFramebufferTexture;
@@ -185,8 +181,6 @@ namespace StgSharp.Graphics.OpenGL
         internal unsafe delegate*<uint, uint, uint, int, int, void> glFramebufferTextureLayer;
         internal unsafe delegate*<uint, void> glFrontFace;
         internal unsafe delegate*<int, uint*, void> glGenBuffers;
-        internal unsafe delegate*<uint, void> glGenerateMipmap;
-        internal unsafe delegate*<uint, void> glGenerateTextureMipmap;
         internal unsafe delegate*<int, uint*, void> glGenFramebuffers;
         internal unsafe delegate*<int, uint*, void> glGenProgramPipelines;
         internal unsafe delegate*<int, uint*, void> glGenQueries;
@@ -195,27 +189,29 @@ namespace StgSharp.Graphics.OpenGL
         internal unsafe delegate*<int, uint*, void> glGenTextures;
         internal unsafe delegate*<int, uint*, void> glGenTransformFeedbacks;
         internal unsafe delegate*<int, uint*, void> glGenVertexArrays;
+        internal unsafe delegate*<uint, void> glGenerateMipmap;
+        internal unsafe delegate*<uint, void> glGenerateTextureMipmap;
         internal unsafe delegate*<uint, uint, uint, int*, void> glGetActiveAtomicCounterBufferiv;
         internal unsafe delegate*<uint, uint, int, int*, int*, uint*, byte*, void> glGetActiveAttrib;
         internal unsafe delegate*<uint, uint, uint, int, int*, byte*, void> glGetActiveSubroutineName;
-        internal unsafe delegate*<uint, uint, uint, uint, int*, void> glGetActiveSubroutineUniformiv;
         internal unsafe delegate*<uint, uint, uint, int, int*, byte*, void> glGetActiveSubroutineUniformName;
+        internal unsafe delegate*<uint, uint, uint, uint, int*, void> glGetActiveSubroutineUniformiv;
         internal unsafe delegate*<uint, uint, int, int*, int*, uint*, byte*, void> glGetActiveUniform;
-        internal unsafe delegate*<uint, uint, uint, int*, void> glGetActiveUniformBlockiv;
         internal unsafe delegate*<uint, uint, int, int*, byte*, void> glGetActiveUniformBlockName;
+        internal unsafe delegate*<uint, uint, uint, int*, void> glGetActiveUniformBlockiv;
         internal unsafe delegate*<uint, uint, int, int*, byte*, void> glGetActiveUniformName;
         internal unsafe delegate*<uint, int, uint*, uint, int*, void> glGetActiveUniformsiv;
         internal unsafe delegate*<uint, int, int*, uint*, void> glGetAttachedShaders;
         internal unsafe delegate*<uint, byte*, int> glGetAttribLocation;
         internal unsafe delegate*<uint, uint, byte*, void> glGetBooleani_v;
         internal unsafe delegate*<uint, byte*, void> glGetBooleanv;
-        internal unsafe delegate*<uint, uint, IntPtr*, void> glGetBufferParameteri64v;
+        internal unsafe delegate*<uint, uint, long*, void> glGetBufferParameteri64v;
         internal unsafe delegate*<uint, uint, int*, void> glGetBufferParameteriv;
-        internal unsafe delegate*<uint, uint, IntPtr*, void> glGetBufferPointerv;
-        internal unsafe delegate*<uint, nint, nuint, IntPtr*, void> glGetBufferSubData;
-        internal unsafe delegate*<uint, int, IntPtr*, void> glGetCompressedTexImage;
-        internal unsafe delegate*<uint, int, int, IntPtr*, void> glGetCompressedTextureImage;
-        internal unsafe delegate*<uint, int, int, int, int, int, int, int, int, IntPtr*, void> glGetCompressedTextureSubImage;
+        internal unsafe delegate*<uint, uint, void**, void> glGetBufferPointerv;
+        internal unsafe delegate*<uint, nint, nint, void*, void> glGetBufferSubData;
+        internal unsafe delegate*<uint, int, void*, void> glGetCompressedTexImage;
+        internal unsafe delegate*<uint, int, int, void*, void> glGetCompressedTextureImage;
+        internal unsafe delegate*<uint, int, int, int, int, int, int, int, int, void*, void> glGetCompressedTextureSubImage;
         internal unsafe delegate*<uint, int, uint*, uint*, uint*, uint*, int*, byte*, uint> glGetDebugMessageLog;
         internal unsafe delegate*<uint, uint, double*, void> glGetDoublei_v;
         internal unsafe delegate*<uint, double*, void> glGetDoublev;
@@ -227,105 +223,105 @@ namespace StgSharp.Graphics.OpenGL
         internal unsafe delegate*<uint, uint, uint, int*, void> glGetFramebufferAttachmentParameteriv;
         internal unsafe delegate*<uint, uint, int*, void> glGetFramebufferParameteriv;
         internal unsafe delegate*<uint> glGetGraphicsResetStatus;
-        internal unsafe delegate*<uint, uint, IntPtr*, void> glGetInteger64i_v;
-        internal unsafe delegate*<uint, IntPtr*, void> glGetInteger64v;
+        internal unsafe delegate*<uint, uint, long*, void> glGetInteger64i_v;
+        internal unsafe delegate*<uint, long*, void> glGetInteger64v;
         internal unsafe delegate*<uint, uint, int*, void> glGetIntegeri_v;
         internal unsafe delegate*<uint, int*, void> glGetIntegerv;
-        internal unsafe delegate*<uint, uint, uint, int, IntPtr*, void> glGetInternalformati64v;
+        internal unsafe delegate*<uint, uint, uint, int, long*, void> glGetInternalformati64v;
         internal unsafe delegate*<uint, uint, uint, int, int*, void> glGetInternalformativ;
         internal unsafe delegate*<uint, uint, float*, void> glGetMultisamplefv;
-        internal unsafe delegate*<uint, uint, IntPtr*, void> glGetNamedBufferParameteri64v;
+        internal unsafe delegate*<uint, uint, long*, void> glGetNamedBufferParameteri64v;
         internal unsafe delegate*<uint, uint, int*, void> glGetNamedBufferParameteriv;
-        internal unsafe delegate*<uint, uint, IntPtr*, void> glGetNamedBufferPointerv;
-        internal unsafe delegate*<uint, nint, nuint, IntPtr*, void> glGetNamedBufferSubData;
+        internal unsafe delegate*<uint, uint, void**, void> glGetNamedBufferPointerv;
+        internal unsafe delegate*<uint, nint, nint, void*, void> glGetNamedBufferSubData;
         internal unsafe delegate*<uint, uint, uint, int*, void> glGetNamedFramebufferAttachmentParameteriv;
         internal unsafe delegate*<uint, uint, int*, void> glGetNamedFramebufferParameteriv;
         internal unsafe delegate*<uint, uint, int*, void> glGetNamedRenderbufferParameteriv;
-        internal unsafe delegate*<uint, int, int, IntPtr*, void> glGetnCompressedTexImage;
-        internal unsafe delegate*<uint, int, uint, uint, int, IntPtr*, void> glGetnTexImage;
-        internal unsafe delegate*<uint, int, int, double*, void> glGetnUniformdv;
-        internal unsafe delegate*<uint, int, int, float*, void> glGetnUniformfv;
-        internal unsafe delegate*<uint, int, int, int*, void> glGetnUniformiv;
-        internal unsafe delegate*<uint, int, int, uint*, void> glGetnUniformuiv;
         internal unsafe delegate*<uint, uint, int, int*, byte*, void> glGetObjectLabel;
-        internal unsafe delegate*<IntPtr*, int, int*, byte*, void> glGetObjectPtrLabel;
-        internal unsafe delegate*<uint, IntPtr*, void> glGetPointerv;
-        internal unsafe delegate*<uint, int, int*, uint*, IntPtr*, void> glGetProgramBinary;
+        internal unsafe delegate*<void*, int, int*, byte*, void> glGetObjectPtrLabel;
+        internal unsafe delegate*<uint, void**, void> glGetPointerv;
+        internal unsafe delegate*<uint, int, int*, uint*, void*, void> glGetProgramBinary;
         internal unsafe delegate*<uint, int, int*, byte*, void> glGetProgramInfoLog;
         internal unsafe delegate*<uint, uint, uint, int*, void> glGetProgramInterfaceiv;
-        internal unsafe delegate*<uint, uint, int*, void> glGetProgramiv;
         internal unsafe delegate*<uint, int, int*, byte*, void> glGetProgramPipelineInfoLog;
         internal unsafe delegate*<uint, uint, int*, void> glGetProgramPipelineiv;
         internal unsafe delegate*<uint, uint, byte*, uint> glGetProgramResourceIndex;
-        internal unsafe delegate*<uint, uint, uint, int, uint*, int, int*, int*, void> glGetProgramResourceiv;
         internal unsafe delegate*<uint, uint, byte*, int> glGetProgramResourceLocation;
         internal unsafe delegate*<uint, uint, byte*, int> glGetProgramResourceLocationIndex;
         internal unsafe delegate*<uint, uint, uint, int, int*, byte*, void> glGetProgramResourceName;
+        internal unsafe delegate*<uint, uint, uint, int, uint*, int, int*, int*, void> glGetProgramResourceiv;
         internal unsafe delegate*<uint, uint, uint, int*, void> glGetProgramStageiv;
+        internal unsafe delegate*<uint, uint, int*, void> glGetProgramiv;
         internal unsafe delegate*<uint, uint, uint, nint, void> glGetQueryBufferObjecti64v;
         internal unsafe delegate*<uint, uint, uint, nint, void> glGetQueryBufferObjectiv;
         internal unsafe delegate*<uint, uint, uint, nint, void> glGetQueryBufferObjectui64v;
         internal unsafe delegate*<uint, uint, uint, nint, void> glGetQueryBufferObjectuiv;
         internal unsafe delegate*<uint, uint, uint, int*, void> glGetQueryIndexediv;
-        internal unsafe delegate*<uint, uint, int*, void> glGetQueryiv;
-        internal unsafe delegate*<uint, uint, IntPtr*, void> glGetQueryObjecti64v;
+        internal unsafe delegate*<uint, uint, long*, void> glGetQueryObjecti64v;
         internal unsafe delegate*<uint, uint, int*, void> glGetQueryObjectiv;
-        internal unsafe delegate*<uint, uint, IntPtr*, void> glGetQueryObjectui64v;
+        internal unsafe delegate*<uint, uint, ulong*, void> glGetQueryObjectui64v;
         internal unsafe delegate*<uint, uint, uint*, void> glGetQueryObjectuiv;
+        internal unsafe delegate*<uint, uint, int*, void> glGetQueryiv;
         internal unsafe delegate*<uint, uint, int*, void> glGetRenderbufferParameteriv;
-        internal unsafe delegate*<uint, uint, float*, void> glGetSamplerParameterfv;
         internal unsafe delegate*<uint, uint, int*, void> glGetSamplerParameterIiv;
         internal unsafe delegate*<uint, uint, uint*, void> glGetSamplerParameterIuiv;
+        internal unsafe delegate*<uint, uint, float*, void> glGetSamplerParameterfv;
         internal unsafe delegate*<uint, uint, int*, void> glGetSamplerParameteriv;
         internal unsafe delegate*<uint, int, int*, byte*, void> glGetShaderInfoLog;
-        internal unsafe delegate*<uint, uint, int*, void> glGetShaderiv;
         internal unsafe delegate*<uint, uint, int*, int*, void> glGetShaderPrecisionFormat;
         internal unsafe delegate*<uint, int, int*, byte*, void> glGetShaderSource;
+        internal unsafe delegate*<uint, uint, int*, void> glGetShaderiv;
         internal unsafe delegate*<uint, byte*> glGetString;
         internal unsafe delegate*<uint, uint, byte*> glGetStringi;
         internal unsafe delegate*<uint, uint, byte*, uint> glGetSubroutineIndex;
         internal unsafe delegate*<uint, uint, byte*, int> glGetSubroutineUniformLocation;
         internal unsafe delegate*<glSync, uint, int, int*, int*, void> glGetSynciv;
-        internal unsafe delegate*<uint, int, uint, uint, IntPtr*, void> glGetTexImage;
+        internal unsafe delegate*<uint, int, uint, uint, void*, void> glGetTexImage;
         internal unsafe delegate*<uint, int, uint, float*, void> glGetTexLevelParameterfv;
         internal unsafe delegate*<uint, int, uint, int*, void> glGetTexLevelParameteriv;
-        internal unsafe delegate*<uint, uint, float*, void> glGetTexParameterfv;
         internal unsafe delegate*<uint, uint, int*, void> glGetTexParameterIiv;
         internal unsafe delegate*<uint, uint, uint*, void> glGetTexParameterIuiv;
+        internal unsafe delegate*<uint, uint, float*, void> glGetTexParameterfv;
         internal unsafe delegate*<uint, uint, int*, void> glGetTexParameteriv;
-        internal unsafe delegate*<uint, int, uint, uint, int, IntPtr*, void> glGetTextureImage;
+        internal unsafe delegate*<uint, int, uint, uint, int, void*, void> glGetTextureImage;
         internal unsafe delegate*<uint, int, uint, float*, void> glGetTextureLevelParameterfv;
         internal unsafe delegate*<uint, int, uint, int*, void> glGetTextureLevelParameteriv;
-        internal unsafe delegate*<uint, uint, float*, void> glGetTextureParameterfv;
         internal unsafe delegate*<uint, uint, int*, void> glGetTextureParameterIiv;
         internal unsafe delegate*<uint, uint, uint*, void> glGetTextureParameterIuiv;
+        internal unsafe delegate*<uint, uint, float*, void> glGetTextureParameterfv;
         internal unsafe delegate*<uint, uint, int*, void> glGetTextureParameteriv;
-        internal unsafe delegate*<uint, int, int, int, int, int, int, int, uint, uint, int, IntPtr*, void> glGetTextureSubImage;
-        internal unsafe delegate*<uint, uint, uint, int*, void> glGetTransformFeedbacki_v;
-        internal unsafe delegate*<uint, uint, uint, IntPtr*, void> glGetTransformFeedbacki64_v;
-        internal unsafe delegate*<uint, uint, int*, void> glGetTransformFeedbackiv;
+        internal unsafe delegate*<uint, int, int, int, int, int, int, int, uint, uint, int, void*, void> glGetTextureSubImage;
         internal unsafe delegate*<uint, uint, int, int*, int*, uint*, byte*, void> glGetTransformFeedbackVarying;
+        internal unsafe delegate*<uint, uint, uint, long*, void> glGetTransformFeedbacki64_v;
+        internal unsafe delegate*<uint, uint, uint, int*, void> glGetTransformFeedbacki_v;
+        internal unsafe delegate*<uint, uint, int*, void> glGetTransformFeedbackiv;
         internal unsafe delegate*<uint, byte*, uint> glGetUniformBlockIndex;
-        internal unsafe delegate*<uint, int, double*, void> glGetUniformdv;
-        internal unsafe delegate*<uint, int, float*, void> glGetUniformfv;
-        internal unsafe delegate*<uint, int, byte*, uint*, void> glGetUniformIndices;
-        internal unsafe delegate*<uint, int, int*, void> glGetUniformiv;
+        internal unsafe delegate*<uint, int, byte**, uint*, void> glGetUniformIndices;
         internal unsafe delegate*<uint, byte*, int> glGetUniformLocation;
         internal unsafe delegate*<uint, int, uint*, void> glGetUniformSubroutineuiv;
+        internal unsafe delegate*<uint, int, double*, void> glGetUniformdv;
+        internal unsafe delegate*<uint, int, float*, void> glGetUniformfv;
+        internal unsafe delegate*<uint, int, int*, void> glGetUniformiv;
         internal unsafe delegate*<uint, int, uint*, void> glGetUniformuiv;
-        internal unsafe delegate*<uint, uint, uint, IntPtr*, void> glGetVertexArrayIndexed64iv;
+        internal unsafe delegate*<uint, uint, uint, long*, void> glGetVertexArrayIndexed64iv;
         internal unsafe delegate*<uint, uint, uint, int*, void> glGetVertexArrayIndexediv;
         internal unsafe delegate*<uint, uint, int*, void> glGetVertexArrayiv;
-        internal unsafe delegate*<uint, uint, double*, void> glGetVertexAttribdv;
-        internal unsafe delegate*<uint, uint, float*, void> glGetVertexAttribfv;
         internal unsafe delegate*<uint, uint, int*, void> glGetVertexAttribIiv;
         internal unsafe delegate*<uint, uint, uint*, void> glGetVertexAttribIuiv;
-        internal unsafe delegate*<uint, uint, int*, void> glGetVertexAttribiv;
         internal unsafe delegate*<uint, uint, double*, void> glGetVertexAttribLdv;
-        internal unsafe delegate*<uint, uint, IntPtr*, void> glGetVertexAttribPointerv;
+        internal unsafe delegate*<uint, uint, void**, void> glGetVertexAttribPointerv;
+        internal unsafe delegate*<uint, uint, double*, void> glGetVertexAttribdv;
+        internal unsafe delegate*<uint, uint, float*, void> glGetVertexAttribfv;
+        internal unsafe delegate*<uint, uint, int*, void> glGetVertexAttribiv;
+        internal unsafe delegate*<uint, int, int, void*, void> glGetnCompressedTexImage;
+        internal unsafe delegate*<uint, int, uint, uint, int, void*, void> glGetnTexImage;
+        internal unsafe delegate*<uint, int, int, double*, void> glGetnUniformdv;
+        internal unsafe delegate*<uint, int, int, float*, void> glGetnUniformfv;
+        internal unsafe delegate*<uint, int, int, int*, void> glGetnUniformiv;
+        internal unsafe delegate*<uint, int, int, uint*, void> glGetnUniformuiv;
         internal unsafe delegate*<uint, uint, void> glHint;
         internal unsafe delegate*<uint, void> glInvalidateBufferData;
-        internal unsafe delegate*<uint, nint, nuint, void> glInvalidateBufferSubData;
+        internal unsafe delegate*<uint, nint, nint, void> glInvalidateBufferSubData;
         internal unsafe delegate*<uint, int, uint*, void> glInvalidateFramebuffer;
         internal unsafe delegate*<uint, int, uint*, void> glInvalidateNamedFramebufferData;
         internal unsafe delegate*<uint, int, uint*, int, int, int, int, void> glInvalidateNamedFramebufferSubData;
@@ -350,22 +346,22 @@ namespace StgSharp.Graphics.OpenGL
         internal unsafe delegate*<uint, void> glLinkProgram;
         internal unsafe delegate*<uint, void> glLogicOp;
         internal unsafe delegate*<uint, uint, void*> glMapBuffer;
-        internal unsafe delegate*<uint, nint, nuint, uint, void*> glMapBufferRange;
+        internal unsafe delegate*<uint, nint, nint, uint, void*> glMapBufferRange;
         internal unsafe delegate*<uint, uint, void*> glMapNamedBuffer;
-        internal unsafe delegate*<uint, nint, nuint, uint, void*> glMapNamedBufferRange;
+        internal unsafe delegate*<uint, nint, nint, uint, void*> glMapNamedBufferRange;
         internal unsafe delegate*<uint, void> glMemoryBarrier;
         internal unsafe delegate*<uint, void> glMemoryBarrierByRegion;
         internal unsafe delegate*<float, void> glMinSampleShading;
         internal unsafe delegate*<uint, int*, int*, int, void> glMultiDrawArrays;
-        internal unsafe delegate*<uint, IntPtr*, int, int, void> glMultiDrawArraysIndirect;
-        internal unsafe delegate*<uint, IntPtr*, nint, int, int, void> glMultiDrawArraysIndirectCount;
-        internal unsafe delegate*<uint, int*, uint, IntPtr*, int, void> glMultiDrawElements;
-        internal unsafe delegate*<uint, int*, uint, IntPtr*, int, int*, void> glMultiDrawElementsBaseVertex;
-        internal unsafe delegate*<uint, uint, IntPtr*, int, int, void> glMultiDrawElementsIndirect;
-        internal unsafe delegate*<uint, uint, IntPtr*, nint, int, int, void> glMultiDrawElementsIndirectCount;
-        internal unsafe delegate*<uint, nuint, IntPtr*, uint, void> glNamedBufferData;
-        internal unsafe delegate*<uint, nuint, IntPtr*, uint, void> glNamedBufferStorage;
-        internal unsafe delegate*<uint, nint, nuint, IntPtr*, void> glNamedBufferSubData;
+        internal unsafe delegate*<uint, void*, int, int, void> glMultiDrawArraysIndirect;
+        internal unsafe delegate*<uint, void*, nint, int, int, void> glMultiDrawArraysIndirectCount;
+        internal unsafe delegate*<uint, int*, uint, void**, int, void> glMultiDrawElements;
+        internal unsafe delegate*<uint, int*, uint, void**, int, int*, void> glMultiDrawElementsBaseVertex;
+        internal unsafe delegate*<uint, uint, void*, int, int, void> glMultiDrawElementsIndirect;
+        internal unsafe delegate*<uint, uint, void*, nint, int, int, void> glMultiDrawElementsIndirectCount;
+        internal unsafe delegate*<uint, nint, void*, uint, void> glNamedBufferData;
+        internal unsafe delegate*<uint, nint, void*, uint, void> glNamedBufferStorage;
+        internal unsafe delegate*<uint, nint, nint, void*, void> glNamedBufferSubData;
         internal unsafe delegate*<uint, uint, void> glNamedFramebufferDrawBuffer;
         internal unsafe delegate*<uint, int, uint*, void> glNamedFramebufferDrawBuffers;
         internal unsafe delegate*<uint, uint, int, void> glNamedFramebufferParameteri;
@@ -376,7 +372,7 @@ namespace StgSharp.Graphics.OpenGL
         internal unsafe delegate*<uint, uint, int, int, void> glNamedRenderbufferStorage;
         internal unsafe delegate*<uint, int, uint, int, int, void> glNamedRenderbufferStorageMultisample;
         internal unsafe delegate*<uint, uint, int, byte*, void> glObjectLabel;
-        internal unsafe delegate*<IntPtr*, int, byte*, void> glObjectPtrLabel;
+        internal unsafe delegate*<void*, int, byte*, void> glObjectPtrLabel;
         internal unsafe delegate*<uint, float*, void> glPatchParameterfv;
         internal unsafe delegate*<uint, int, void> glPatchParameteri;
         internal unsafe delegate*<void> glPauseTransformFeedback;
@@ -392,7 +388,7 @@ namespace StgSharp.Graphics.OpenGL
         internal unsafe delegate*<float, float, float, void> glPolygonOffsetClamp;
         internal unsafe delegate*<void> glPopDebugGroup;
         internal unsafe delegate*<uint, void> glPrimitiveRestartIndex;
-        internal unsafe delegate*<uint, uint, IntPtr*, int, void> glProgramBinary;
+        internal unsafe delegate*<uint, uint, void*, int, void> glProgramBinary;
         internal unsafe delegate*<uint, uint, int, void> glProgramParameteri;
         internal unsafe delegate*<uint, int, double, void> glProgramUniform1d;
         internal unsafe delegate*<uint, int, int, double*, void> glProgramUniform1dv;
@@ -448,25 +444,25 @@ namespace StgSharp.Graphics.OpenGL
         internal unsafe delegate*<uint, uint, int, byte*, void> glPushDebugGroup;
         internal unsafe delegate*<uint, uint, void> glQueryCounter;
         internal unsafe delegate*<uint, void> glReadBuffer;
-        internal unsafe delegate*<int, int, int, int, uint, uint, int, IntPtr*, void> glReadnPixels;
-        internal unsafe delegate*<int, int, int, int, uint, uint, IntPtr*, void> glReadPixels;
+        internal unsafe delegate*<int, int, int, int, uint, uint, void*, void> glReadPixels;
+        internal unsafe delegate*<int, int, int, int, uint, uint, int, void*, void> glReadnPixels;
         internal unsafe delegate*<void> glReleaseShaderCompiler;
         internal unsafe delegate*<uint, uint, int, int, void> glRenderbufferStorage;
         internal unsafe delegate*<uint, int, uint, int, int, void> glRenderbufferStorageMultisample;
         internal unsafe delegate*<void> glResumeTransformFeedback;
         internal unsafe delegate*<float, byte, void> glSampleCoverage;
         internal unsafe delegate*<uint, uint, void> glSampleMaski;
+        internal unsafe delegate*<uint, uint, int*, void> glSamplerParameterIiv;
+        internal unsafe delegate*<uint, uint, uint*, void> glSamplerParameterIuiv;
         internal unsafe delegate*<uint, uint, float, void> glSamplerParameterf;
         internal unsafe delegate*<uint, uint, float*, void> glSamplerParameterfv;
         internal unsafe delegate*<uint, uint, int, void> glSamplerParameteri;
-        internal unsafe delegate*<uint, uint, int*, void> glSamplerParameterIiv;
-        internal unsafe delegate*<uint, uint, uint*, void> glSamplerParameterIuiv;
         internal unsafe delegate*<uint, uint, int*, void> glSamplerParameteriv;
         internal unsafe delegate*<int, int, int, int, void> glScissor;
         internal unsafe delegate*<uint, int, int*, void> glScissorArrayv;
         internal unsafe delegate*<uint, int, int, int, int, void> glScissorIndexed;
         internal unsafe delegate*<uint, int*, void> glScissorIndexedv;
-        internal unsafe delegate*<int, uint*, uint, IntPtr*, int, void> glShaderBinary;
+        internal unsafe delegate*<int, uint*, uint, void*, int, void> glShaderBinary;
         internal unsafe delegate*<uint, int, byte**, int*, void> glShaderSource;
         internal unsafe delegate*<uint, uint, uint, void> glShaderStorageBlockBinding;
         internal unsafe delegate*<uint, byte*, uint, uint*, uint*, void> glSpecializeShader;
@@ -477,47 +473,47 @@ namespace StgSharp.Graphics.OpenGL
         internal unsafe delegate*<uint, uint, uint, void> glStencilOp;
         internal unsafe delegate*<uint, uint, uint, uint, void> glStencilOpSeparate;
         internal unsafe delegate*<uint, uint, uint, void> glTexBuffer;
-        internal unsafe delegate*<uint, uint, uint, nint, nuint, void> glTexBufferRange;
-        internal unsafe delegate*<uint, int, int, int, int, uint, uint, IntPtr*, void> glTexImage1D;
-        internal unsafe delegate*<uint, int, int, int, int, int, uint, uint, IntPtr*, void> glTexImage2D;
+        internal unsafe delegate*<uint, uint, uint, nint, nint, void> glTexBufferRange;
+        internal unsafe delegate*<uint, int, int, int, int, uint, uint, void*, void> glTexImage1D;
+        internal unsafe delegate*<uint, int, int, int, int, int, uint, uint, void*, void> glTexImage2D;
         internal unsafe delegate*<uint, int, uint, int, int, byte, void> glTexImage2DMultisample;
-        internal unsafe delegate*<uint, int, int, int, int, int, int, uint, uint, IntPtr*, void> glTexImage3D;
+        internal unsafe delegate*<uint, int, int, int, int, int, int, uint, uint, void*, void> glTexImage3D;
         internal unsafe delegate*<uint, int, uint, int, int, int, byte, void> glTexImage3DMultisample;
+        internal unsafe delegate*<uint, uint, int*, void> glTexParameterIiv;
+        internal unsafe delegate*<uint, uint, uint*, void> glTexParameterIuiv;
         internal unsafe delegate*<uint, uint, float, void> glTexParameterf;
         internal unsafe delegate*<uint, uint, float*, void> glTexParameterfv;
         internal unsafe delegate*<uint, uint, int, void> glTexParameteri;
-        internal unsafe delegate*<uint, uint, int*, void> glTexParameterIiv;
-        internal unsafe delegate*<uint, uint, uint*, void> glTexParameterIuiv;
         internal unsafe delegate*<uint, uint, int*, void> glTexParameteriv;
         internal unsafe delegate*<uint, int, uint, int, void> glTexStorage1D;
         internal unsafe delegate*<uint, int, uint, int, int, void> glTexStorage2D;
         internal unsafe delegate*<uint, int, uint, int, int, byte, void> glTexStorage2DMultisample;
         internal unsafe delegate*<uint, int, uint, int, int, int, void> glTexStorage3D;
         internal unsafe delegate*<uint, int, uint, int, int, int, byte, void> glTexStorage3DMultisample;
-        internal unsafe delegate*<uint, int, int, int, uint, uint, IntPtr*, void> glTexSubImage1D;
-        internal unsafe delegate*<uint, int, int, int, int, int, uint, uint, IntPtr*, void> glTexSubImage2D;
-        internal unsafe delegate*<uint, int, int, int, int, int, int, int, uint, uint, IntPtr*, void> glTexSubImage3D;
+        internal unsafe delegate*<uint, int, int, int, uint, uint, void*, void> glTexSubImage1D;
+        internal unsafe delegate*<uint, int, int, int, int, int, uint, uint, void*, void> glTexSubImage2D;
+        internal unsafe delegate*<uint, int, int, int, int, int, int, int, uint, uint, void*, void> glTexSubImage3D;
         internal unsafe delegate*<void> glTextureBarrier;
         internal unsafe delegate*<uint, uint, uint, void> glTextureBuffer;
-        internal unsafe delegate*<uint, uint, uint, nint, nuint, void> glTextureBufferRange;
+        internal unsafe delegate*<uint, uint, uint, nint, nint, void> glTextureBufferRange;
+        internal unsafe delegate*<uint, uint, int*, void> glTextureParameterIiv;
+        internal unsafe delegate*<uint, uint, uint*, void> glTextureParameterIuiv;
         internal unsafe delegate*<uint, uint, float, void> glTextureParameterf;
         internal unsafe delegate*<uint, uint, float*, void> glTextureParameterfv;
         internal unsafe delegate*<uint, uint, int, void> glTextureParameteri;
-        internal unsafe delegate*<uint, uint, int*, void> glTextureParameterIiv;
-        internal unsafe delegate*<uint, uint, uint*, void> glTextureParameterIuiv;
         internal unsafe delegate*<uint, uint, int*, void> glTextureParameteriv;
         internal unsafe delegate*<uint, int, uint, int, void> glTextureStorage1D;
         internal unsafe delegate*<uint, int, uint, int, int, void> glTextureStorage2D;
         internal unsafe delegate*<uint, int, uint, int, int, byte, void> glTextureStorage2DMultisample;
         internal unsafe delegate*<uint, int, uint, int, int, int, void> glTextureStorage3D;
         internal unsafe delegate*<uint, int, uint, int, int, int, byte, void> glTextureStorage3DMultisample;
-        internal unsafe delegate*<uint, int, int, int, uint, uint, IntPtr*, void> glTextureSubImage1D;
-        internal unsafe delegate*<uint, int, int, int, int, int, uint, uint, IntPtr*, void> glTextureSubImage2D;
-        internal unsafe delegate*<uint, int, int, int, int, int, int, int, uint, uint, IntPtr*, void> glTextureSubImage3D;
+        internal unsafe delegate*<uint, int, int, int, uint, uint, void*, void> glTextureSubImage1D;
+        internal unsafe delegate*<uint, int, int, int, int, int, uint, uint, void*, void> glTextureSubImage2D;
+        internal unsafe delegate*<uint, int, int, int, int, int, int, int, uint, uint, void*, void> glTextureSubImage3D;
         internal unsafe delegate*<uint, uint, uint, uint, uint, uint, uint, uint, void> glTextureView;
         internal unsafe delegate*<uint, uint, uint, void> glTransformFeedbackBufferBase;
-        internal unsafe delegate*<uint, uint, uint, nint, nuint, void> glTransformFeedbackBufferRange;
-        internal unsafe delegate*<uint, int, byte*, uint, void> glTransformFeedbackVaryings;
+        internal unsafe delegate*<uint, uint, uint, nint, nint, void> glTransformFeedbackBufferRange;
+        internal unsafe delegate*<uint, int, byte**, uint, void> glTransformFeedbackVaryings;
         internal unsafe delegate*<int, double, void> glUniform1d;
         internal unsafe delegate*<int, int, double*, void> glUniform1dv;
         internal unsafe delegate*<int, float, void> glUniform1f;
@@ -602,12 +598,6 @@ namespace StgSharp.Graphics.OpenGL
         internal unsafe delegate*<uint, float*, void> glVertexAttrib3fv;
         internal unsafe delegate*<uint, short, short, short, void> glVertexAttrib3s;
         internal unsafe delegate*<uint, short*, void> glVertexAttrib3sv;
-        internal unsafe delegate*<uint, sbyte*, void> glVertexAttrib4bv;
-        internal unsafe delegate*<uint, double, double, double, double, void> glVertexAttrib4d;
-        internal unsafe delegate*<uint, double*, void> glVertexAttrib4dv;
-        internal unsafe delegate*<uint, float, float, float, float, void> glVertexAttrib4f;
-        internal unsafe delegate*<uint, float*, void> glVertexAttrib4fv;
-        internal unsafe delegate*<uint, int*, void> glVertexAttrib4iv;
         internal unsafe delegate*<uint, sbyte*, void> glVertexAttrib4Nbv;
         internal unsafe delegate*<uint, int*, void> glVertexAttrib4Niv;
         internal unsafe delegate*<uint, short*, void> glVertexAttrib4Nsv;
@@ -615,6 +605,12 @@ namespace StgSharp.Graphics.OpenGL
         internal unsafe delegate*<uint, byte*, void> glVertexAttrib4Nubv;
         internal unsafe delegate*<uint, uint*, void> glVertexAttrib4Nuiv;
         internal unsafe delegate*<uint, ushort*, void> glVertexAttrib4Nusv;
+        internal unsafe delegate*<uint, sbyte*, void> glVertexAttrib4bv;
+        internal unsafe delegate*<uint, double, double, double, double, void> glVertexAttrib4d;
+        internal unsafe delegate*<uint, double*, void> glVertexAttrib4dv;
+        internal unsafe delegate*<uint, float, float, float, float, void> glVertexAttrib4f;
+        internal unsafe delegate*<uint, float*, void> glVertexAttrib4fv;
+        internal unsafe delegate*<uint, int*, void> glVertexAttrib4iv;
         internal unsafe delegate*<uint, short, short, short, short, void> glVertexAttrib4s;
         internal unsafe delegate*<uint, short*, void> glVertexAttrib4sv;
         internal unsafe delegate*<uint, byte*, void> glVertexAttrib4ubv;
@@ -644,7 +640,7 @@ namespace StgSharp.Graphics.OpenGL
         internal unsafe delegate*<uint, uint*, void> glVertexAttribI4uiv;
         internal unsafe delegate*<uint, ushort*, void> glVertexAttribI4usv;
         internal unsafe delegate*<uint, int, uint, uint, void> glVertexAttribIFormat;
-        internal unsafe delegate*<uint, int, uint, int, IntPtr*, void> glVertexAttribIPointer;
+        internal unsafe delegate*<uint, int, uint, int, void*, void> glVertexAttribIPointer;
         internal unsafe delegate*<uint, double, void> glVertexAttribL1d;
         internal unsafe delegate*<uint, double*, void> glVertexAttribL1dv;
         internal unsafe delegate*<uint, double, double, void> glVertexAttribL2d;
@@ -654,7 +650,7 @@ namespace StgSharp.Graphics.OpenGL
         internal unsafe delegate*<uint, double, double, double, double, void> glVertexAttribL4d;
         internal unsafe delegate*<uint, double*, void> glVertexAttribL4dv;
         internal unsafe delegate*<uint, int, uint, uint, void> glVertexAttribLFormat;
-        internal unsafe delegate*<uint, int, uint, int, IntPtr*, void> glVertexAttribLPointer;
+        internal unsafe delegate*<uint, int, uint, int, void*, void> glVertexAttribLPointer;
         internal unsafe delegate*<uint, uint, byte, uint, void> glVertexAttribP1ui;
         internal unsafe delegate*<uint, uint, byte, uint*, void> glVertexAttribP1uiv;
         internal unsafe delegate*<uint, uint, byte, uint, void> glVertexAttribP2ui;
@@ -663,13 +659,12 @@ namespace StgSharp.Graphics.OpenGL
         internal unsafe delegate*<uint, uint, byte, uint*, void> glVertexAttribP3uiv;
         internal unsafe delegate*<uint, uint, byte, uint, void> glVertexAttribP4ui;
         internal unsafe delegate*<uint, uint, byte, uint*, void> glVertexAttribP4uiv;
-        internal unsafe delegate*<uint, int, uint, byte, int, IntPtr*, void> glVertexAttribPointer;
+        internal unsafe delegate*<uint, int, uint, byte, int, void*, void> glVertexAttribPointer;
         internal unsafe delegate*<uint, uint, void> glVertexBindingDivisor;
         internal unsafe delegate*<int, int, int, int, void> glViewport;
         internal unsafe delegate*<uint, int, float*, void> glViewportArrayv;
         internal unsafe delegate*<uint, float, float, float, float, void> glViewportIndexedf;
         internal unsafe delegate*<uint, float*, void> glViewportIndexedfv;
-        internal unsafe delegate*<glSync, uint, IntPtr, void> glWaitSync;
-
+        internal unsafe delegate*<glSync, uint, ulong, void> glWaitSync;
     }
 }

src/StgSharp.Graphics/OpenGL/ShaderEdit/Uniform.cs

@@ -5,11 +5,6 @@
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-using StgSharp.Graphics;
-using StgSharp.Mathematics.Graphics;
-using System.Diagnostics.CodeAnalysis;
-using System.Runtime.CompilerServices;
-
 namespace StgSharp.Graphics.OpenGL
 {
     public class Uniform
@@ -120,86 +115,4 @@ namespace StgSharp.Graphics.OpenGL
 
     }
 
-    public unsafe partial class OpenGLFunction
-    {
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetUniformValue(
-                    [NotNull] Uniform<GraphicsMatrix> uniform,
-                    GraphicsMatrix mat
-        )
-        {
-            Context.glUniformMatrix4fv(uniform.id.SignedValue, 1, (byte)0, (float*)&mat);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetUniformValue(
-                    [NotNull]Uniform<float, float, float, float> uniform,
-                    Vec4 vec
-        )
-        {
-            Context.glUniform1fv(uniform.id.SignedValue, 4, (float*)&vec);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetUniformValue(
-                    [NotNull]Uniform<Vec4> uniform,
-                    Vec4 vec
-        )
-        {
-            Context.glUniform1fv(uniform.id.SignedValue, 4, (float*)&vec);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetUniformValue(
-                    [NotNull]Uniform<float> uniform,
-                    float v0
-        )
-        {
-            Context.glUniform1f(uniform.id.SignedValue, v0);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetUniformValue(
-                    [NotNull]Uniform<int> uniform,
-                    int i0
-        )
-        {
-            Context.glUniform1i(uniform.id.SignedValue, i0);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetUniformValue(
-                    [NotNull] Uniform<float, float> uniform,
-                    float v0,
-                    float v1
-        )
-        {
-            Context.glUniform2f(uniform.id.SignedValue, v0, v1);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetUniformValue(
-                    [NotNull] Uniform<float, float, float> uniform,
-                    float v0,
-                    float v1,
-                    float v2
-        )
-        {
-            Context.glUniform3f(uniform.id.SignedValue, v0, v1, v2);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetUniformValue(
-                    [NotNull] Uniform<float, float, float, float> uniform,
-                    float v0,
-                    float v1,
-                    float v2,
-                    float v3
-        )
-        {
-            Context.glUniform4f(uniform.id.SignedValue, v0, v1, v2, v3);
-        }
-
-    }
-}
+}

src/StgSharp.Graphics/OpenGL/glFunction.cs

@@ -1,794 +0,0 @@
-// -----------------------------------------------------------------------------
-// file="glFunction"
-// Project: StgSharp
-// Copyright (c) Nitload.
-// SPDX-License-Identifier: MIT
-// -----------------------------------------------------------------------------
-
-using StgSharp.Graphics;
-using StgSharp.Graphics;
-using StgSharp.Internal;
-using StgSharp.Mathematics;
-using StgSharp.Mathematics.Numeric;
-
-using System;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.ExceptionServices;
-using System.Runtime.InteropServices;
-using System.Text;
-using System.Threading;
-
-namespace StgSharp.Graphics.OpenGL
-{
-    public unsafe partial class OpenGLFunction
-    {
-
-        private static readonly Dictionary<IntPtr, OpenGLFunction> contextToGLMap = [];
-        private static readonly ThreadLocal<OpenGLFunction> _currentGL = new ThreadLocal<OpenGLFunction>();
-        private OpenglContext* _context;
-
-        private Lazy<int> _attachmentColorRange;
-
-        private OpenGLFunction()
-        {
-            textureUnitCountGetter = glConst.MAX_TEXTURE_IMAGE_UNITS;
-            UnusedTextureImageUint = [];
-            _attachmentColorRange = new Lazy<int>(
-                () => GetMaskInteger((uint)glConst.MAX_COLOR_ATTACHMENTS));
-        }
-
-        public int AttachmentColorRange => _attachmentColorRange.Value;
-
-        public static OpenGLFunction CurrentGL
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            get => _currentGL.Value!;
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            internal set => _currentGL.Value = value;
-        }
-
-        internal IntPtr ContextHandle => (IntPtr)_context;
-
-        protected ref OpenglContext Context
-        {
-            get
-            {
-                #if DEBUG
-                ArgumentNullException.ThrowIfNull(_context, nameof(_context));
-                #endif
-                return ref (*_context);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void ActiveTextureUnit(
-                    uint type
-        )
-        {
-            _context->glActiveTexture(type);
-        }
-
-        [Conditional("DEBUG")]
-        public void Assert(
-                    bool shouldReportWhenNormal
-        )
-        {
-            uint code = _context->glGetError();
-            if (code != glConst.NO_ERROR) {
-                throw new GlExecutionException(code);
-            }
-            if (shouldReportWhenNormal) {
-                Console.WriteLine("OpenGL runs normally");
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void BindBuffer(
-                    BufferType bufferType,
-                    GlHandle handle
-        )
-        {
-            _context->glBindBuffer((uint)bufferType, handle.Value);
-        }
-
-        /// <summary>
-        ///   Bind a frame BufferHandle to a frame BufferHandle target Same function as <see ///  
-        ///   ///   href="https://docs._gl/gl3/glBindFramebuffer"> glBindFramebuffer </see>.
-        /// </summary>
-        /// <param _label="target">
-        ///   The frame BufferHandle target of the binding operation.
-        /// </param>
-        /// <param _label="handle">
-        ///   The handle of the frame BufferHandle object to bind.
-        /// </param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void BindFrameBuffer(
-                    FrameBufferTarget target,
-                    GlHandle handle
-        )
-        {
-            _context->glBindFramebuffer((uint)target, handle.Value);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void BindRenderBuffer(
-                    GlHandle handle
-        )
-        {
-            _context->glBindRenderbuffer(glConst.RENDERBUFFER, handle.Value);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void BindVertexArray(
-                    GlHandle handle
-        )
-        {
-            _context->glBindVertexArray(handle.Value);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public FrameBufferStatus CheckFrameBufferStatus(
-                                 FrameBufferTarget target
-        )
-        {
-            return (FrameBufferStatus)_context->glCheckFramebufferStatus((uint)target);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Clear(
-                    MaskBufferBit mask
-        )
-        {
-            _context->glClear((uint)mask);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void ClearError()
-        {
-            uint code = 0;
-            for (int i = 0; i < 1024; i++)
-            {
-                code = _context->glGetError();
-                if (code == 0) {
-                    return;
-                }
-
-                // Console.WriteLine(code);
-            }
-            foreach (ProcessThread thread in Process.GetCurrentProcess().Threads) {
-                Debugger.Break();
-            }
-            throw new GlErrorOverflowException(1024, code);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void ClearGraphicError()
-        {
-            while (_context->glGetError() != 0) { }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void CombineFrameBufferRenderBuffer(
-                    FrameBufferAttachment attachment,
-                    GlHandle rboHandle
-        )
-        {
-            _context->glFramebufferRenderbuffer(glConst.FRAMEBUFFER, (uint)attachment,
-                                                glConst.RENDERBUFFER, rboHandle.Value);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe GlHandle CreateGraphicProgram()
-        {
-            return GlHandle.Create(_context->glCreateProgram());
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe GlHandle[] CreateProgram(
-                                 int count
-        )
-        {
-            GlHandle[] h = new GlHandle[count];
-            for (int i = 0; i < count; i++) {
-                h.SetValue(i, _context->glCreateProgram());
-            }
-            return h;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public GlHandle[] CreateShaderSet(
-                          int count,
-                          ShaderType type
-        )
-        {
-            GlHandle[] ret = new GlHandle[count];
-            uint t = (uint)type;
-            for (int i = 0; i < count; i++)
-            {
-                uint id = _context->glCreateShader(t);
-                if (id == 0)
-                {
-                    uint error = _context->glGetError();
-                    throw new InvalidOperationException($"Failed in creating shader: {error}");
-                }
-                ret[i] = GlHandle.Create(id);
-            }
-            return ret;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void DeleteBuffer(
-                           GlHandle handle
-        )
-        {
-            _context->glDeleteBuffers(1, (uint*)&handle);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void DeleteBuffers(
-                           GlHandle[] handle
-        )
-        {
-            if ((handle == null) || (handle.Length == 0)) {
-                throw new ArgumentNullException(nameof(handle));
-            }
-            fixed (GlHandle* hptr = handle)
-            {
-                uint* iptr = (uint*)hptr;
-                for (int i = 0; i < handle.Length; i++) {
-                    _context->glDeleteBuffers(1, iptr + i);
-                }
-            }
-        }
-
-        /// <summary>
-        ///   Delete a render BufferHandle object Very simlilar function as <see ///   ///  
-        ///   href="https://docs.gl/gl3/glDeleteRenderbuffers"> glDeleteRenderbuffers </see>. The
-        ///   only deifference is that this mehtod can only delete one renderbuffer at the same
-        ///   time.
-        /// </summary>
-        /// <param _label="bufferHandle">
-        ///   Handle to BufferHandle to delete.
-        /// </param>
-        public unsafe void DeleteRenderBuffer(
-                           GlHandle bufferHandle
-        )
-        {
-            _context->glDeleteRenderbuffers(1, &bufferHandle.Value);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void DeleteVertexArrays(
-                           GlHandle[] arrays
-        )
-        {
-            fixed (GlHandle* hptr = arrays)
-            {
-                uint* iptr = (uint*)hptr;
-                for (int i = 0; i < arrays.Length; i++) {
-                    _context->glDeleteVertexArrays(1, iptr + i);
-                }
-            }
-        }
-
-        public void DepthMaskAccess(
-                    bool isWrite
-        )
-        {
-            _context->glDepthMask(isWrite ? (byte)1 : (byte)0);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Disable(
-                    glOperation operation
-        )
-        {
-            _context->glDisable((uint)operation);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void DrawArrays(
-                           GeometryType mode,
-                           int first,
-                           int count
-        )
-        {
-            _context->glDrawArrays((uint)mode, first, count);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void DrawElements(
-                           GeometryType mode,
-                           int count,
-                           TypeCode type,
-                           IntPtr ptr
-        )
-        {
-            uint a;
-            a = type switch
-            {
-                TypeCode.UInt32 => glConst.UNSIGNED_INT,
-                TypeCode.UInt16 => glConst.UNSIGNED_SHORT,
-                TypeCode.Byte => glConst.UNSIGNED_BYTE,
-                _ => throw new ArgumentException(
-                    $"{$"{$"Parameter error in parameter {nameof(type)} method DrawElements. "}"}{$"{$"Only {typeof(uint).Name},{typeof(ushort).Name},{typeof(byte).Name} types are supported."}"}")
-            };
-            _context->glDrawElements((uint)mode, count, a, (nint*)ptr);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void DrawElementsInstanced(
-                    GeometryType mode,
-                    int count,
-                    TypeCode type,
-                    IntPtr ptr,
-                    int amount
-        )
-        {
-            uint a;
-            a = type switch
-            {
-                TypeCode.UInt32 => glConst.UNSIGNED_INT,
-                TypeCode.UInt16 => glConst.UNSIGNED_SHORT,
-                TypeCode.Byte => glConst.UNSIGNED_BYTE,
-                _ => throw new ArgumentException(
-                    $"{$"{$"Parameter error in parameter {nameof(type)} method DrawElements. "}"}{$"{$"Only {typeof(uint).Name},{typeof(ushort).Name},{typeof(byte).Name} types are supported."}"}")
-            };
-            _context->glDrawElementsInstanced((uint)mode, count, a, (nint*)ptr, amount);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Enable(
-                    glOperation operation
-        )
-        {
-            _context->glEnable((uint)operation);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void FrameBufferTexture2d(
-                    FrameBufferTarget target,
-                    uint attachment,
-                    Texture2DTarget texTarget,
-                    GlHandle textureHandle,
-                    int level
-        )
-        {
-            _context->glFramebufferTexture2D((uint)target, attachment, (uint)texTarget,
-                                             textureHandle.Value, level);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe GlHandle[] GenBuffers(
-                                 int count
-        )
-        {
-            GlHandle[] h = new GlHandle[count];
-            fixed (GlHandle* hptr = h)
-            {
-                for (int i = 0; i < count; i++) {
-                    _context->glGenBuffers(count, ((uint*)hptr) + i);
-                }
-            }
-            return h;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe GlHandle[] GenRenderBuffer(
-                                 int count
-        )
-        {
-            GlHandle[] h = new GlHandle[count];
-            fixed (GlHandle* hptr = h) {
-                _context->glGenRenderbuffers(count, (uint*)hptr);
-            }
-            return h;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe GlHandle[] GenTextures(
-                                 int count
-        )
-        {
-            GlHandle[] h = new GlHandle[count];
-            fixed (GlHandle* hptr = h) {
-                _context->glGenTextures(count, (uint*)hptr);
-            }
-            return h;
-        }
-
-        public unsafe GlHandle[] GenVertexArrays(
-                                 int count
-        )
-        {
-            GlHandle[] h = new GlHandle[count];
-            fixed (GlHandle* hptr = h) {
-                _context->glGenVertexArrays(count, (uint*)hptr);
-            }
-            return h;
-        }
-
-        public unsafe int GetMaskInteger(
-                          uint statusCode
-        )
-        {
-            int ret = 0;
-            _context->glGetIntegerv(statusCode, &ret);
-            return ret;
-        }
-
-        public string GetShaderStatus(
-                      Shader s,
-                      int index,
-                      int key
-        )
-        {
-            IntPtr sptr = IntPtr.Zero;
-            if (GraphicFramework.glCheckShaderStatus(ref Context, s.handle[index].Value, key,
-                                                     ref sptr) == 0) {
-                return Marshal.PtrToStringAnsi(sptr);
-            }
-            return string.Empty;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void GetTextureImage<T>(
-                           Texture2DTarget target,
-                           int level,
-                           ImageChannel channel,
-                           PixelChannelLayout channelLayout,
-                           T[] dataStream
-        ) where T : unmanaged,INumber<T>
-        {
-            fixed (T* tptr = dataStream) {
-                _context->glGetTexImage((uint)target, level, (uint)channel, (uint)channelLayout,
-                                        (nint*)tptr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void GetTextureLevelProperty(
-                    uint textureTypeMask,
-                    int level,
-                    uint propertyMask,
-                    out int propertyValue
-        )
-        {
-            fixed (int* iptr = &propertyValue) {
-                _context->glGetTexLevelParameteriv(textureTypeMask, level, propertyMask, iptr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe GlHandle GetUniformLocation(
-                               GlHandle program,
-                               string name
-        )
-        {
-            byte[] code = Encoding.UTF8.GetBytes(name);
-            fixed (byte* ptr = code)
-            {
-                int ret = _context->glGetUniformLocation(program.Value, ptr);
-                #if DEBUG
-                if ((ret == glConst.INVALID_OPERATION) || (ret == glConst.INVALID_VALUE))
-                {
-                    throw new InvalidOperationException();
-                }
-                if (ret == -1) {
-                    throw new UniformEmptyReferenceException(nameof(program), name);
-                }
-                #endif
-                return GlHandle.CreateSigned(ret);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void LoadShaderSource(
-                           GlHandle shaderHandle,
-                           byte[] codeStream
-        )
-        {
-            fixed (byte* streamPtr = codeStream) {
-                _context->glShaderSource(shaderHandle.Value, 1, &streamPtr, (int*)0);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void LoadShaderSource(
-                           GlHandle shaderHandle,
-                           ReadOnlySpan<char> codeStream
-        )
-        {
-            fixed (char* streamPtr = codeStream) {
-                _context->glShaderSource(shaderHandle.Value, 1, (byte**)&streamPtr, (int*)0);
-            }
-        }
-
-        public unsafe void LoadShaderSource(
-                           GlHandle shaderHandle,
-                           ReadOnlySpan<byte> codeStream
-        )
-        {
-            fixed (byte* streamPtr = codeStream)
-            {
-                byte* bptr = streamPtr;
-                _context->glShaderSource(shaderHandle.Value, 1, &bptr, (int*)0);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void PolygonMode(
-                    FaceMode mode
-        )
-        {
-            _context->glPolygonMode(glConst.FRONT_AND_BACK, (uint)mode);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void ReadPixels(
-                    (int X, int Y) beginPosition,
-                    (int width, int height) size,
-                    FrameBufferChannel format,
-                    PixelChannelLayout dataType,
-                    ref byte[] stream
-        )
-        {
-            fixed (byte* bptr = stream) {
-                _context->glReadPixels(beginPosition.X, beginPosition.Y, size.width, size.height,
-                                       (uint)format, (uint)dataType, (nint*)bptr);
-            }
-        }
-
-        public void RereadImage(
-                    in Image i,
-                    (int X, int Y) beginPosition,
-                    FrameBufferChannel format,
-                    PixelChannelLayout dataType
-        )
-        {
-            byte[] pixels = i.PixelBuffer;
-            if (!pixels.CheckArrayFormat(dataType)) {
-                throw new GlArrayFormatException(dataType, "i.PixelArray");
-            }
-            fixed (byte* bptr = pixels) {
-                _context->glReadPixels(beginPosition.X, beginPosition.Y, i.Width, i.Height,
-                                       (uint)format, (uint)dataType, (nint*)bptr);
-            }
-            i.PixelUpdateCount++;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void SetBufferData<T>(
-                           BufferType bufferType,
-                           T bufferData,
-                           BufferUsage usage
-        ) where T : unmanaged,INumber<T>
-        {
-            int size = Marshal.SizeOf<T>();
-
-            T* p = &bufferData;
-
-            _context->glBufferData((uint)bufferType, (nuint)size, (nint*)p, (uint)usage);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void SetBufferData<T>(
-                           BufferType bufferType,
-                           T[] bufferArray,
-                           BufferUsage usage
-        ) where T : unmanaged,INumber<T>
-        {
-            int size = bufferArray.Length * Marshal.SizeOf(typeof(T));
-            if (bufferArray == null) {
-                return;
-            }
-
-            fixed (void* bufferPtr = bufferArray) {
-                _context->glBufferData((uint)bufferType, (nuint)size, (nint*)bufferPtr,
-                                       (uint)usage);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void SetBufferData<T>(
-                           BufferType bufferType,
-                           ReadOnlySpan<T> bufferSpan,
-                           BufferUsage usage
-        ) where T : unmanaged,INumber<T>
-        {
-            int size = bufferSpan.Length * Marshal.SizeOf<T>();
-            if (bufferSpan.IsEmpty) {
-                return;
-            }
-
-            fixed (void* bufferPtr = bufferSpan) {
-                _context->glBufferData((uint)bufferType, (nuint)size, (IntPtr*)bufferPtr,
-                                       (uint)usage);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void SetBufferData<T>(
-                           BufferType bufferType,
-                           Span<T> bufferArray,
-                           BufferUsage usage
-        ) where T : unmanaged, INumber<T>
-        {
-            int size = bufferArray.Length * Marshal.SizeOf<T>();
-            if (bufferArray.IsEmpty) {
-                return;
-            }
-
-
-            fixed (void* bufferPtr = bufferArray) {
-                _context->glBufferData((uint)bufferType, (nuint)size, (IntPtr*)bufferPtr,
-                                       (uint)usage);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void SetBufferVectorData<T>(
-                           BufferType bufferType,
-                           ReadOnlySpan<T> bufferSpan,
-                           BufferUsage usage
-        ) where T : unmanaged, IUnmanagedVector<T>
-        {
-            int size = bufferSpan.Length * Marshal.SizeOf<T>();
-
-            fixed (void* bufferPtr = bufferSpan) {
-                _context->glBufferData((uint)bufferType, (nuint)size, (IntPtr*)bufferPtr,
-                                       (uint)usage);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void SetBufferVectorData<T>(
-                           BufferType bufferType,
-                           T[] bufferArray,
-                           BufferUsage usage
-        ) where T : unmanaged, IUnmanagedVector<T>
-        {
-            int size = bufferArray.Length * Marshal.SizeOf(typeof(T));
-            if (bufferArray == null) {
-                return;
-            }
-            fixed (void* bufferPtr = bufferArray) {
-                _context->glBufferData((uint)bufferType, (nuint)size, (IntPtr*)bufferPtr,
-                                       (uint)usage);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void SetRenderBufferStorage(
-                           RenderBufferInternalFormat internalFormat,
-                           (int width, int height) size
-        )
-        {
-            _context->glRenderbufferStorage(glConst.RENDERBUFFER, (uint)internalFormat, size.width,
-                                            size.height);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void SetRenderBufferStorage(
-                           RenderBufferInternalFormat internalFormat,
-                           (uint width, uint height) size
-        )
-        {
-            _context->glRenderbufferStorage(glConst.RENDERBUFFER, (uint)internalFormat,
-                                            (int)size.width, (int)size.height);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetVertexAttribute(
-                    uint index,
-                    int size,
-                    TypeCode t,
-                    bool normalized,
-                    int stride,
-                    int pointer
-        )
-        {
-            uint type = GraphicFramework.GLtype[(int)t];
-            _context->glVertexAttribPointer(index, size, type, (byte)(normalized ? 1 : 0), stride,
-                                            (nint*)pointer);
-            _context->glEnableVertexAttribArray(index);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void TextureImage2d<T>(
-                    Texture2DTarget target,
-                    int level,
-                    ImageChannel sourceChannel,
-                    int width,
-                    int height,
-                    ImageChannel targetChannel,
-                    PixelChannelLayout type,
-                    T[] pixels
-        ) where T : unmanaged, INumber<T>
-        {
-            fixed (T* tptr = pixels)
-            {
-                T* ptr = ((pixels == null) || (pixels.Length == 0)) ? (T*)IntPtr.Zero : tptr;
-                _context->glTexImage2D((uint)target, level, (int)sourceChannel, width, height, 0,
-                                       (uint)targetChannel, (uint)type, (nint*)tptr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void TextureImage2d<T>(
-                    Texture2DTarget target,
-                    int level,
-                    ImageChannel sourceChannel,
-                    int width,
-                    int height,
-                    ImageChannel targetChannel,
-                    PixelChannelLayout type,
-                    Span<T> pixelSpan
-        ) where T : unmanaged, INumber<T>
-        {
-            fixed (T* tPtr = pixelSpan) {
-                _context->glTexImage2D((uint)target, level, (int)sourceChannel, width, height, 0,
-                                       (uint)targetChannel, (uint)type, (nint*)tPtr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void TextureParameter(
-                    int target,
-                    uint pname,
-                    int param
-        )
-        {
-            _context->glTexParameteri((uint)target, pname, param);
-        }
-
-        public static bool TryGetFunctionPackage(
-                           IntPtr handle,
-                           out OpenGLFunction functionPackage
-        )
-        {
-            return contextToGLMap.TryGetValue(handle, out functionPackage);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void VertexAttributeDivisor(
-                    uint layoutIndex,
-                    uint divisor
-        )
-        {
-            _context->glVertexAttribDivisor(layoutIndex, divisor);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void WaitAccomplishment()
-        {
-            _context->glFinish();
-        }
-
-        internal static OpenGLFunction BuildGlFunctionPackage(
-                                       IntPtr handle
-        )
-        {
-            if (contextToGLMap.TryGetValue(handle, out OpenGLFunction pack)) {
-                return pack;
-            }
-            pack = new OpenGLFunction
-            {
-                _context = (OpenglContext*)handle
-            };
-            contextToGLMap.Add(handle, pack);
-            return pack;
-        }
-
-        ~OpenGLFunction()
-        {
-            _ = contextToGLMap.Remove(ContextHandle);
-        }
-
-    }
-}
-

src/StgSharp.Graphics/OpenGL/glFunction.v4_0.cs

@@ -1,524 +0,0 @@
-// -----------------------------------------------------------------------------
-// file="glFunction.v4_0"
-// Project: StgSharp
-// Copyright (c) Nitload.
-// SPDX-License-Identifier: MIT
-// -----------------------------------------------------------------------------
-
-using StgSharp.Graphics.OpenGL;
-using System;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace StgSharp.Graphics.OpenGL
-{
-    public unsafe partial class OpenGLFunction
-    {
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void BeginQueryIndexed(
-                    uint target,
-                    uint index,
-                    uint id
-        )
-        {
-            _context->glBeginQueryIndexed(target, index, id);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void BindTransformFeedback(
-                    uint target,
-                    uint id
-        )
-        {
-            _context->glBindTransformFeedback(target, id);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void BlendEquationi(
-                    uint buf,
-                    uint mode
-        )
-        {
-            _context->glBlendEquationi(buf, mode);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void BlendEquationSeparatei(
-                    uint buf,
-                    uint modeRGB,
-                    uint modeAlpha
-        )
-        {
-            _context->glBlendEquationSeparatei(buf, modeRGB, modeAlpha);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void BlendFunci(
-                    uint buf,
-                    uint src,
-                    uint dst
-        )
-        {
-            _context->glBlendFunci(buf, src, dst);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void BlendFuncSeparatei(
-                    uint buf,
-                    uint srcRGB,
-                    uint dstRGB,
-                    uint srcAlpha,
-                    uint dstAlpha
-        )
-        {
-            _context->glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void DeleteTransformFeedbacks(
-                    int n,
-                    ReadOnlySpan<uint> ids
-        )
-        {
-            fixed (uint* idsPtr = ids) {
-                _context->glDeleteTransformFeedbacks(n, idsPtr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void DrawArraysIndirect(
-                    uint mode,
-                    ReadOnlySpan<IntPtr> indirect
-        )
-        {
-            fixed (IntPtr* indirectPtr = indirect) {
-                _context->glDrawArraysIndirect(mode, indirectPtr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void DrawElementsIndirect(
-                    uint mode,
-                    ShaderType type,
-                    ReadOnlySpan<IntPtr> indirect
-        )
-        {
-            fixed (IntPtr* indirectPtr = indirect) {
-                _context->glDrawElementsIndirect(mode, (uint)type, indirectPtr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void DrawTransformFeedback(
-                    uint mode,
-                    uint id
-        )
-        {
-            _context->glDrawTransformFeedback(mode, id);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void DrawTransformFeedbackStream(
-                    uint mode,
-                    uint id,
-                    uint stream
-        )
-        {
-            _context->glDrawTransformFeedbackStream(mode, id, stream);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void EndQueryIndexed(
-                    uint target,
-                    uint index
-        )
-        {
-            _context->glEndQueryIndexed(target, index);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void GenTransformFeedbacks(
-                    int n,
-                    uint* ids
-        )
-        {
-            _context->glGenTransformFeedbacks(n, ids);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void GetActiveSubroutineName(
-                    GlHandle program,
-                    ShaderType shaderType,
-                    uint index,
-                    int bufSize,
-                    int* length,
-                    byte* name
-        )
-        {
-            _context->glGetActiveSubroutineName(program.Value, (uint)shaderType, index, bufSize,
-                                                length, name);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void GetActiveSubroutineUniformiv(
-                    GlHandle program,
-                    ShaderType shaderType,
-                    uint index,
-                    uint pName,
-                    int* values
-        )
-        {
-            _context->glGetActiveSubroutineUniformiv(program.Value, (uint)shaderType, index, pName,
-                                                     values);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void GetActiveSubroutineUniformName(
-                    GlHandle program,
-                    ShaderType shaderType,
-                    uint index,
-                    int bufSize,
-                    int* length,
-                    byte* name
-        )
-        {
-            _context->glGetActiveSubroutineUniformName(program.Value, (uint)shaderType, index,
-                                                       bufSize, length, name);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void GetProgramStageiv(
-                    GlHandle program,
-                    ShaderType shaderType,
-                    uint pName,
-                    int* values
-        )
-        {
-            _context->glGetProgramStageiv(program.Value, (uint)shaderType, pName, values);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void GetQueryIndexediv(
-                    uint target,
-                    uint index,
-                    uint pName,
-                    int* @params
-        )
-        {
-            _context->glGetQueryIndexediv(target, index, pName, @params);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public uint GetSubroutineIndex(
-                    GlHandle program,
-                    ShaderType shaderType,
-                    ReadOnlySpan<byte> name
-        )
-        {
-            fixed (byte* namePtr = name) {
-                return _context->glGetSubroutineIndex(program.Value, (uint)shaderType, namePtr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public int GetSubroutineUniformLocation(
-                   GlHandle program,
-                   ShaderType shaderType,
-                   ReadOnlySpan<byte> name
-        )
-        {
-            fixed (byte* namePtr = name) {
-                return _context->glGetSubroutineUniformLocation(program.Value, (uint)shaderType, namePtr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void GetUniformdv(
-                    GlHandle program,
-                    int location,
-                    double* @params
-        )
-        {
-            _context->glGetUniformdv(program.Value, location, @params);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void GetUniformSubroutineuiv(
-                    ShaderType shaderType,
-                    int location,
-                    uint* @params
-        )
-        {
-            _context->glGetUniformSubroutineuiv((uint)shaderType, location, @params);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public byte IsTransformFeedback(
-                    uint id
-        )
-        {
-            return _context->glIsTransformFeedback(id);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void MinSampleShading(
-                    float value
-        )
-        {
-            _context->glMinSampleShading(value);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void PatchParameterfv(
-                    uint pName,
-                    ReadOnlySpan<float> values
-        )
-        {
-            fixed (float* valuesPtr = values) {
-                _context->glPatchParameterfv(pName, valuesPtr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void PatchParameteri(
-                    uint pName,
-                    int value
-        )
-        {
-            _context->glPatchParameteri(pName, value);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void PauseTransformFeedback()
-        {
-            _context->glPauseTransformFeedback();
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void ResumeTransformFeedback()
-        {
-            _context->glResumeTransformFeedback();
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Uniform1d(
-                    int location,
-                    double x
-        )
-        {
-            _context->glUniform1d(location, x);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Uniform1dv(
-                    int location,
-                    int count,
-                    ReadOnlySpan<double> value
-        )
-        {
-            fixed (double* valuePtr = value) {
-                _context->glUniform1dv(location, count, valuePtr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Uniform2d(
-                    int location,
-                    double x,
-                    double y
-        )
-        {
-            _context->glUniform2d(location, x, y);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Uniform2dv(
-                    int location,
-                    int count,
-                    ReadOnlySpan<double> value
-        )
-        {
-            fixed (double* valuePtr = value) {
-                _context->glUniform2dv(location, count, valuePtr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Uniform3d(
-                    int location,
-                    double x,
-                    double y,
-                    double z
-        )
-        {
-            _context->glUniform3d(location, x, y, z);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Uniform3dv(
-                    int location,
-                    int count,
-                    ReadOnlySpan<double> value
-        )
-        {
-            fixed (double* valuePtr = value) {
-                _context->glUniform3dv(location, count, valuePtr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Uniform4d(
-                    int location,
-                    double x,
-                    double y,
-                    double z,
-                    double w
-        )
-        {
-            _context->glUniform4d(location, x, y, z, w);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Uniform4dv(
-                    int location,
-                    int count,
-                    ReadOnlySpan<double> value
-        )
-        {
-            fixed (double* valuePtr = value) {
-                _context->glUniform4dv(location, count, valuePtr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void UniformMatrix2dv(
-                    int location,
-                    int count,
-                    byte transpose,
-                    ReadOnlySpan<double> value
-        )
-        {
-            fixed (double* valuePtr = value) {
-                _context->glUniformMatrix2dv(location, count, transpose, valuePtr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void UniformMatrix2x3dv(
-                    int location,
-                    int count,
-                    byte transpose,
-                    ReadOnlySpan<double> value
-        )
-        {
-            fixed (double* valuePtr = value) {
-                _context->glUniformMatrix2x3dv(location, count, transpose, valuePtr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void UniformMatrix2x4dv(
-                    int location,
-                    int count,
-                    byte transpose,
-                    ReadOnlySpan<double> value
-        )
-        {
-            fixed (double* valuePtr = value) {
-                _context->glUniformMatrix2x4dv(location, count, transpose, valuePtr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void UniformMatrix3dv(
-                    int location,
-                    int count,
-                    byte transpose,
-                    ReadOnlySpan<double> value
-        )
-        {
-            fixed (double* valuePtr = value) {
-                _context->glUniformMatrix3dv(location, count, transpose, valuePtr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void UniformMatrix3x2dv(
-                    int location,
-                    int count,
-                    byte transpose,
-                    ReadOnlySpan<double> value
-        )
-        {
-            fixed (double* valuePtr = value) {
-                _context->glUniformMatrix3x2dv(location, count, transpose, valuePtr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void UniformMatrix3x4dv(
-                    int location,
-                    int count,
-                    byte transpose,
-                    ReadOnlySpan<double> value
-        )
-        {
-            fixed (double* valuePtr = value) {
-                _context->glUniformMatrix3x4dv(location, count, transpose, valuePtr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void UniformMatrix4dv(
-                    int location,
-                    int count,
-                    byte transpose,
-                    ReadOnlySpan<double> value
-        )
-        {
-            fixed (double* valuePtr = value) {
-                _context->glUniformMatrix4dv(location, count, transpose, valuePtr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void UniformMatrix4x2dv(
-                    int location,
-                    int count,
-                    byte transpose,
-                    ReadOnlySpan<double> value
-        )
-        {
-            fixed (double* valuePtr = value) {
-                _context->glUniformMatrix4x2dv(location, count, transpose, valuePtr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void UniformMatrix4x3dv(
-                    int location,
-                    int count,
-                    byte transpose,
-                    ReadOnlySpan<double> value
-        )
-        {
-            fixed (double* valuePtr = value) {
-                _context->glUniformMatrix4x3dv(location, count, transpose, valuePtr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void UniformSubroutinesuiv(
-                    ShaderType shaderType,
-                    int count,
-                    ReadOnlySpan<uint> indices
-        )
-        {
-            fixed (uint* indicesPtr = indices) {
-                _context->glUniformSubroutinesuiv((uint)shaderType, count, indicesPtr);
-            }
-        }
-
-    }
-}

src/StgSharp.Graphics/OpenGL/glFunction.v4_2.cs

@@ -1,170 +0,0 @@
-// -----------------------------------------------------------------------------
-// file="glFunction.v4_2"
-// Project: StgSharp
-// Copyright (c) Nitload.
-// SPDX-License-Identifier: MIT
-// -----------------------------------------------------------------------------
-
-using StgSharp.Graphics.OpenGL;
-using System;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace StgSharp.Graphics.OpenGL
-{
-    public unsafe partial class OpenGLFunction
-    {
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void BindImageTexture(
-                    uint unit,
-                    GlHandle texture,
-                    int level,
-                    byte layered,
-                    int layer,
-                    uint access,
-                    uint format
-        )
-        {
-            _context->glBindImageTexture(unit, texture.Value, level, layered, layer, access,
-                                         format);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void DrawArraysInstancedBaseInstance(
-                    uint mode,
-                    int first,
-                    int count,
-                    int instancecount,
-                    uint baseinstance
-        )
-        {
-            _context->glDrawArraysInstancedBaseInstance(mode, first, count, instancecount,
-                                                        baseinstance);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void DrawElementsInstancedBaseInstance(
-                    uint mode,
-                    int count,
-                    ShaderType type,
-                    ReadOnlySpan<IntPtr> indices,
-                    int instancecount,
-                    uint baseinstance
-        )
-        {
-            fixed (IntPtr* indicesPtr = indices) {
-                _context->glDrawElementsInstancedBaseInstance(mode, count, (uint)type, indicesPtr,
-                                                              instancecount, baseinstance);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void DrawElementsInstancedBaseVertexBaseInstance(
-                    uint mode,
-                    int count,
-                    ShaderType type,
-                    ReadOnlySpan<IntPtr> indices,
-                    int instancecount,
-                    int basevertex,
-                    uint baseinstance
-        )
-        {
-            fixed (IntPtr* indicesPtr = indices) {
-                _context->glDrawElementsInstancedBaseVertexBaseInstance(mode, count, (uint)type,
-                                                                        indicesPtr, instancecount,
-                                                                        basevertex, baseinstance);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void DrawTransformFeedbackInstanced(
-                    uint mode,
-                    uint id,
-                    int instancecount
-        )
-        {
-            _context->glDrawTransformFeedbackInstanced(mode, id, instancecount);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void DrawTransformFeedbackStreamInstanced(
-                    uint mode,
-                    uint id,
-                    uint stream,
-                    int instancecount
-        )
-        {
-            _context->glDrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void GetActiveAtomicCounterBufferiv(
-                    GlHandle program,
-                    GlHandle bufferIndex,
-                    uint pname,
-                    int* @params
-        )
-        {
-            _context->glGetActiveAtomicCounterBufferiv(program.Value, bufferIndex.Value, pname,
-                                                       @params);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void GetInternalformativ(
-                    uint target,
-                    uint internalformat,
-                    uint pname,
-                    int count,
-                    int* @params
-        )
-        {
-            _context->glGetInternalformativ(target, internalformat, pname, count, @params);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void MemoryBarrier(
-                    uint barriers
-        )
-        {
-            _context->glMemoryBarrier(barriers);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void TexStorage1D(
-                    uint target,
-                    int levels,
-                    uint internalformat,
-                    int width
-        )
-        {
-            _context->glTexStorage1D(target, levels, internalformat, width);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void TexStorage2D(
-                    uint target,
-                    int levels,
-                    uint internalformat,
-                    int width,
-                    int height
-        )
-        {
-            _context->glTexStorage2D(target, levels, internalformat, width, height);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void TexStorage3D(
-                    uint target,
-                    int levels,
-                    uint internalformat,
-                    int width,
-                    int height,
-                    int depth
-        )
-        {
-            _context->glTexStorage3D(target, levels, internalformat, width, height, depth);
-        }
-
-    }
-}

src/StgSharp.Graphics/OpenGL/glFunction.v4_3.cs

@@ -1,564 +0,0 @@
-// -----------------------------------------------------------------------------
-// file="glFunction.v4_3"
-// Project: StgSharp
-// Copyright (c) Nitload.
-// SPDX-License-Identifier: MIT
-// -----------------------------------------------------------------------------
-
-using StgSharp.Graphics.OpenGL;
-using System;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace StgSharp.Graphics.OpenGL
-{
-    public unsafe partial class OpenGLFunction
-    {
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void BindVertexBuffer(
-                    uint bindingindex,
-                    GlHandle buffer,
-                    nint offset,
-                    int stride
-        )
-        {
-            _context->glBindVertexBuffer(bindingindex, buffer.Value, offset, stride);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void ClearBufferData(
-                    uint target,
-                    uint internalformat,
-                    uint format,
-                    ShaderType type,
-                    ReadOnlySpan<IntPtr> data
-        )
-        {
-            fixed (IntPtr* dataPtr = data) {
-                _context->glClearBufferData(target, internalformat, format, (uint)type, dataPtr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void ClearBufferSubData(
-                    uint target,
-                    uint internalformat,
-                    nint offset,
-                    nuint size,
-                    uint format,
-                    ShaderType type,
-                    ReadOnlySpan<IntPtr> data
-        )
-        {
-            fixed (IntPtr* dataPtr = data) {
-                _context->glClearBufferSubData(target, internalformat, offset, size, format,
-                                               (uint)type, dataPtr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void CopyImageSubData(
-                    uint srcName,
-                    uint srcTarget,
-                    int srcLevel,
-                    int srcX,
-                    int srcY,
-                    int srcZ,
-                    uint dstName,
-                    uint dstTarget,
-                    int dstLevel,
-                    int dstX,
-                    int dstY,
-                    int dstZ,
-                    int srcWidth,
-                    int srcHeight,
-                    int srcDepth
-        )
-        {
-            _context->glCopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName,
-                                         dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight,
-                                         srcDepth);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void DebugMessageCallback(
-                    IntPtr callback,
-                    ReadOnlySpan<IntPtr> userParam
-        )
-        {
-            fixed (IntPtr* userParamPtr = userParam) {
-                _context->glDebugMessageCallback(callback, userParamPtr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void DebugMessageControl(
-                    uint source,
-                    ShaderType type,
-                    uint severity,
-                    int count,
-                    ReadOnlySpan<uint> ids,
-                    byte enabled
-        )
-        {
-            fixed (uint* idsPtr = ids) {
-                _context->glDebugMessageControl(source, (uint)type, severity, count, idsPtr,
-                                                enabled);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void DebugMessageInsert(
-                    uint source,
-                    ShaderType type,
-                    uint id,
-                    uint severity,
-                    int length,
-                    ReadOnlySpan<byte> buf
-        )
-        {
-            fixed (byte* bufPtr = buf) {
-                _context->glDebugMessageInsert(source, (uint)type, id, severity, length, bufPtr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void DispatchCompute(
-                    uint num_groups_x,
-                    uint num_groups_y,
-                    uint num_groups_z
-        )
-        {
-            _context->glDispatchCompute(num_groups_x, num_groups_y, num_groups_z);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void DispatchComputeIndirect(
-                    nint indirect
-        )
-        {
-            _context->glDispatchComputeIndirect(indirect);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void FramebufferParameteri(
-                    uint target,
-                    uint pname,
-                    int param
-        )
-        {
-            _context->glFramebufferParameteri(target, pname, param);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public uint GetDebugMessageLog(
-                    uint count,
-                    int bufSize,
-                    uint* sources,
-                    uint* types,
-                    uint* ids,
-                    uint* severities,
-                    int* lengths,
-                    byte* messageLog
-        )
-        {
-            return _context->glGetDebugMessageLog(count, bufSize, sources, types, ids, severities,
-                                                  lengths, messageLog);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void GetFramebufferParameteriv(
-                    uint target,
-                    uint pname,
-                    int* @params
-        )
-        {
-            _context->glGetFramebufferParameteriv(target, pname, @params);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void GetInternalformati64v(
-                    uint target,
-                    uint internalformat,
-                    uint pname,
-                    int count,
-                    IntPtr* @params
-        )
-        {
-            _context->glGetInternalformati64v(target, internalformat, pname, count, @params);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void GetObjectLabel(
-                    uint identifier,
-                    uint name,
-                    int bufSize,
-                    int* length,
-                    byte* label
-        )
-        {
-            _context->glGetObjectLabel(identifier, name, bufSize, length, label);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void GetObjectPtrLabel(
-                    ReadOnlySpan<IntPtr> ptr,
-                    int bufSize,
-                    int* length,
-                    byte* label
-        )
-        {
-            fixed (IntPtr* ptrPtr = ptr) {
-                _context->glGetObjectPtrLabel(ptrPtr, bufSize, length, label);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void GetProgramInterfaceiv(
-                    GlHandle program,
-                    uint programInterface,
-                    uint pname,
-                    int* @params
-        )
-        {
-            _context->glGetProgramInterfaceiv(program.Value, programInterface, pname, @params);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public uint GetProgramResourceIndex(
-                    GlHandle program,
-                    uint programInterface,
-                    ReadOnlySpan<byte> name
-        )
-        {
-            fixed (byte* namePtr = name) {
-                return _context->glGetProgramResourceIndex(program.Value, programInterface, namePtr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void GetProgramResourceiv(
-                    GlHandle program,
-                    uint programInterface,
-                    uint index,
-                    int propCount,
-                    ReadOnlySpan<uint> props,
-                    int count,
-                    int* length,
-                    int* @params
-        )
-        {
-            fixed (uint* propsPtr = props) {
-                _context->glGetProgramResourceiv(program.Value, programInterface, index, propCount,
-                                                 propsPtr, count, length, @params);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public int GetProgramResourceLocation(
-                   GlHandle program,
-                   uint programInterface,
-                   ReadOnlySpan<byte> name
-        )
-        {
-            fixed (byte* namePtr = name) {
-                return _context->glGetProgramResourceLocation(program.Value, programInterface, namePtr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public int GetProgramResourceLocationIndex(
-                   GlHandle program,
-                   uint programInterface,
-                   ReadOnlySpan<byte> name
-        )
-        {
-            fixed (byte* namePtr = name) {
-                return _context->glGetProgramResourceLocationIndex(program.Value, programInterface, namePtr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void GetProgramResourceName(
-                    GlHandle program,
-                    uint programInterface,
-                    uint index,
-                    int bufSize,
-                    int* length,
-                    byte* name
-        )
-        {
-            _context->glGetProgramResourceName(program.Value, programInterface, index, bufSize,
-                                               length, name);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void InvalidateBufferData(
-                    GlHandle buffer
-        )
-        {
-            _context->glInvalidateBufferData(buffer.Value);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void InvalidateBufferSubData(
-                    GlHandle buffer,
-                    nint offset,
-                    nuint length
-        )
-        {
-            _context->glInvalidateBufferSubData(buffer.Value, offset, length);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void InvalidateFramebuffer(
-                    uint target,
-                    int numAttachments,
-                    ReadOnlySpan<uint> attachments
-        )
-        {
-            fixed (uint* attachmentsPtr = attachments) {
-                _context->glInvalidateFramebuffer(target, numAttachments, attachmentsPtr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void InvalidateSubFramebuffer(
-                    uint target,
-                    int numAttachments,
-                    ReadOnlySpan<uint> attachments,
-                    int x,
-                    int y,
-                    int width,
-                    int height
-        )
-        {
-            fixed (uint* attachmentsPtr = attachments) {
-                _context->glInvalidateSubFramebuffer(target, numAttachments, attachmentsPtr, x, y,
-                                                     width, height);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void InvalidateTexImage(
-                    GlHandle texture,
-                    int level
-        )
-        {
-            _context->glInvalidateTexImage(texture.Value, level);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void InvalidateTexSubImage(
-                    GlHandle texture,
-                    int level,
-                    int xoffset,
-                    int yoffset,
-                    int zoffset,
-                    int width,
-                    int height,
-                    int depth
-        )
-        {
-            _context->glInvalidateTexSubImage(texture.Value, level, xoffset, yoffset, zoffset,
-                                              width, height, depth);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void MultiDrawArraysIndirect(
-                    uint mode,
-                    ReadOnlySpan<IntPtr> indirect,
-                    int drawcount,
-                    int stride
-        )
-        {
-            fixed (IntPtr* indirectPtr = indirect) {
-                _context->glMultiDrawArraysIndirect(mode, indirectPtr, drawcount, stride);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void MultiDrawElementsIndirect(
-                    uint mode,
-                    ShaderType type,
-                    ReadOnlySpan<IntPtr> indirect,
-                    int drawcount,
-                    int stride
-        )
-        {
-            fixed (IntPtr* indirectPtr = indirect) {
-                _context->glMultiDrawElementsIndirect(mode, (uint)type, indirectPtr, drawcount,
-                                                      stride);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void ObjectLabel(
-                    uint identifier,
-                    uint name,
-                    int length,
-                    ReadOnlySpan<byte> label
-        )
-        {
-            fixed (byte* labelPtr = label) {
-                _context->glObjectLabel(identifier, name, length, labelPtr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void ObjectPtrLabel(
-                    ReadOnlySpan<IntPtr> ptr,
-                    int length,
-                    ReadOnlySpan<byte> label
-        )
-        {
-            fixed (IntPtr* ptrPtr = ptr)
-            {
-                fixed (byte* labelPtr = label) {
-                    _context->glObjectPtrLabel(ptrPtr, length, labelPtr);
-                }
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void PopDebugGroup()
-        {
-            _context->glPopDebugGroup();
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void PushDebugGroup(
-                    uint source,
-                    uint id,
-                    int length,
-                    ReadOnlySpan<byte> message
-        )
-        {
-            fixed (byte* messagePtr = message) {
-                _context->glPushDebugGroup(source, id, length, messagePtr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void ShaderStorageBlockBinding(
-                    GlHandle program,
-                    uint storageBlockIndex,
-                    uint storageBlockBinding
-        )
-        {
-            _context->glShaderStorageBlockBinding(program.Value, storageBlockIndex, storageBlockBinding);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void TexBufferRange(
-                    uint target,
-                    uint internalformat,
-                    GlHandle buffer,
-                    nint offset,
-                    nuint size
-        )
-        {
-            _context->glTexBufferRange(target, internalformat, buffer.Value, offset, size);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void TexStorage2DMultisample(
-                    uint target,
-                    int samples,
-                    uint internalformat,
-                    int width,
-                    int height,
-                    byte fixedsamplelocations
-        )
-        {
-            _context->glTexStorage2DMultisample(target, samples, internalformat, width, height,
-                                                fixedsamplelocations);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void TexStorage3DMultisample(
-                    uint target,
-                    int samples,
-                    uint internalformat,
-                    int width,
-                    int height,
-                    int depth,
-                    byte fixedsamplelocations
-        )
-        {
-            _context->glTexStorage3DMultisample(target, samples, internalformat, width, height,
-                                                depth, fixedsamplelocations);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void TextureView(
-                    GlHandle texture,
-                    uint target,
-                    GlHandle origtexture,
-                    uint internalformat,
-                    uint minlevel,
-                    uint numlevels,
-                    uint minlayer,
-                    uint numlayers
-        )
-        {
-            _context->glTextureView(texture.Value, target, origtexture.Value, internalformat,
-                                    minlevel, numlevels, minlayer, numlayers);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void VertexAttribBinding(
-                    uint attribindex,
-                    uint bindingindex
-        )
-        {
-            _context->glVertexAttribBinding(attribindex, bindingindex);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void VertexAttribFormat(
-                    uint attribindex,
-                    int size,
-                    ShaderType type,
-                    byte normalized,
-                    uint relativeoffset
-        )
-        {
-            _context->glVertexAttribFormat(attribindex, size, (uint)type, normalized,
-                                           relativeoffset);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void VertexAttribIFormat(
-                    uint attribindex,
-                    int size,
-                    ShaderType type,
-                    uint relativeoffset
-        )
-        {
-            _context->glVertexAttribIFormat(attribindex, size, (uint)type, relativeoffset);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void VertexAttribLFormat(
-                    uint attribindex,
-                    int size,
-                    ShaderType type,
-                    uint relativeoffset
-        )
-        {
-            _context->glVertexAttribLFormat(attribindex, size, (uint)type, relativeoffset);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void VertexBindingDivisor(
-                    uint bindingindex,
-                    uint divisor
-        )
-        {
-            _context->glVertexBindingDivisor(bindingindex, divisor);
-        }
-
-    }
-}

src/StgSharp.Graphics/OpenGL/glFunction.v4_4.cs

@@ -1,159 +0,0 @@
-// -----------------------------------------------------------------------------
-// file="glFunction.v4_4"
-// Project: StgSharp
-// Copyright (c) Nitload.
-// SPDX-License-Identifier: MIT
-// -----------------------------------------------------------------------------
-
-using StgSharp.Graphics.OpenGL;
-using System;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace StgSharp.Graphics.OpenGL
-{
-    public unsafe partial class OpenGLFunction
-    {
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void BindBuffersBase(
-                    uint target,
-                    uint first,
-                    int count,
-                    ReadOnlySpan<uint> buffers
-        )
-        {
-            fixed (uint* buffersPtr = buffers) {
-                _context->glBindBuffersBase(target, first, count, buffersPtr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void BindBuffersRange(
-                    uint target,
-                    uint first,
-                    int count,
-                    ReadOnlySpan<uint> buffers,
-                    ReadOnlySpan<nint> offsets,
-                    ReadOnlySpan<nuint> sizes
-        )
-        {
-            fixed (uint* buffersPtr = buffers)
-            {
-                fixed (nint* offsetsPtr = offsets)
-                {
-                    fixed (nuint* sizesPtr = sizes) {
-                        _context->glBindBuffersRange(target, first, count, buffersPtr, offsetsPtr,
-                                                     sizesPtr);
-                    }
-                }
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void BindImageTextures(
-                    uint first,
-                    int count,
-                    ReadOnlySpan<uint> textures
-        )
-        {
-            fixed (uint* texturesPtr = textures) {
-                _context->glBindImageTextures(first, count, texturesPtr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void BindSamplers(
-                    uint first,
-                    int count,
-                    ReadOnlySpan<uint> samplers
-        )
-        {
-            fixed (uint* samplersPtr = samplers) {
-                _context->glBindSamplers(first, count, samplersPtr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void BindTextures(
-                    uint first,
-                    int count,
-                    ReadOnlySpan<uint> textures
-        )
-        {
-            fixed (uint* texturesPtr = textures) {
-                _context->glBindTextures(first, count, texturesPtr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void BindVertexBuffers(
-                    uint first,
-                    int count,
-                    ReadOnlySpan<uint> buffers,
-                    ReadOnlySpan<nint> offsets,
-                    ReadOnlySpan<int> strides
-        )
-        {
-            fixed (uint* buffersPtr = buffers)
-            {
-                fixed (nint* offsetsPtr = offsets)
-                {
-                    fixed (int* stridesPtr = strides) {
-                        _context->glBindVertexBuffers(first, count, buffersPtr, offsetsPtr,
-                                                      stridesPtr);
-                    }
-                }
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void BufferStorage(
-                    uint target,
-                    nuint size,
-                    ReadOnlySpan<IntPtr> data,
-                    uint flags
-        )
-        {
-            fixed (IntPtr* dataPtr = data) {
-                _context->glBufferStorage(target, size, dataPtr, flags);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void ClearTexImage(
-                    GlHandle texture,
-                    int level,
-                    uint format,
-                    ShaderType type,
-                    ReadOnlySpan<IntPtr> data
-        )
-        {
-            fixed (IntPtr* dataPtr = data) {
-                _context->glClearTexImage(texture.Value, level, format, (uint)type, dataPtr);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void ClearTexSubImage(
-                    GlHandle texture,
-                    int level,
-                    int xoffset,
-                    int yoffset,
-                    int zoffset,
-                    int width,
-                    int height,
-                    int depth,
-                    uint format,
-                    ShaderType type,
-                    ReadOnlySpan<IntPtr> data
-        )
-        {
-            fixed (IntPtr* dataPtr = data) {
-                _context->glClearTexSubImage(texture.Value, level, xoffset, yoffset, zoffset, width,
-                                             height, depth, format, (uint)type, dataPtr);
-            }
-        }
-
-    }
-}

src/StgSharp.Graphics/OpenGL/glFunction.v4_6.cs

@@ -1,82 +0,0 @@
-// -----------------------------------------------------------------------------
-// file="glFunction.v4_6"
-// Project: StgSharp
-// Copyright (c) Nitload.
-// SPDX-License-Identifier: MIT
-// -----------------------------------------------------------------------------
-
-using StgSharp.Graphics.OpenGL;
-using System;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace StgSharp.Graphics.OpenGL
-{
-    public unsafe partial class OpenGLFunction
-    {
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void MultiDrawArraysIndirectCount(
-                    uint mode,
-                    ReadOnlySpan<IntPtr> indirect,
-                    nint drawcount,
-                    int maxdrawcount,
-                    int stride
-        )
-        {
-            fixed (IntPtr* indirectPtr = indirect) {
-                _context->glMultiDrawArraysIndirectCount(mode, indirectPtr, drawcount, maxdrawcount,
-                                                         stride);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void MultiDrawElementsIndirectCount(
-                    uint mode,
-                    ShaderType type,
-                    ReadOnlySpan<IntPtr> indirect,
-                    nint drawcount,
-                    int maxdrawcount,
-                    int stride
-        )
-        {
-            fixed (IntPtr* indirectPtr = indirect) {
-                _context->glMultiDrawElementsIndirectCount(mode, (uint)type, indirectPtr, drawcount,
-                                                           maxdrawcount, stride);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void PolygonOffsetClamp(
-                    float factor,
-                    float units,
-                    float clamp
-        )
-        {
-            _context->glPolygonOffsetClamp(factor, units, clamp);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SpecializeShader(
-                    GlHandle shader,
-                    ReadOnlySpan<byte> pEntryPoint,
-                    uint numSpecializationConstants,
-                    ReadOnlySpan<uint> pConstantIndex,
-                    ReadOnlySpan<uint> pConstantValue
-        )
-        {
-            fixed (byte* pEntryPointPtr = pEntryPoint)
-            {
-                fixed (uint* pConstantIndexPtr = pConstantIndex)
-                {
-                    fixed (uint* pConstantValuePtr = pConstantValue) {
-                        _context->glSpecializeShader(shader.Value, pEntryPointPtr,
-                                                     numSpecializationConstants, pConstantIndexPtr,
-                                                     pConstantValuePtr);
-                    }
-                }
-            }
-        }
-
-    }
-}

src/StgSharp.Graphics/glfw.cs

@@ -1087,8 +1087,6 @@ namespace StgSharp.Graphics
             return _glfw.glfwGetRequiredInstanceExtensions(count);
         }
 
+        #endregion
     }
 }
-
-#endregion
-