Daily update on 20251230-224423 by Nitload Youmu. Additional Message : Adding compute support for mat<double>. Import all opengl core profile fucntions

Signed-off-by: Nitload <YoumuLiu_NSI@whv0t.onmicrosoft.com>

GenerateGL.sln

@@ -0,0 +1,37 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.14.36705.20
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GenerateGL", "StgSharp.GenerateGL\GenerateGL.csproj", "{9FD27EE6-E94D-4E64-A13B-5A349DEA215A}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "StgSharp.Common", "StgSharp.Common\StgSharp.Common.csproj", "{5D646C0E-CCF8-B5B4-7DE8-1C37542E7B4D}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Debug|x64 = Debug|x64
+		Release|Any CPU = Release|Any CPU
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{9FD27EE6-E94D-4E64-A13B-5A349DEA215A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{9FD27EE6-E94D-4E64-A13B-5A349DEA215A}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{9FD27EE6-E94D-4E64-A13B-5A349DEA215A}.Debug|x64.ActiveCfg = Debug|x64
+		{9FD27EE6-E94D-4E64-A13B-5A349DEA215A}.Debug|x64.Build.0 = Debug|x64
+		{9FD27EE6-E94D-4E64-A13B-5A349DEA215A}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{9FD27EE6-E94D-4E64-A13B-5A349DEA215A}.Release|Any CPU.Build.0 = Release|Any CPU
+		{9FD27EE6-E94D-4E64-A13B-5A349DEA215A}.Release|x64.ActiveCfg = Release|x64
+		{9FD27EE6-E94D-4E64-A13B-5A349DEA215A}.Release|x64.Build.0 = Release|x64
+		{5D646C0E-CCF8-B5B4-7DE8-1C37542E7B4D}.Debug|Any CPU.ActiveCfg = Debug|x64
+		{5D646C0E-CCF8-B5B4-7DE8-1C37542E7B4D}.Debug|x64.ActiveCfg = Debug|x64
+		{5D646C0E-CCF8-B5B4-7DE8-1C37542E7B4D}.Release|Any CPU.ActiveCfg = Release|x64
+		{5D646C0E-CCF8-B5B4-7DE8-1C37542E7B4D}.Release|x64.ActiveCfg = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {AC71C01F-9867-4E43-85AB-4A8A7896B1BC}
+	EndGlobalSection
+EndGlobal

StgSharp.Common/Collections/StringHashMultiplexer.cs

@@ -1,4 +1,4 @@
-//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 // file="StringHashMultiplexer"
 // Project: StgSharp
@@ -71,7 +71,7 @@ namespace StgSharp.Collections
         {
             int hash;
             fixed (char* cPtr = obj.AsSpan()) {
-                hash = NativeIntrinsic.Intrinsic.city_hash_simplify(cPtr, obj.Length);
+                hash = NativeIntrinsic.Context.city_hash_simplify(cPtr, obj.Length);
             }
             return hash;
         }
@@ -136,7 +136,7 @@ namespace StgSharp.Collections
         {
             int hash;
             fixed (char* cPtr = obj.AsSpan()) {
-                hash = NativeIntrinsic.Intrinsic.city_hash_simplify(cPtr, obj.Length);
+                hash = NativeIntrinsic.Context.city_hash_simplify(cPtr, obj.Length);
             }
             return hash;
         }

StgSharp.Common/Graphics/OpenGL/Buffer/TextureGL.cs

@@ -1,4 +1,4 @@
-//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 // file="TextureGL"
 // Project: StgSharp
@@ -44,14 +44,19 @@ namespace StgSharp.Graphics.OpenGL
         private OpenGLFunction _gl;
         internal GlHandle[] _textureHandle;
 
-        internal TextureGL(int count, glRender binding)
+        internal TextureGL(
+                 int count,
+                 glRender binding
+        )
         {
             // sourceList = new Image[count];
             this._gl = binding.GL;
             _textureHandle = _gl.GenTextures(count);
         }
 
-        public GlHandle this[int index]
+        public GlHandle this[
+                        int index
+        ]
         {
             get => _textureHandle[index];
         }
@@ -70,12 +75,16 @@ namespace StgSharp.Graphics.OpenGL
 
         internal OpenGLFunction GL => _gl;
 
-        public void ActivateAs(TextureUnit unit)
+        public void ActivateAs(
+                    TextureUnit unit
+        )
         {
             _gl.ActiveTextureUnit((uint)unit);
         }
 
-        public void Bind2D(int index)
+        public void Bind2D(
+                    int index
+        )
         {
             currentEditingTextureIndex = index;
             _gl.BindTexture(glConst.TEXTURE_2D, _textureHandle[index]);
@@ -90,19 +99,25 @@ namespace StgSharp.Graphics.OpenGL
         /// <param _label="i">
         ///
         /// </param>
-        public unsafe void LoadTexture(int index, Image i)
+        public unsafe void LoadTexture(
+                           int index,
+                           Image i
+        )
         {
             byte[] handle = i.PixelBuffer;
-            _gl.TextureImage2d(
-                Texture2DTarget.Texture2D, 0, i.Channel, (uint)i.Width, (uint)i.Height, i.Channel, i.PixelLayout,
-                pixels:handle);
+            _gl.TextureImage2d(Texture2DTarget.Texture2D, 0, i.Channel, i.Width, i.Height,
+                               i.Channel, i.PixelLayout, pixels:handle);
             _gl.GenerateMipmap(Texture2DTarget.Texture2D);
         }
 
         #region texture setting
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Set2dFilterProperty(int index, TextureFilter onMinify, TextureFilter onMagnify)
+        public void Set2dFilterProperty(
+                    int index,
+                    TextureFilter onMinify,
+                    TextureFilter onMagnify
+        )
         {
             #if DEBUG
             if (index != currentEditingTextureIndex)
@@ -117,7 +132,11 @@ namespace StgSharp.Graphics.OpenGL
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Set2dWrapProperty(int index, TextureWrap onHorizontial, TextureWrap onVertical)
+        public void Set2dWrapProperty(
+                    int index,
+                    TextureWrap onHorizontial,
+                    TextureWrap onVertical
+        )
         {
             #if DEBUG
             if (index != currentEditingTextureIndex)
@@ -132,7 +151,10 @@ namespace StgSharp.Graphics.OpenGL
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Set2dProperty(int index, TextureProperty property)
+        public void Set2dProperty(
+                    int index,
+                    TextureProperty property
+        )
         {
             Set2dFilterProperty(index, property.FilterOnMinify, property.FilterOnMagnify);
             Set2dWrapProperty(index, property.WrapOnHorizontial, property.WrapOnVertical);
@@ -156,7 +178,8 @@ namespace StgSharp.Graphics.OpenGL
                TextureFilter onMagnify,
                TextureFilter onMinify,
                TextureWrap onHorizontial,
-               TextureWrap onVertical)
+               TextureWrap onVertical
+        )
         {
             FilterOnMagnify = onMagnify;
             FilterOnMinify = onMinify;
@@ -188,15 +211,17 @@ namespace StgSharp.Graphics.OpenGL
             set => vert = value;
         }
 
-        public override bool Equals([NotNullWhen(true)] object obj)
+        public override bool Equals(
+                             [NotNullWhen(true)] object obj
+        )
         {
             return base.Equals(obj);
         }
 
         public override int GetHashCode()
         {
-            return HashCode.Combine(
-                FilterOnMagnify, FilterOnMagnify, WrapOnHorizontial, WrapOnVertical);
+            return HashCode.Combine(FilterOnMagnify, FilterOnMagnify, WrapOnHorizontial,
+                                    WrapOnVertical);
         }
 
         public override string ToString()
@@ -204,12 +229,18 @@ namespace StgSharp.Graphics.OpenGL
             return $"FilterOnMagnify:{FilterOnMagnify}, " + $"FilterOnMagnify:{FilterOnMagnify}, " + $"WrapOnHorizontial:{WrapOnHorizontial}, " + $"WrapOnVertical:{WrapOnVertical}";
         }
 
-        public static bool operator !=(TextureProperty left, TextureProperty right)
+        public static bool operator !=(
+                                    TextureProperty left,
+                                    TextureProperty right
+        )
         {
             return left.mask != right.mask;
         }
 
-        public static bool operator ==(TextureProperty left, TextureProperty right)
+        public static bool operator ==(
+                                    TextureProperty left,
+                                    TextureProperty right
+        )
         {
             return left.mask == right.mask;
         }
@@ -218,11 +249,12 @@ namespace StgSharp.Graphics.OpenGL
                                         (
             TextureFilter onMagnify, TextureFilter onMinify,
             TextureWrap onHorizontial, TextureWrap onVertical
-            ) propertyValueTuple)
+            ) propertyValueTuple
+        )
         {
-            return new TextureProperty(
-                propertyValueTuple.onMagnify, propertyValueTuple.onMinify,
-                propertyValueTuple.onHorizontial, propertyValueTuple.onVertical);
+            return new TextureProperty(propertyValueTuple.onMagnify, propertyValueTuple.onMinify,
+                                       propertyValueTuple.onHorizontial,
+                                       propertyValueTuple.onVertical);
         }
 
     }

StgSharp.Common/Graphics/OpenGL/Buffer/VAO.cs

@@ -1,4 +1,4 @@
-//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 // file="VAO"
 // Project: StgSharp
@@ -36,14 +36,19 @@ namespace StgSharp.Graphics.OpenGL
     public sealed unsafe class VertexArray : GlBufferObjectBase
     {
 
-        internal VertexArray(int n, glRender binding)
+        internal VertexArray(
+                 int n,
+                 glRender binding
+        )
             : base(binding)
         {
             _bufferHandle = GL.GenVertexArrays(n);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public sealed override void Bind(int index)
+        public sealed override void Bind(
+                                    int index
+        )
         {
             GL.BindVertexArray(_bufferHandle[index]);
         }
@@ -60,13 +65,17 @@ namespace StgSharp.Graphics.OpenGL
                     int vertexLength,
                     TypeCode dataType,
                     bool isNomalized,
-                    uint stride,
-                    int pointer)
+                    int stride,
+                    int pointer
+        )
         {
-            GL.SetVertexAttribute(attributeIndex, vertexLength, dataType, isNomalized, stride, pointer);
+            GL.SetVertexAttribute(attributeIndex, vertexLength, dataType, isNomalized, stride,
+                                  pointer);
         }
 
-        protected sealed override void Dispose(bool disposing)
+        protected sealed override void Dispose(
+                                       bool disposing
+        )
         {
             if (disposing) {
                 GL.DeleteVertexArrays(_bufferHandle);

StgSharp.Common/Graphics/OpenGL/ShaderEdit/Shader.cs

@@ -1,4 +1,4 @@
-//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 // file="Shader"
 // Project: StgSharp
@@ -56,7 +56,10 @@ namespace StgSharp.Graphics.OpenGL
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        protected sealed override Shader CreateShaderSegment(ShaderType type, int count)
+        protected sealed override Shader CreateShaderSegment(
+                                         ShaderType type,
+                                         int count
+        )
         {
             return new Shader(GL.CreateShaderSet(count, type), type, this);
         }
@@ -70,7 +73,11 @@ namespace StgSharp.Graphics.OpenGL
         internal readonly GlHandle[] handle;
         public readonly ShaderType type;
 
-        internal unsafe Shader(GlHandle[] handle, ShaderType usage, glRender stream)
+        internal unsafe Shader(
+                        GlHandle[] handle,
+                        ShaderType usage,
+                        glRender stream
+        )
         {
             this.handle = handle;
             GL = stream.GL;
@@ -89,12 +96,18 @@ namespace StgSharp.Graphics.OpenGL
         ///   Index of shader code in current shader code set.
         /// </param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void AttachTo(int index, [NotNull]ShaderProgram target)
+        public void AttachTo(
+                    int index,
+                    [NotNull]ShaderProgram target
+        )
         {
             GL.AttachShader(target.handle, handle[index]);
         }
 
-        public void CheckStatus(int index, ShaderStatus status)
+        public void CheckStatus(
+                    int index,
+                    ShaderStatus status
+        )
         {
             string log = GL.GetShaderStatus(this, index, (int)status);
             if (!string.IsNullOrEmpty(log)) {
@@ -103,7 +116,10 @@ namespace StgSharp.Graphics.OpenGL
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void Compile(int index, ReadOnlySpan<byte> codeU8Stream)
+        public unsafe void Compile(
+                           int index,
+                           ReadOnlySpan<byte> codeU8Stream
+        )
         {
             GL.LoadShaderSource(handle[index], codeU8Stream);
             GL.CompileShader(handle[index]);
@@ -111,7 +127,10 @@ namespace StgSharp.Graphics.OpenGL
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void Compile(int index, byte[] codeStream)
+        public unsafe void Compile(
+                           int index,
+                           byte[] codeStream
+        )
         {
             ArgumentNullException.ThrowIfNull(codeStream);
             GL.LoadShaderSource(handle[index], codeStream);
@@ -120,7 +139,10 @@ namespace StgSharp.Graphics.OpenGL
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void Compile(int index, string codeStream)
+        public unsafe void Compile(
+                           int index,
+                           string codeStream
+        )
         {
             ArgumentNullException.ThrowIfNull(codeStream);
             GL.LoadShaderSource(handle[index], codeStream.AsSpan());
@@ -128,12 +150,16 @@ namespace StgSharp.Graphics.OpenGL
             CheckStatus(index, ShaderStatus.CompileStatus);
         }
 
-        public void FromBytes(byte[] stream)
+        public void FromBytes(
+                    byte[] stream
+        )
         {
             throw new NotImplementedException();
         }
 
-        public static byte[] FromCodeFile(string fileRoute)
+        public static byte[] FromCodeFile(
+                             string fileRoute
+        )
         {
             string str = File.ReadAllText(fileRoute);
             if (string.IsNullOrEmpty(str)) {
@@ -147,7 +173,9 @@ namespace StgSharp.Graphics.OpenGL
             return Array.Empty<byte>();
         }
 
-        public byte[] GetBytes(out int length)
+        public byte[] GetBytes(
+                      out int length
+        )
         {
             throw new NotImplementedException();
         }
@@ -175,7 +203,9 @@ namespace StgSharp.Graphics.OpenGL
         /// <summary>
         ///   CustomizeInit a program with no shader attached.
         /// </summary>
-        internal unsafe ShaderProgram(glRender binding)
+        internal unsafe ShaderProgram(
+                        glRender binding
+        )
         {
             GL = binding.GL;
             handle = GL.CreateProgram();
@@ -191,7 +221,9 @@ namespace StgSharp.Graphics.OpenGL
         ///
         /// </returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe Uniform<T> GetUniform<T>(string name) where T: unmanaged
+        public unsafe Uniform<T> GetUniform<T>(
+                                 string name
+        ) where T : unmanaged
         {
             return new Uniform<T>(GL.GetUniformLocation(this.handle, name));
         }
@@ -205,7 +237,9 @@ namespace StgSharp.Graphics.OpenGL
         /// <returns>
         ///
         /// </returns>
-        public unsafe Uniform<T, U> GetUniform<T, U>(string name) where T: unmanaged where U: struct
+        public unsafe Uniform<T, U> GetUniform<T, U>(
+                                    string name
+        ) where T : unmanaged where U : struct
         {
             return new Uniform<T, U>(GL.GetUniformLocation(this.handle, name));
         }
@@ -219,8 +253,9 @@ namespace StgSharp.Graphics.OpenGL
         /// <returns>
         ///
         /// </returns>
-        public unsafe Uniform<T, U, V> GetUniform<T, U, V>(string name) where T: unmanaged where U: struct
-            where V: struct
+        public unsafe Uniform<T, U, V> GetUniform<T, U, V>(
+                                       string name
+        ) where T : unmanaged where U : struct where V : struct
         {
             return new Uniform<T, U, V>(GL.GetUniformLocation(this.handle, name));
         }
@@ -234,9 +269,9 @@ namespace StgSharp.Graphics.OpenGL
         /// <returns>
         ///
         /// </returns>
-        public unsafe Uniform<T, U, V, W> GetUniform<T, U, V, W>(string name) where T: unmanaged where U: struct
-            where V: struct
-            where W: struct
+        public unsafe Uniform<T, U, V, W> GetUniform<T, U, V, W>(
+                                          string name
+        ) where T : unmanaged where U : struct where V : struct where W : struct
         {
             return new Uniform<T, U, V, W>(GL.GetUniformLocation(this.handle, name));
         }

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

@@ -1,4 +1,4 @@
-//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 // file="Uniform"
 // Project: StgSharp
@@ -41,17 +41,21 @@ namespace StgSharp.Graphics.OpenGL
 
     }
 
-    public sealed class Uniform<T> : Uniform where T: unmanaged
+    public sealed class Uniform<T> : Uniform where T : unmanaged
     {
 
         internal Uniform() { }
 
-        internal unsafe Uniform(GlHandle id)
+        internal unsafe Uniform(
+                        GlHandle id
+        )
         {
             this.id = id;
         }
 
-        internal static Uniform<T> FromHandle(GlHandle handle)
+        internal static Uniform<T> FromHandle(
+                                   GlHandle handle
+        )
         {
             return new Uniform<T>
             {
@@ -61,17 +65,21 @@ namespace StgSharp.Graphics.OpenGL
 
     }
 
-    public sealed class Uniform<T, U> : Uniform where T: unmanaged where U: struct
+    public sealed class Uniform<T, U> : Uniform where T : unmanaged where U : struct
     {
 
         internal Uniform() { }
 
-        internal unsafe Uniform(GlHandle id)
+        internal unsafe Uniform(
+                        GlHandle id
+        )
         {
             this.id = id;
         }
 
-        internal static Uniform<T, U> FromHandle(GlHandle handle)
+        internal static Uniform<T, U> FromHandle(
+                                      GlHandle handle
+        )
         {
             return new Uniform<T, U>
             {
@@ -81,17 +89,22 @@ namespace StgSharp.Graphics.OpenGL
 
     }
 
-    public sealed class Uniform<T, U, V> : Uniform where T: unmanaged where U: struct where V: struct
+    public sealed class Uniform<T, U, V> : Uniform where T : unmanaged where U : struct
+        where V : struct
     {
 
         internal Uniform() { }
 
-        internal unsafe Uniform(GlHandle id)
+        internal unsafe Uniform(
+                        GlHandle id
+        )
         {
             this.id = id;
         }
 
-        internal static Uniform<T, U, V> FromHandle(GlHandle handle)
+        internal static Uniform<T, U, V> FromHandle(
+                                         GlHandle handle
+        )
         {
             return new Uniform<T, U, V>
             {
@@ -101,17 +114,23 @@ namespace StgSharp.Graphics.OpenGL
 
     }
 
-    public sealed class Uniform<T, U, V, W> : Uniform where T: unmanaged where U: struct where V: struct where W: struct
+    public sealed class Uniform<T, U, V, W> : Uniform where T : unmanaged where U : struct
+        where V : struct
+        where W : struct
     {
 
         internal Uniform() { }
 
-        internal unsafe Uniform(GlHandle id)
+        internal unsafe Uniform(
+                        GlHandle id
+        )
         {
             this.id = id;
         }
 
-        internal static Uniform<T, U, V, W> FromHandle(GlHandle handle)
+        internal static Uniform<T, U, V, W> FromHandle(
+                                            GlHandle handle
+        )
         {
             return new Uniform<T, U, V, W>
             {
@@ -125,46 +144,67 @@ namespace StgSharp.Graphics.OpenGL
     {
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetUniformValue([NotNull] Uniform<Matrix44> uniform, Matrix44 mat)
+        public void SetUniformValue(
+                    [NotNull] Uniform<Matrix44> uniform,
+                    Matrix44 mat
+        )
         {
-            Matrix44 temp = mat;
-            Context.glUniformMatrix4fv(uniform.id.SignedValue, 1, false, (float*)&temp);
+            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)
+        public void SetUniformValue(
+                    [NotNull]Uniform<float, float, float, float> uniform,
+                    Vec4 vec
+        )
         {
-            Vec4 temp = vec;
-            Context.glUniform1fv(uniform.id.SignedValue, 4, &temp.reg);
+            Context.glUniform1fv(uniform.id.SignedValue, 4, (float*)&vec);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetUniformValue([NotNull]Uniform<Vec4> uniform, Vec4 vec)
+        public void SetUniformValue(
+                    [NotNull]Uniform<Vec4> uniform,
+                    Vec4 vec
+        )
         {
-            Vec4 temp = vec;
-            Context.glUniform1fv(uniform.id.SignedValue, 4, &temp.reg);
+            Context.glUniform1fv(uniform.id.SignedValue, 4, (float*)&vec);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetUniformValue([NotNull]Uniform<float> uniform, float v0)
+        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)
+        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)
+        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)
+        public void SetUniformValue(
+                    [NotNull] Uniform<float, float, float> uniform,
+                    float v0,
+                    float v1,
+                    float v2
+        )
         {
             Context.glUniform3f(uniform.id.SignedValue, v0, v1, v2);
         }
@@ -175,7 +215,8 @@ namespace StgSharp.Graphics.OpenGL
                     float v0,
                     float v1,
                     float v2,
-                    float v3)
+                    float v3
+        )
         {
             Context.glUniform4f(uniform.id.SignedValue, v0, v1, v2, v3);
         }

StgSharp.Common/Graphics/OpenGL/glApiManager.cs

@@ -1,4 +1,4 @@
-//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 // file="glApiManager"
 // Project: StgSharp
@@ -54,28 +54,6 @@ namespace StgSharp.Graphics.OpenGL
 
         private static string glExtensionList;
 
-        // --------------------------------------------------------------------------------
-
-        /// <summary>
-        ///   Get the function pointer of given OpenGL api _label
-        /// </summary>
-        /// <param _label="name">
-        ///   ContextName of the OpenGL api
-        /// </param>
-        /// <returns>
-        ///   The funtion pointer of the api in stream of <see cref="IntPtr" />
-        /// </returns>
-        public static IntPtr LoadGLfunc(string name)
-        {
-            IntPtr ret = GraphicFramework.glfwGetProcAddress(Encoding.UTF8.GetBytes(name));
-            if (ret == default)
-            {
-                DefaultLog.InternalAppendLog(
-                    $"Cannot load OpenGL api called {name}, this api may not exist or supported.");
-                return ret;
-            }
-            return ret;
-        }
 
         /// <summary>
         ///   Load all supported OpenGL APIs and bind them to given <see cref="ViewPort" />.
@@ -83,10 +61,12 @@ namespace StgSharp.Graphics.OpenGL
         /// <param _label="contextHandle">
         ///   The handle to current OpenGL viewPortDisplay
         /// </param>
-        public static unsafe void LoadOpenGLApiTo(IntPtr contextHandle)
+        public static unsafe void LoadOpenGLApiTo(
+                                  IntPtr contextHandle
+        )
         {
             OpenglContext* context = (OpenglContext*)contextHandle;
-            if ((IntPtr)context->glGetString != IntPtr.Zero) {
+            if (context->glGetString != null) {
                 return;
             }
             delegate*<ReadOnlySpan<byte>, IntPtr> loader = &GraphicFramework.glfwGetProcAddress;
@@ -96,15 +76,16 @@ namespace StgSharp.Graphics.OpenGL
                 #if DEBUG
                 Console.WriteLine("Cannot load GL.");
                 #endif
-                throw new Exception("Cannot load gl");
+                throw new NotSupportedException("Cannot load gl");
             }
-            context->glGetString = (delegate*<uint, IntPtr>)proc;
+            context->glGetString = (delegate*<uint, byte*>)proc;
 
             string coreVersion;
-            if (context->glGetString(glVersion) == IntPtr.Zero) {
+            if (context->glGetString(glVersion) == null) {
                 DefaultLog.InternalWriteLog("Failed to call glGetString", LogType.Error);
             }
-            coreVersion = Marshal.PtrToStringAnsi(context->glGetString(glVersion)) ?? string.Empty;
+            coreVersion = Marshal.PtrToStringAnsi((nint)context->glGetString(glVersion)) ??
+                string.Empty;
 
             foreach (string branch in glBranch)
             {
@@ -118,25 +99,25 @@ namespace StgSharp.Graphics.OpenGL
             CheckCoreVersion(majorVersion, minorVersion);
 
 
-            if (LoadGLcore10(context, loader) &&
-                LoadGLcore11(context, loader) &&
-                LoadGLcore12(context, loader) &&
-                LoadGLcore13(context, loader) &&
-                LoadGLcore14(context, loader) &&
-                LoadGLcore15(context, loader) &&
-                LoadGLcore20(context, loader) &&
-                LoadGLcore21(context, loader) &&
-                LoadGLcore30(context, loader) &&
-                LoadGLcore31(context, loader) &&
-                LoadGLcore32(context, loader) &&
-                LoadGLcore33(context, loader) &&
-                LoadGLcore40(context, loader) &&
-                LoadGLcore41(context, loader) &&
-                LoadGLcore42(context, loader) &&
-                LoadGLcore43(context, loader) &&
-                LoadGLcore44(context, loader) &&
-                LoadGLcore45(context, loader) &&
-                LoadGLcore46(context, loader)) { }
+            if (LoadGLcore10((glContextShadow*)context, loader) &&
+                LoadGLcore11((glContextShadow*)context, loader) &&
+                LoadGLcore12((glContextShadow*)context, loader) &&
+                LoadGLcore13((glContextShadow*)context, loader) &&
+                LoadGLcore14((glContextShadow*)context, loader) &&
+                LoadGLcore15((glContextShadow*)context, loader) &&
+                LoadGLcore20((glContextShadow*)context, loader) &&
+                LoadGLcore21((glContextShadow*)context, loader) &&
+                LoadGLcore30((glContextShadow*)context, loader) &&
+                LoadGLcore31((glContextShadow*)context, loader) &&
+                LoadGLcore32((glContextShadow*)context, loader) &&
+                LoadGLcore33((glContextShadow*)context, loader) &&
+                LoadGLcore40((glContextShadow*)context, loader) &&
+                LoadGLcore41((glContextShadow*)context, loader) &&
+                LoadGLcore42((glContextShadow*)context, loader) &&
+                LoadGLcore43((glContextShadow*)context, loader) &&
+                LoadGLcore44((glContextShadow*)context, loader) &&
+                LoadGLcore45((glContextShadow*)context, loader) &&
+                LoadGLcore46((glContextShadow*)context, loader)) { }
 
             uint code = context->glGetError();
             if (code != 0)
@@ -3267,7 +3248,10 @@ namespace StgSharp.Graphics.OpenGL
             #endregion checkGLextensions
         }
 
-        internal static void CheckCoreVersion(int majorVersion, int minorVersion)
+        internal static void CheckCoreVersion(
+                             int majorVersion,
+                             int minorVersion
+        )
         {
             if (majorVersion < 3) {
                 throw new InvalidOperationException(
@@ -3433,32 +3417,14 @@ namespace StgSharp.Graphics.OpenGL
             }
         }
 
-        internal static unsafe string GetExtensions(this OpenglContext context)
+        internal static unsafe string GetExtensions(
+                                      this OpenglContext context
+        )
         {
             if (context.glGetString == null) {
                 return string.Empty;
             }
-            return Marshal.PtrToStringAnsi(context.glGetString(glExtension))!;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal static T internalLoadAPI<T>(IntPtr ptr) where T: Delegate
-        {
-            try
-            {
-                if (ptr == IntPtr.Zero) {
-                    return null;
-                }
-                T func = Marshal.GetDelegateForFunctionPointer<T>(ptr);
-                return func;
-            }
-            catch (Exception ex)
-            {
-                DefaultLog.InternalWriteLog(
-                    $"{$"Failed to convert the api {typeof(T).Name}.\n"}{ex.Message}",
-                    LogType.Warning);
-                return default;
-            }
+            return Marshal.PtrToStringAnsi((nint)context.glGetString(glExtension))!;
         }
 
     }

StgSharp.Common/Graphics/OpenGL/glContextShadow.cs

@@ -0,0 +1,698 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="glContextShadow"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. All rights reserved.
+//     
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//     
+// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    internal struct glContextShadow
+    {
+
+        internal IntPtr glActiveShaderProgram;
+        internal IntPtr glActiveTexture;
+        internal IntPtr glAttachShader;
+        internal IntPtr glBeginConditionalRender;
+        internal IntPtr glBeginQuery;
+        internal IntPtr glBeginQueryIndexed;
+        internal IntPtr glBeginTransformFeedback;
+        internal IntPtr glBindAttribLocation;
+        internal IntPtr glBindBuffer;
+        internal IntPtr glBindBufferBase;
+        internal IntPtr glBindBufferRange;
+        internal IntPtr glBindBuffersBase;
+        internal IntPtr glBindBuffersRange;
+        internal IntPtr glBindFragDataLocation;
+        internal IntPtr glBindFragDataLocationIndexed;
+        internal IntPtr glBindFramebuffer;
+        internal IntPtr glBindImageTexture;
+        internal IntPtr glBindImageTextures;
+        internal IntPtr glBindProgramPipeline;
+        internal IntPtr glBindRenderbuffer;
+        internal IntPtr glBindSampler;
+        internal IntPtr glBindSamplers;
+        internal IntPtr glBindTexture;
+        internal IntPtr glBindTextures;
+        internal IntPtr glBindTextureUnit;
+        internal IntPtr glBindTransformFeedback;
+        internal IntPtr glBindVertexArray;
+        internal IntPtr glBindVertexBuffer;
+        internal IntPtr glBindVertexBuffers;
+        internal IntPtr glBlendColor;
+        internal IntPtr glBlendEquation;
+        internal IntPtr glBlendEquationi;
+        internal IntPtr glBlendEquationSeparate;
+        internal IntPtr glBlendEquationSeparatei;
+        internal IntPtr glBlendFunc;
+        internal IntPtr glBlendFunci;
+        internal IntPtr glBlendFuncSeparate;
+        internal IntPtr glBlendFuncSeparatei;
+        internal IntPtr glBlitFramebuffer;
+        internal IntPtr glBlitNamedFramebuffer;
+        internal IntPtr glBufferData;
+        internal IntPtr glBufferStorage;
+        internal IntPtr glBufferSubData;
+        internal IntPtr glCheckFramebufferStatus;
+        internal IntPtr glCheckNamedFramebufferStatus;
+        internal IntPtr glClampColor;
+        internal IntPtr glClear;
+        internal IntPtr glClearBufferData;
+        internal IntPtr glClearBufferfi;
+        internal IntPtr glClearBufferfv;
+        internal IntPtr glClearBufferiv;
+        internal IntPtr glClearBufferSubData;
+        internal IntPtr glClearBufferuiv;
+        internal IntPtr glClearColor;
+        internal IntPtr glClearDepth;
+        internal IntPtr glClearDepthf;
+        internal IntPtr glClearNamedBufferData;
+        internal IntPtr glClearNamedBufferSubData;
+        internal IntPtr glClearNamedFramebufferfi;
+        internal IntPtr glClearNamedFramebufferfv;
+        internal IntPtr glClearNamedFramebufferiv;
+        internal IntPtr glClearNamedFramebufferuiv;
+        internal IntPtr glClearStencil;
+        internal IntPtr glClearTexImage;
+        internal IntPtr glClearTexSubImage;
+        internal IntPtr glClientWaitSync;
+        internal IntPtr glClipControl;
+        internal IntPtr glColorMask;
+        internal IntPtr glColorMaski;
+        internal IntPtr glCompileShader;
+        internal IntPtr glCompressedTexImage1D;
+        internal IntPtr glCompressedTexImage2D;
+        internal IntPtr glCompressedTexImage3D;
+        internal IntPtr glCompressedTexSubImage1D;
+        internal IntPtr glCompressedTexSubImage2D;
+        internal IntPtr glCompressedTexSubImage3D;
+        internal IntPtr glCompressedTextureSubImage1D;
+        internal IntPtr glCompressedTextureSubImage2D;
+        internal IntPtr glCompressedTextureSubImage3D;
+        internal IntPtr glCopyBufferSubData;
+        internal IntPtr glCopyImageSubData;
+        internal IntPtr glCopyNamedBufferSubData;
+        internal IntPtr glCopyTexImage1D;
+        internal IntPtr glCopyTexImage2D;
+        internal IntPtr glCopyTexSubImage1D;
+        internal IntPtr glCopyTexSubImage2D;
+        internal IntPtr glCopyTexSubImage3D;
+        internal IntPtr glCopyTextureSubImage1D;
+        internal IntPtr glCopyTextureSubImage2D;
+        internal IntPtr glCopyTextureSubImage3D;
+        internal IntPtr glCreateBuffers;
+        internal IntPtr glCreateFramebuffers;
+        internal IntPtr glCreateProgram;
+        internal IntPtr glCreateProgramPipelines;
+        internal IntPtr glCreateQueries;
+        internal IntPtr glCreateRenderbuffers;
+        internal IntPtr glCreateSamplers;
+        internal IntPtr glCreateShader;
+        internal IntPtr glCreateShaderProgramv;
+        internal IntPtr glCreateTextures;
+        internal IntPtr glCreateTransformFeedbacks;
+        internal IntPtr glCreateVertexArrays;
+        internal IntPtr glCullFace;
+        internal IntPtr glDebugMessageCallback;
+        internal IntPtr glDebugMessageControl;
+        internal IntPtr glDebugMessageInsert;
+        internal IntPtr glDeleteBuffers;
+        internal IntPtr glDeleteFramebuffers;
+        internal IntPtr glDeleteProgram;
+        internal IntPtr glDeleteProgramPipelines;
+        internal IntPtr glDeleteQueries;
+        internal IntPtr glDeleteRenderbuffers;
+        internal IntPtr glDeleteSamplers;
+        internal IntPtr glDeleteShader;
+        internal IntPtr glDeleteSync;
+        internal IntPtr glDeleteTextures;
+        internal IntPtr glDeleteTransformFeedbacks;
+        internal IntPtr glDeleteVertexArrays;
+        internal IntPtr glDepthFunc;
+        internal IntPtr glDepthMask;
+        internal IntPtr glDepthRange;
+        internal IntPtr glDepthRangeArrayv;
+        internal IntPtr glDepthRangef;
+        internal IntPtr glDepthRangeIndexed;
+        internal IntPtr glDetachShader;
+        internal IntPtr glDisable;
+        internal IntPtr glDisablei;
+        internal IntPtr glDisableVertexArrayAttrib;
+        internal IntPtr glDisableVertexAttribArray;
+        internal IntPtr glDispatchCompute;
+        internal IntPtr glDispatchComputeIndirect;
+        internal IntPtr glDrawArrays;
+        internal IntPtr glDrawArraysIndirect;
+        internal IntPtr glDrawArraysInstanced;
+        internal IntPtr glDrawArraysInstancedBaseInstance;
+        internal IntPtr glDrawBuffer;
+        internal IntPtr glDrawBuffers;
+        internal IntPtr glDrawElements;
+        internal IntPtr glDrawElementsBaseVertex;
+        internal IntPtr glDrawElementsIndirect;
+        internal IntPtr glDrawElementsInstanced;
+        internal IntPtr glDrawElementsInstancedBaseInstance;
+        internal IntPtr glDrawElementsInstancedBaseVertex;
+        internal IntPtr glDrawElementsInstancedBaseVertexBaseInstance;
+        internal IntPtr glDrawRangeElements;
+        internal IntPtr glDrawRangeElementsBaseVertex;
+        internal IntPtr glDrawTransformFeedback;
+        internal IntPtr glDrawTransformFeedbackInstanced;
+        internal IntPtr glDrawTransformFeedbackStream;
+        internal IntPtr glDrawTransformFeedbackStreamInstanced;
+        internal IntPtr glEnable;
+        internal IntPtr glEnablei;
+        internal IntPtr glEnableVertexArrayAttrib;
+        internal IntPtr glEnableVertexAttribArray;
+        internal IntPtr glEndConditionalRender;
+        internal IntPtr glEndQuery;
+        internal IntPtr glEndQueryIndexed;
+        internal IntPtr glEndTransformFeedback;
+        internal IntPtr glFenceSync;
+        internal IntPtr glFinish;
+        internal IntPtr glFlush;
+        internal IntPtr glFlushMappedBufferRange;
+        internal IntPtr glFlushMappedNamedBufferRange;
+        internal IntPtr glFramebufferParameteri;
+        internal IntPtr glFramebufferRenderbuffer;
+        internal IntPtr glFramebufferTexture;
+        internal IntPtr glFramebufferTexture1D;
+        internal IntPtr glFramebufferTexture2D;
+        internal IntPtr glFramebufferTexture3D;
+        internal IntPtr glFramebufferTextureLayer;
+        internal IntPtr glFrontFace;
+        internal IntPtr glGenBuffers;
+        internal IntPtr glGenerateMipmap;
+        internal IntPtr glGenerateTextureMipmap;
+        internal IntPtr glGenFramebuffers;
+        internal IntPtr glGenProgramPipelines;
+        internal IntPtr glGenQueries;
+        internal IntPtr glGenRenderbuffers;
+        internal IntPtr glGenSamplers;
+        internal IntPtr glGenTextures;
+        internal IntPtr glGenTransformFeedbacks;
+        internal IntPtr glGenVertexArrays;
+        internal IntPtr glGetActiveAtomicCounterBufferiv;
+        internal IntPtr glGetActiveAttrib;
+        internal IntPtr glGetActiveSubroutineName;
+        internal IntPtr glGetActiveSubroutineUniformiv;
+        internal IntPtr glGetActiveSubroutineUniformName;
+        internal IntPtr glGetActiveUniform;
+        internal IntPtr glGetActiveUniformBlockiv;
+        internal IntPtr glGetActiveUniformBlockName;
+        internal IntPtr glGetActiveUniformName;
+        internal IntPtr glGetActiveUniformsiv;
+        internal IntPtr glGetAttachedShaders;
+        internal IntPtr glGetAttribLocation;
+        internal IntPtr glGetBooleani_v;
+        internal IntPtr glGetBooleanv;
+        internal IntPtr glGetBufferParameteri64v;
+        internal IntPtr glGetBufferParameteriv;
+        internal IntPtr glGetBufferPointerv;
+        internal IntPtr glGetBufferSubData;
+        internal IntPtr glGetCompressedTexImage;
+        internal IntPtr glGetCompressedTextureImage;
+        internal IntPtr glGetCompressedTextureSubImage;
+        internal IntPtr glGetDebugMessageLog;
+        internal IntPtr glGetDoublei_v;
+        internal IntPtr glGetDoublev;
+        internal IntPtr glGetError;
+        internal IntPtr glGetFloati_v;
+        internal IntPtr glGetFloatv;
+        internal IntPtr glGetFragDataIndex;
+        internal IntPtr glGetFragDataLocation;
+        internal IntPtr glGetFramebufferAttachmentParameteriv;
+        internal IntPtr glGetFramebufferParameteriv;
+        internal IntPtr glGetGraphicsResetStatus;
+        internal IntPtr glGetInteger64i_v;
+        internal IntPtr glGetInteger64v;
+        internal IntPtr glGetIntegeri_v;
+        internal IntPtr glGetIntegerv;
+        internal IntPtr glGetInternalformati64v;
+        internal IntPtr glGetInternalformativ;
+        internal IntPtr glGetMultisamplefv;
+        internal IntPtr glGetNamedBufferParameteri64v;
+        internal IntPtr glGetNamedBufferParameteriv;
+        internal IntPtr glGetNamedBufferPointerv;
+        internal IntPtr glGetNamedBufferSubData;
+        internal IntPtr glGetNamedFramebufferAttachmentParameteriv;
+        internal IntPtr glGetNamedFramebufferParameteriv;
+        internal IntPtr glGetNamedRenderbufferParameteriv;
+        internal IntPtr glGetnCompressedTexImage;
+        internal IntPtr glGetnTexImage;
+        internal IntPtr glGetnUniformdv;
+        internal IntPtr glGetnUniformfv;
+        internal IntPtr glGetnUniformiv;
+        internal IntPtr glGetnUniformuiv;
+        internal IntPtr glGetObjectLabel;
+        internal IntPtr glGetObjectPtrLabel;
+        internal IntPtr glGetPointerv;
+        internal IntPtr glGetProgramBinary;
+        internal IntPtr glGetProgramInfoLog;
+        internal IntPtr glGetProgramInterfaceiv;
+        internal IntPtr glGetProgramiv;
+        internal IntPtr glGetProgramPipelineInfoLog;
+        internal IntPtr glGetProgramPipelineiv;
+        internal IntPtr glGetProgramResourceIndex;
+        internal IntPtr glGetProgramResourceiv;
+        internal IntPtr glGetProgramResourceLocation;
+        internal IntPtr glGetProgramResourceLocationIndex;
+        internal IntPtr glGetProgramResourceName;
+        internal IntPtr glGetProgramStageiv;
+        internal IntPtr glGetQueryBufferObjecti64v;
+        internal IntPtr glGetQueryBufferObjectiv;
+        internal IntPtr glGetQueryBufferObjectui64v;
+        internal IntPtr glGetQueryBufferObjectuiv;
+        internal IntPtr glGetQueryIndexediv;
+        internal IntPtr glGetQueryiv;
+        internal IntPtr glGetQueryObjecti64v;
+        internal IntPtr glGetQueryObjectiv;
+        internal IntPtr glGetQueryObjectui64v;
+        internal IntPtr glGetQueryObjectuiv;
+        internal IntPtr glGetRenderbufferParameteriv;
+        internal IntPtr glGetSamplerParameterfv;
+        internal IntPtr glGetSamplerParameterIiv;
+        internal IntPtr glGetSamplerParameterIuiv;
+        internal IntPtr glGetSamplerParameteriv;
+        internal IntPtr glGetShaderInfoLog;
+        internal IntPtr glGetShaderiv;
+        internal IntPtr glGetShaderPrecisionFormat;
+        internal IntPtr glGetShaderSource;
+        internal IntPtr glGetString;
+        internal IntPtr glGetStringi;
+        internal IntPtr glGetSubroutineIndex;
+        internal IntPtr glGetSubroutineUniformLocation;
+        internal IntPtr glGetSynciv;
+        internal IntPtr glGetTexImage;
+        internal IntPtr glGetTexLevelParameterfv;
+        internal IntPtr glGetTexLevelParameteriv;
+        internal IntPtr glGetTexParameterfv;
+        internal IntPtr glGetTexParameterIiv;
+        internal IntPtr glGetTexParameterIuiv;
+        internal IntPtr glGetTexParameteriv;
+        internal IntPtr glGetTextureImage;
+        internal IntPtr glGetTextureLevelParameterfv;
+        internal IntPtr glGetTextureLevelParameteriv;
+        internal IntPtr glGetTextureParameterfv;
+        internal IntPtr glGetTextureParameterIiv;
+        internal IntPtr glGetTextureParameterIuiv;
+        internal IntPtr glGetTextureParameteriv;
+        internal IntPtr glGetTextureSubImage;
+        internal IntPtr glGetTransformFeedbacki_v;
+        internal IntPtr glGetTransformFeedbacki64_v;
+        internal IntPtr glGetTransformFeedbackiv;
+        internal IntPtr glGetTransformFeedbackVarying;
+        internal IntPtr glGetUniformBlockIndex;
+        internal IntPtr glGetUniformdv;
+        internal IntPtr glGetUniformfv;
+        internal IntPtr glGetUniformIndices;
+        internal IntPtr glGetUniformiv;
+        internal IntPtr glGetUniformLocation;
+        internal IntPtr glGetUniformSubroutineuiv;
+        internal IntPtr glGetUniformuiv;
+        internal IntPtr glGetVertexArrayIndexed64iv;
+        internal IntPtr glGetVertexArrayIndexediv;
+        internal IntPtr glGetVertexArrayiv;
+        internal IntPtr glGetVertexAttribdv;
+        internal IntPtr glGetVertexAttribfv;
+        internal IntPtr glGetVertexAttribIiv;
+        internal IntPtr glGetVertexAttribIuiv;
+        internal IntPtr glGetVertexAttribiv;
+        internal IntPtr glGetVertexAttribLdv;
+        internal IntPtr glGetVertexAttribPointerv;
+        internal IntPtr glHint;
+        internal IntPtr glInvalidateBufferData;
+        internal IntPtr glInvalidateBufferSubData;
+        internal IntPtr glInvalidateFramebuffer;
+        internal IntPtr glInvalidateNamedFramebufferData;
+        internal IntPtr glInvalidateNamedFramebufferSubData;
+        internal IntPtr glInvalidateSubFramebuffer;
+        internal IntPtr glInvalidateTexImage;
+        internal IntPtr glInvalidateTexSubImage;
+        internal IntPtr glIsBuffer;
+        internal IntPtr glIsEnabled;
+        internal IntPtr glIsEnabledi;
+        internal IntPtr glIsFramebuffer;
+        internal IntPtr glIsProgram;
+        internal IntPtr glIsProgramPipeline;
+        internal IntPtr glIsQuery;
+        internal IntPtr glIsRenderbuffer;
+        internal IntPtr glIsSampler;
+        internal IntPtr glIsShader;
+        internal IntPtr glIsSync;
+        internal IntPtr glIsTexture;
+        internal IntPtr glIsTransformFeedback;
+        internal IntPtr glIsVertexArray;
+        internal IntPtr glLineWidth;
+        internal IntPtr glLinkProgram;
+        internal IntPtr glLogicOp;
+        internal IntPtr glMapBuffer;
+        internal IntPtr glMapBufferRange;
+        internal IntPtr glMapNamedBuffer;
+        internal IntPtr glMapNamedBufferRange;
+        internal IntPtr glMemoryBarrier;
+        internal IntPtr glMemoryBarrierByRegion;
+        internal IntPtr glMinSampleShading;
+        internal IntPtr glMultiDrawArrays;
+        internal IntPtr glMultiDrawArraysIndirect;
+        internal IntPtr glMultiDrawArraysIndirectCount;
+        internal IntPtr glMultiDrawElements;
+        internal IntPtr glMultiDrawElementsBaseVertex;
+        internal IntPtr glMultiDrawElementsIndirect;
+        internal IntPtr glMultiDrawElementsIndirectCount;
+        internal IntPtr glNamedBufferData;
+        internal IntPtr glNamedBufferStorage;
+        internal IntPtr glNamedBufferSubData;
+        internal IntPtr glNamedFramebufferDrawBuffer;
+        internal IntPtr glNamedFramebufferDrawBuffers;
+        internal IntPtr glNamedFramebufferParameteri;
+        internal IntPtr glNamedFramebufferReadBuffer;
+        internal IntPtr glNamedFramebufferRenderbuffer;
+        internal IntPtr glNamedFramebufferTexture;
+        internal IntPtr glNamedFramebufferTextureLayer;
+        internal IntPtr glNamedRenderbufferStorage;
+        internal IntPtr glNamedRenderbufferStorageMultisample;
+        internal IntPtr glObjectLabel;
+        internal IntPtr glObjectPtrLabel;
+        internal IntPtr glPatchParameterfv;
+        internal IntPtr glPatchParameteri;
+        internal IntPtr glPauseTransformFeedback;
+        internal IntPtr glPixelStoref;
+        internal IntPtr glPixelStorei;
+        internal IntPtr glPointParameterf;
+        internal IntPtr glPointParameterfv;
+        internal IntPtr glPointParameteri;
+        internal IntPtr glPointParameteriv;
+        internal IntPtr glPointSize;
+        internal IntPtr glPolygonMode;
+        internal IntPtr glPolygonOffset;
+        internal IntPtr glPolygonOffsetClamp;
+        internal IntPtr glPopDebugGroup;
+        internal IntPtr glPrimitiveRestartIndex;
+        internal IntPtr glProgramBinary;
+        internal IntPtr glProgramParameteri;
+        internal IntPtr glProgramUniform1d;
+        internal IntPtr glProgramUniform1dv;
+        internal IntPtr glProgramUniform1f;
+        internal IntPtr glProgramUniform1fv;
+        internal IntPtr glProgramUniform1i;
+        internal IntPtr glProgramUniform1iv;
+        internal IntPtr glProgramUniform1ui;
+        internal IntPtr glProgramUniform1uiv;
+        internal IntPtr glProgramUniform2d;
+        internal IntPtr glProgramUniform2dv;
+        internal IntPtr glProgramUniform2f;
+        internal IntPtr glProgramUniform2fv;
+        internal IntPtr glProgramUniform2i;
+        internal IntPtr glProgramUniform2iv;
+        internal IntPtr glProgramUniform2ui;
+        internal IntPtr glProgramUniform2uiv;
+        internal IntPtr glProgramUniform3d;
+        internal IntPtr glProgramUniform3dv;
+        internal IntPtr glProgramUniform3f;
+        internal IntPtr glProgramUniform3fv;
+        internal IntPtr glProgramUniform3i;
+        internal IntPtr glProgramUniform3iv;
+        internal IntPtr glProgramUniform3ui;
+        internal IntPtr glProgramUniform3uiv;
+        internal IntPtr glProgramUniform4d;
+        internal IntPtr glProgramUniform4dv;
+        internal IntPtr glProgramUniform4f;
+        internal IntPtr glProgramUniform4fv;
+        internal IntPtr glProgramUniform4i;
+        internal IntPtr glProgramUniform4iv;
+        internal IntPtr glProgramUniform4ui;
+        internal IntPtr glProgramUniform4uiv;
+        internal IntPtr glProgramUniformMatrix2dv;
+        internal IntPtr glProgramUniformMatrix2fv;
+        internal IntPtr glProgramUniformMatrix2x3dv;
+        internal IntPtr glProgramUniformMatrix2x3fv;
+        internal IntPtr glProgramUniformMatrix2x4dv;
+        internal IntPtr glProgramUniformMatrix2x4fv;
+        internal IntPtr glProgramUniformMatrix3dv;
+        internal IntPtr glProgramUniformMatrix3fv;
+        internal IntPtr glProgramUniformMatrix3x2dv;
+        internal IntPtr glProgramUniformMatrix3x2fv;
+        internal IntPtr glProgramUniformMatrix3x4dv;
+        internal IntPtr glProgramUniformMatrix3x4fv;
+        internal IntPtr glProgramUniformMatrix4dv;
+        internal IntPtr glProgramUniformMatrix4fv;
+        internal IntPtr glProgramUniformMatrix4x2dv;
+        internal IntPtr glProgramUniformMatrix4x2fv;
+        internal IntPtr glProgramUniformMatrix4x3dv;
+        internal IntPtr glProgramUniformMatrix4x3fv;
+        internal IntPtr glProvokingVertex;
+        internal IntPtr glPushDebugGroup;
+        internal IntPtr glQueryCounter;
+        internal IntPtr glReadBuffer;
+        internal IntPtr glReadnPixels;
+        internal IntPtr glReadPixels;
+        internal IntPtr glReleaseShaderCompiler;
+        internal IntPtr glRenderbufferStorage;
+        internal IntPtr glRenderbufferStorageMultisample;
+        internal IntPtr glResumeTransformFeedback;
+        internal IntPtr glSampleCoverage;
+        internal IntPtr glSampleMaski;
+        internal IntPtr glSamplerParameterf;
+        internal IntPtr glSamplerParameterfv;
+        internal IntPtr glSamplerParameteri;
+        internal IntPtr glSamplerParameterIiv;
+        internal IntPtr glSamplerParameterIuiv;
+        internal IntPtr glSamplerParameteriv;
+        internal IntPtr glScissor;
+        internal IntPtr glScissorArrayv;
+        internal IntPtr glScissorIndexed;
+        internal IntPtr glScissorIndexedv;
+        internal IntPtr glShaderBinary;
+        internal IntPtr glShaderSource;
+        internal IntPtr glShaderStorageBlockBinding;
+        internal IntPtr glSpecializeShader;
+        internal IntPtr glStencilFunc;
+        internal IntPtr glStencilFuncSeparate;
+        internal IntPtr glStencilMask;
+        internal IntPtr glStencilMaskSeparate;
+        internal IntPtr glStencilOp;
+        internal IntPtr glStencilOpSeparate;
+        internal IntPtr glTexBuffer;
+        internal IntPtr glTexBufferRange;
+        internal IntPtr glTexImage1D;
+        internal IntPtr glTexImage2D;
+        internal IntPtr glTexImage2DMultisample;
+        internal IntPtr glTexImage3D;
+        internal IntPtr glTexImage3DMultisample;
+        internal IntPtr glTexParameterf;
+        internal IntPtr glTexParameterfv;
+        internal IntPtr glTexParameteri;
+        internal IntPtr glTexParameterIiv;
+        internal IntPtr glTexParameterIuiv;
+        internal IntPtr glTexParameteriv;
+        internal IntPtr glTexStorage1D;
+        internal IntPtr glTexStorage2D;
+        internal IntPtr glTexStorage2DMultisample;
+        internal IntPtr glTexStorage3D;
+        internal IntPtr glTexStorage3DMultisample;
+        internal IntPtr glTexSubImage1D;
+        internal IntPtr glTexSubImage2D;
+        internal IntPtr glTexSubImage3D;
+        internal IntPtr glTextureBarrier;
+        internal IntPtr glTextureBuffer;
+        internal IntPtr glTextureBufferRange;
+        internal IntPtr glTextureParameterf;
+        internal IntPtr glTextureParameterfv;
+        internal IntPtr glTextureParameteri;
+        internal IntPtr glTextureParameterIiv;
+        internal IntPtr glTextureParameterIuiv;
+        internal IntPtr glTextureParameteriv;
+        internal IntPtr glTextureStorage1D;
+        internal IntPtr glTextureStorage2D;
+        internal IntPtr glTextureStorage2DMultisample;
+        internal IntPtr glTextureStorage3D;
+        internal IntPtr glTextureStorage3DMultisample;
+        internal IntPtr glTextureSubImage1D;
+        internal IntPtr glTextureSubImage2D;
+        internal IntPtr glTextureSubImage3D;
+        internal IntPtr glTextureView;
+        internal IntPtr glTransformFeedbackBufferBase;
+        internal IntPtr glTransformFeedbackBufferRange;
+        internal IntPtr glTransformFeedbackVaryings;
+        internal IntPtr glUniform1d;
+        internal IntPtr glUniform1dv;
+        internal IntPtr glUniform1f;
+        internal IntPtr glUniform1fv;
+        internal IntPtr glUniform1i;
+        internal IntPtr glUniform1iv;
+        internal IntPtr glUniform1ui;
+        internal IntPtr glUniform1uiv;
+        internal IntPtr glUniform2d;
+        internal IntPtr glUniform2dv;
+        internal IntPtr glUniform2f;
+        internal IntPtr glUniform2fv;
+        internal IntPtr glUniform2i;
+        internal IntPtr glUniform2iv;
+        internal IntPtr glUniform2ui;
+        internal IntPtr glUniform2uiv;
+        internal IntPtr glUniform3d;
+        internal IntPtr glUniform3dv;
+        internal IntPtr glUniform3f;
+        internal IntPtr glUniform3fv;
+        internal IntPtr glUniform3i;
+        internal IntPtr glUniform3iv;
+        internal IntPtr glUniform3ui;
+        internal IntPtr glUniform3uiv;
+        internal IntPtr glUniform4d;
+        internal IntPtr glUniform4dv;
+        internal IntPtr glUniform4f;
+        internal IntPtr glUniform4fv;
+        internal IntPtr glUniform4i;
+        internal IntPtr glUniform4iv;
+        internal IntPtr glUniform4ui;
+        internal IntPtr glUniform4uiv;
+        internal IntPtr glUniformBlockBinding;
+        internal IntPtr glUniformMatrix2dv;
+        internal IntPtr glUniformMatrix2fv;
+        internal IntPtr glUniformMatrix2x3dv;
+        internal IntPtr glUniformMatrix2x3fv;
+        internal IntPtr glUniformMatrix2x4dv;
+        internal IntPtr glUniformMatrix2x4fv;
+        internal IntPtr glUniformMatrix3dv;
+        internal IntPtr glUniformMatrix3fv;
+        internal IntPtr glUniformMatrix3x2dv;
+        internal IntPtr glUniformMatrix3x2fv;
+        internal IntPtr glUniformMatrix3x4dv;
+        internal IntPtr glUniformMatrix3x4fv;
+        internal IntPtr glUniformMatrix4dv;
+        internal IntPtr glUniformMatrix4fv;
+        internal IntPtr glUniformMatrix4x2dv;
+        internal IntPtr glUniformMatrix4x2fv;
+        internal IntPtr glUniformMatrix4x3dv;
+        internal IntPtr glUniformMatrix4x3fv;
+        internal IntPtr glUniformSubroutinesuiv;
+        internal IntPtr glUnmapBuffer;
+        internal IntPtr glUnmapNamedBuffer;
+        internal IntPtr glUseProgram;
+        internal IntPtr glUseProgramStages;
+        internal IntPtr glValidateProgram;
+        internal IntPtr glValidateProgramPipeline;
+        internal IntPtr glVertexArrayAttribBinding;
+        internal IntPtr glVertexArrayAttribFormat;
+        internal IntPtr glVertexArrayAttribIFormat;
+        internal IntPtr glVertexArrayAttribLFormat;
+        internal IntPtr glVertexArrayBindingDivisor;
+        internal IntPtr glVertexArrayElementBuffer;
+        internal IntPtr glVertexArrayVertexBuffer;
+        internal IntPtr glVertexArrayVertexBuffers;
+        internal IntPtr glVertexAttrib1d;
+        internal IntPtr glVertexAttrib1dv;
+        internal IntPtr glVertexAttrib1f;
+        internal IntPtr glVertexAttrib1fv;
+        internal IntPtr glVertexAttrib1s;
+        internal IntPtr glVertexAttrib1sv;
+        internal IntPtr glVertexAttrib2d;
+        internal IntPtr glVertexAttrib2dv;
+        internal IntPtr glVertexAttrib2f;
+        internal IntPtr glVertexAttrib2fv;
+        internal IntPtr glVertexAttrib2s;
+        internal IntPtr glVertexAttrib2sv;
+        internal IntPtr glVertexAttrib3d;
+        internal IntPtr glVertexAttrib3dv;
+        internal IntPtr glVertexAttrib3f;
+        internal IntPtr glVertexAttrib3fv;
+        internal IntPtr glVertexAttrib3s;
+        internal IntPtr glVertexAttrib3sv;
+        internal IntPtr glVertexAttrib4bv;
+        internal IntPtr glVertexAttrib4d;
+        internal IntPtr glVertexAttrib4dv;
+        internal IntPtr glVertexAttrib4f;
+        internal IntPtr glVertexAttrib4fv;
+        internal IntPtr glVertexAttrib4iv;
+        internal IntPtr glVertexAttrib4Nbv;
+        internal IntPtr glVertexAttrib4Niv;
+        internal IntPtr glVertexAttrib4Nsv;
+        internal IntPtr glVertexAttrib4Nub;
+        internal IntPtr glVertexAttrib4Nubv;
+        internal IntPtr glVertexAttrib4Nuiv;
+        internal IntPtr glVertexAttrib4Nusv;
+        internal IntPtr glVertexAttrib4s;
+        internal IntPtr glVertexAttrib4sv;
+        internal IntPtr glVertexAttrib4ubv;
+        internal IntPtr glVertexAttrib4uiv;
+        internal IntPtr glVertexAttrib4usv;
+        internal IntPtr glVertexAttribBinding;
+        internal IntPtr glVertexAttribDivisor;
+        internal IntPtr glVertexAttribFormat;
+        internal IntPtr glVertexAttribI1i;
+        internal IntPtr glVertexAttribI1iv;
+        internal IntPtr glVertexAttribI1ui;
+        internal IntPtr glVertexAttribI1uiv;
+        internal IntPtr glVertexAttribI2i;
+        internal IntPtr glVertexAttribI2iv;
+        internal IntPtr glVertexAttribI2ui;
+        internal IntPtr glVertexAttribI2uiv;
+        internal IntPtr glVertexAttribI3i;
+        internal IntPtr glVertexAttribI3iv;
+        internal IntPtr glVertexAttribI3ui;
+        internal IntPtr glVertexAttribI3uiv;
+        internal IntPtr glVertexAttribI4bv;
+        internal IntPtr glVertexAttribI4i;
+        internal IntPtr glVertexAttribI4iv;
+        internal IntPtr glVertexAttribI4sv;
+        internal IntPtr glVertexAttribI4ubv;
+        internal IntPtr glVertexAttribI4ui;
+        internal IntPtr glVertexAttribI4uiv;
+        internal IntPtr glVertexAttribI4usv;
+        internal IntPtr glVertexAttribIFormat;
+        internal IntPtr glVertexAttribIPointer;
+        internal IntPtr glVertexAttribL1d;
+        internal IntPtr glVertexAttribL1dv;
+        internal IntPtr glVertexAttribL2d;
+        internal IntPtr glVertexAttribL2dv;
+        internal IntPtr glVertexAttribL3d;
+        internal IntPtr glVertexAttribL3dv;
+        internal IntPtr glVertexAttribL4d;
+        internal IntPtr glVertexAttribL4dv;
+        internal IntPtr glVertexAttribLFormat;
+        internal IntPtr glVertexAttribLPointer;
+        internal IntPtr glVertexAttribP1ui;
+        internal IntPtr glVertexAttribP1uiv;
+        internal IntPtr glVertexAttribP2ui;
+        internal IntPtr glVertexAttribP2uiv;
+        internal IntPtr glVertexAttribP3ui;
+        internal IntPtr glVertexAttribP3uiv;
+        internal IntPtr glVertexAttribP4ui;
+        internal IntPtr glVertexAttribP4uiv;
+        internal IntPtr glVertexAttribPointer;
+        internal IntPtr glVertexBindingDivisor;
+        internal IntPtr glViewport;
+        internal IntPtr glViewportArrayv;
+        internal IntPtr glViewportIndexedf;
+        internal IntPtr glViewportIndexedfv;
+        internal IntPtr glWaitSync;
+
+    }
+}

StgSharp.Common/Graphics/OpenGL/glFunction.cs

@@ -1,4 +1,4 @@
-//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 // file="glFunction"
 // Project: StgSharp
@@ -92,13 +92,17 @@ namespace StgSharp.Graphics.OpenGL
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void ActiveTextureUnit(uint type)
+        public void ActiveTextureUnit(
+                    uint type
+        )
         {
             Context.glActiveTexture(type);
         }
 
         [Conditional("DEBUG")]
-        public void Assert(bool shouldReportWhenNormal)
+        public void Assert(
+                    bool shouldReportWhenNormal
+        )
         {
             uint code = Context.glGetError();
             if (code != glConst.NO_ERROR) {
@@ -110,20 +114,17 @@ namespace StgSharp.Graphics.OpenGL
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void AttachShader(GlHandle program, GlHandle shader)
-        {
-            Context.glAttachShader(program.Value, shader.Value);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void BindBuffer(BufferType bufferType, GlHandle handle)
+        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>.
+        ///   href="https://docs._gl/gl3/glBindFramebuffer"> glBindFramebuffer </see>.
         /// </summary>
         /// <param _label="target">
         ///   The frame BufferHandle target of the binding operation.
@@ -132,47 +133,46 @@ namespace StgSharp.Graphics.OpenGL
         ///   The handle of the frame BufferHandle object to bind.
         /// </param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void BindFrameBuffer(FrameBufferTarget target, GlHandle handle)
+        public void BindFrameBuffer(
+                    FrameBufferTarget target,
+                    GlHandle handle
+        )
         {
             Context.glBindFramebuffer((uint)target, handle.Value);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void BindRenderBuffer(GlHandle handle)
+        public void BindRenderBuffer(
+                    GlHandle handle
+        )
         {
             Context.glBindRenderbuffer(glConst.RENDERBUFFER, handle.Value);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void BindTexture(uint type, GlHandle texture)
-        {
-            Context.glBindTexture(type, texture.Value);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void BindVertexArray(GlHandle handle)
+        public void BindVertexArray(
+                    GlHandle handle
+        )
         {
             Context.glBindVertexArray(handle.Value);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public FrameBufferStatus CheckFrameBufferStatus(FrameBufferTarget target)
+        public FrameBufferStatus CheckFrameBufferStatus(
+                                 FrameBufferTarget target
+        )
         {
             return (FrameBufferStatus)Context.glCheckFramebufferStatus((uint)target);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Clear(MaskBufferBit mask)
+        public void Clear(
+                    MaskBufferBit mask
+        )
         {
             Context.glClear((uint)mask);
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void ClearColor(float R, float G, float B, float A)
-        {
-            Context.glClearColor(R, G, B, A);
-        }
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ClearError()
         {
@@ -199,16 +199,13 @@ namespace StgSharp.Graphics.OpenGL
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void CombineFrameBufferRenderBuffer(FrameBufferAttachment attachment, GlHandle rboHandle)
+        public void CombineFrameBufferRenderBuffer(
+                    FrameBufferAttachment attachment,
+                    GlHandle rboHandle
+        )
         {
-            Context.glFramebufferRenderbuffer(glConst.FRAMEBUFFER, (uint)attachment, glConst.RENDERBUFFER,
-                                              rboHandle.Value);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void CompileShader(GlHandle shaderhandle)
-        {
-            Context.glCompileShader(shaderhandle.Value);
+            Context.glFramebufferRenderbuffer(glConst.FRAMEBUFFER, (uint)attachment,
+                                              glConst.RENDERBUFFER, rboHandle.Value);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -218,13 +215,9 @@ namespace StgSharp.Graphics.OpenGL
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public GlHandle CreateProgram()
-        {
-            return GlHandle.Create(Context.glCreateProgram());
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe GlHandle[] CreateProgram(int count)
+        public unsafe GlHandle[] CreateProgram(
+                                 int count
+        )
         {
             GlHandle[] h = new GlHandle[count];
             for (int i = 0; i < count; i++) {
@@ -234,7 +227,10 @@ namespace StgSharp.Graphics.OpenGL
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public GlHandle[] CreateShaderSet(int count, ShaderType type)
+        public GlHandle[] CreateShaderSet(
+                          int count,
+                          ShaderType type
+        )
         {
             GlHandle[] ret = new GlHandle[count];
             uint t = (uint)type;
@@ -252,13 +248,17 @@ namespace StgSharp.Graphics.OpenGL
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void DeleteBuffer(GlHandle handle)
+        public unsafe void DeleteBuffer(
+                           GlHandle handle
+        )
         {
             Context.glDeleteBuffers(1, (uint*)&handle);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void DeleteBuffers(GlHandle[] handle)
+        public unsafe void DeleteBuffers(
+                           GlHandle[] handle
+        )
         {
             if ((handle == null) || (handle.Length == 0)) {
                 throw new ArgumentNullException(nameof(handle));
@@ -274,19 +274,24 @@ namespace StgSharp.Graphics.OpenGL
 
         /// <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.
+        ///   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)
+        public unsafe void DeleteRenderBuffer(
+                           GlHandle bufferHandle
+        )
         {
             Context.glDeleteRenderbuffers(1, &bufferHandle.Value);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void DeleteVertexArrays(GlHandle[] arrays)
+        public unsafe void DeleteVertexArrays(
+                           GlHandle[] arrays
+        )
         {
             fixed (GlHandle* hptr = arrays)
             {
@@ -297,25 +302,38 @@ namespace StgSharp.Graphics.OpenGL
             }
         }
 
-        public void DepthMaskAccess(bool isWrite)
+        public void DepthMaskAccess(
+                    bool isWrite
+        )
         {
-            Context.glDepthMask(isWrite);
+            Context.glDepthMask(isWrite ? (byte)1 : (byte)0);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Disable(glOperation operation)
+        public void Disable(
+                    glOperation operation
+        )
         {
             Context.glDisable((uint)operation);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void DrawArrays(GeometryType mode, int first, uint count)
+        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, uint count, TypeCode type, IntPtr ptr)
+        public unsafe void DrawElements(
+                           GeometryType mode,
+                           int count,
+                           TypeCode type,
+                           IntPtr ptr
+        )
         {
             uint a;
             a = type switch
@@ -326,37 +344,34 @@ namespace StgSharp.Graphics.OpenGL
                 _ => 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, (void*)ptr);
+            Context.glDrawElements((uint)mode, count, a, (nint*)ptr);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void DrawElementsInstanced(GeometryType mode, uint count, TypeCode type, IntPtr ptr, uint amount)
+        public void DrawElementsInstanced(
+                    GeometryType mode,
+                    int count,
+                    TypeCode type,
+                    IntPtr ptr,
+                    int amount
+        )
         {
             uint a;
-            switch (type)
+            a = type switch
             {
-                case TypeCode.UInt32:
-                    a = glConst.UNSIGNED_INT;
-                    break;
-
-                case TypeCode.UInt16:
-                    a = glConst.UNSIGNED_SHORT;
-                    break;
-
-                case TypeCode.Byte:
-                    a = glConst.UNSIGNED_BYTE;
-                    break;
-                default:
-                    DefaultLog.InternalWriteLog(
-                        $"{$"Parameter error in parameter {nameof(type)} method DrawElements. "}{$"Only {typeof(uint).Name},{typeof(ushort).Name},{typeof(byte).Name} types are supported."}",
-                        LogType.Error);
-                    return;
-            }
-            Context.glDrawElementsInstanced((uint)mode, count, a, (void*)ptr, amount);
+                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)
+        public void Enable(
+                    glOperation operation
+        )
         {
             Context.glEnable((uint)operation);
         }
@@ -367,13 +382,17 @@ namespace StgSharp.Graphics.OpenGL
                     uint attachment,
                     Texture2DTarget texTarget,
                     GlHandle textureHandle,
-                    int level)
+                    int level
+        )
         {
-            Context.glFramebufferTexture2D((uint)target, attachment, (uint)texTarget, textureHandle.Value, level);
+            Context.glFramebufferTexture2D((uint)target, attachment, (uint)texTarget,
+                                           textureHandle.Value, level);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe GlHandle[] GenBuffers(int count)
+        public unsafe GlHandle[] GenBuffers(
+                                 int count
+        )
         {
             GlHandle[] h = new GlHandle[count];
             fixed (GlHandle* hptr = h)
@@ -386,12 +405,16 @@ namespace StgSharp.Graphics.OpenGL
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void GenerateMipmap(Texture2DTarget target)
+        public void GenerateMipmap(
+                    Texture2DTarget target
+        )
         {
             Context.glGenerateMipmap((uint)target);
         }
 
-        public unsafe GlHandle[] GenFrameBuffers(int count)
+        public unsafe GlHandle[] GenFrameBuffers(
+                                 int count
+        )
         {
             GlHandle[] h = new GlHandle[count];
             fixed (GlHandle* hptr = h) {
@@ -401,7 +424,9 @@ namespace StgSharp.Graphics.OpenGL
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe GlHandle[] GenRenderBuffer(int count)
+        public unsafe GlHandle[] GenRenderBuffer(
+                                 int count
+        )
         {
             GlHandle[] h = new GlHandle[count];
             fixed (GlHandle* hptr = h) {
@@ -411,7 +436,9 @@ namespace StgSharp.Graphics.OpenGL
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe GlHandle[] GenTextures(int count)
+        public unsafe GlHandle[] GenTextures(
+                                 int count
+        )
         {
             GlHandle[] h = new GlHandle[count];
             fixed (GlHandle* hptr = h) {
@@ -420,7 +447,9 @@ namespace StgSharp.Graphics.OpenGL
             return h;
         }
 
-        public unsafe GlHandle[] GenVertexArrays(int count)
+        public unsafe GlHandle[] GenVertexArrays(
+                                 int count
+        )
         {
             GlHandle[] h = new GlHandle[count];
             fixed (GlHandle* hptr = h) {
@@ -429,23 +458,24 @@ namespace StgSharp.Graphics.OpenGL
             return h;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public uint GetError()
-        {
-            return Context.glGetError();
-        }
-
-        public unsafe int GetMaskInteger(uint statusCode)
+        public unsafe int GetMaskInteger(
+                          uint statusCode
+        )
         {
             int ret = 0;
             Context.glGetIntegerv(statusCode, &ret);
             return ret;
         }
 
-        public string GetShaderStatus(Shader s, int index, int key)
+        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) {
+            if (GraphicFramework.glCheckShaderStatus(ref Context, s.handle[index].Value, key,
+                                                     ref sptr) == 0) {
                 return Marshal.PtrToStringAnsi(sptr);
             }
             return string.Empty;
@@ -457,16 +487,22 @@ namespace StgSharp.Graphics.OpenGL
                            int level,
                            ImageChannel channel,
                            PixelChannelLayout channelLayout,
-                           T[] dataStream)
-            where T: unmanaged,INumber<T>
+                           T[] dataStream
+        ) where T : unmanaged,INumber<T>
         {
             fixed (T* tptr = dataStream) {
-                Context.glGetTexImage((uint)target, level, (uint)channel, (uint)channelLayout, tptr);
+                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)
+        public void GetTextureLevelProperty(
+                    uint textureTypeMask,
+                    int level,
+                    uint propertyMask,
+                    out int propertyValue
+        )
         {
             fixed (int* iptr = &propertyValue) {
                 Context.glGetTexLevelParameteriv(textureTypeMask, level, propertyMask, iptr);
@@ -474,7 +510,10 @@ namespace StgSharp.Graphics.OpenGL
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe GlHandle GetUniformLocation(GlHandle program, string name)
+        public unsafe GlHandle GetUniformLocation(
+                               GlHandle program,
+                               string name
+        )
         {
             byte[] code = Encoding.UTF8.GetBytes(name);
             fixed (byte* ptr = code)
@@ -494,54 +533,59 @@ namespace StgSharp.Graphics.OpenGL
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void LoadShaderSource(GlHandle shaderHandle, byte[] codeStream)
+        public unsafe void LoadShaderSource(
+                           GlHandle shaderHandle,
+                           byte[] codeStream
+        )
         {
             fixed (byte* streamPtr = codeStream) {
-                Context.glShaderSource(shaderHandle.Value, 1, &streamPtr, (void*)0);
+                Context.glShaderSource(shaderHandle.Value, 1, &streamPtr, (int*)0);
             }
         }
 
-        public unsafe void LoadShaderSource(GlHandle shaderHandle, ReadOnlySpan<char> codeStream)
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void LoadShaderSource(
+                           GlHandle shaderHandle,
+                           ReadOnlySpan<char> codeStream
+        )
         {
-            fixed (char* streamPtr = codeStream)
-            {
-                byte* bptr = (byte*)streamPtr;
-                Context.glShaderSource(shaderHandle.Value, 1, &bptr, (void*)0);
+            fixed (char* streamPtr = codeStream) {
+                Context.glShaderSource(shaderHandle.Value, 1, (byte**)&streamPtr, (int*)0);
             }
         }
 
-        public unsafe void LoadShaderSource(GlHandle shaderHandle, ReadOnlySpan<byte> codeStream)
+        public unsafe void LoadShaderSource(
+                           GlHandle shaderHandle,
+                           ReadOnlySpan<byte> codeStream
+        )
         {
             fixed (byte* streamPtr = codeStream)
             {
                 byte* bptr = streamPtr;
-                Context.glShaderSource(shaderHandle.Value, 1, &bptr, (void*)0);
+                Context.glShaderSource(shaderHandle.Value, 1, &bptr, (int*)0);
             }
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void PolygonMode(FaceMode mode)
+        public void PolygonMode(
+                    FaceMode mode
+        )
         {
             Context.glPolygonMode(glConst.FRONT_AND_BACK, (uint)mode);
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void PolygonOffset(float factor, float unit)
-        {
-            Context.glPolygonOffset(factor, unit);
-        }
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ReadPixels(
                     (int X, int Y) beginPosition,
                     (int width, int height) size,
                     FrameBufferChannel format,
                     PixelChannelLayout dataType,
-                    ref byte[] stream)
+                    ref byte[] stream
+        )
         {
             fixed (byte* bptr = stream) {
-                Context.glReadPixels(beginPosition.X, beginPosition.Y, size.width, size.height, (uint)format,
-                                     (uint)dataType, bptr);
+                Context.glReadPixels(beginPosition.X, beginPosition.Y, size.width, size.height,
+                                     (uint)format, (uint)dataType, (nint*)bptr);
             }
         }
 
@@ -549,33 +593,40 @@ namespace StgSharp.Graphics.OpenGL
                     in Image i,
                     (int X, int Y) beginPosition,
                     FrameBufferChannel format,
-                    PixelChannelLayout dataType)
+                    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,
-                                     bptr);
+                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>
+        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, (IntPtr)size, (IntPtr)p, (uint)usage);
+            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>
+        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) {
@@ -583,85 +634,112 @@ namespace StgSharp.Graphics.OpenGL
             }
 
             fixed (void* bufferPtr = bufferArray) {
-                Context.glBufferData((uint)bufferType, (IntPtr)size, (IntPtr)bufferPtr, (uint)usage);
+                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>
+        public unsafe void SetBufferData<T>(
+                           BufferType bufferType,
+                           ReadOnlySpan<T> bufferSpan,
+                           BufferUsage usage
+        ) where T : unmanaged,INumber<T>
         {
-            int size = bufferSpan.Length * Marshal.SizeOf(typeof(T));
-            if (bufferSpan == null) {
+            int size = bufferSpan.Length * Marshal.SizeOf<T>();
+            if (bufferSpan.IsEmpty) {
                 return;
             }
 
             fixed (void* bufferPtr = bufferSpan) {
-                Context.glBufferData((uint)bufferType, (IntPtr)size, (IntPtr)bufferPtr, (uint)usage);
+                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>
+        public unsafe void SetBufferData<T>(
+                           BufferType bufferType,
+                           Span<T> bufferArray,
+                           BufferUsage usage
+        ) where T : unmanaged, INumber<T>
         {
-            int size = bufferArray.Length * Marshal.SizeOf(typeof(T));
-            if (bufferArray == null) {
+            int size = bufferArray.Length * Marshal.SizeOf<T>();
+            if (bufferArray.IsEmpty) {
                 return;
             }
 
 
             fixed (void* bufferPtr = bufferArray) {
-                Context.glBufferData((uint)bufferType, (IntPtr)size, (IntPtr)bufferPtr, (uint)usage);
+                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>
+        public unsafe void SetBufferVectorData<T>(
+                           BufferType bufferType,
+                           ReadOnlySpan<T> bufferSpan,
+                           BufferUsage usage
+        ) where T : unmanaged, IUnmanagedVector<T>
         {
-            int size = bufferSpan.Length * Marshal.SizeOf(typeof(T));
+            int size = bufferSpan.Length * Marshal.SizeOf<T>();
 
             fixed (void* bufferPtr = bufferSpan) {
-                Context.glBufferData((uint)bufferType, (IntPtr)size, (IntPtr)bufferPtr, (uint)usage);
+                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>
+        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, (IntPtr)size, (IntPtr)bufferPtr, (uint)usage);
+                Context.glBufferData((uint)bufferType, (nuint)size, (IntPtr*)bufferPtr,
+                                     (uint)usage);
             }
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public unsafe void SetRenderBufferStorage(
                            RenderBufferInternalFormat internalFormat,
-                           (int width, int height) size)
+                           (int width, int height) size
+        )
         {
-            Context.glRenderbufferStorage(glConst.RENDERBUFFER, (uint)internalFormat, size.width, size.height);
+            Context.glRenderbufferStorage(glConst.RENDERBUFFER, (uint)internalFormat, size.width,
+                                          size.height);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public unsafe void SetRenderBufferStorage(
                            RenderBufferInternalFormat internalFormat,
-                           (uint width, uint height) size)
+                           (uint width, uint height) size
+        )
         {
-            Context.glRenderbufferStorage(glConst.RENDERBUFFER, (uint)internalFormat, (int)size.width,
-                                          (int)size.height);
+            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, uint stride, int pointer)
+        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, normalized ? 1 : 0, stride, (void*)pointer);
+            Context.glVertexAttribPointer(index, size, type, (byte)(normalized ? 1 : 0), stride,
+                                          (nint*)pointer);
             Context.glEnableVertexAttribArray(index);
         }
 
@@ -670,18 +748,18 @@ namespace StgSharp.Graphics.OpenGL
                     Texture2DTarget target,
                     int level,
                     ImageChannel sourceChannel,
-                    uint width,
-                    uint height,
+                    int width,
+                    int height,
                     ImageChannel targetChannel,
                     PixelChannelLayout type,
-                    T[] pixels)
-            where T: unmanaged, INumber<T>
+                    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, (uint)sourceChannel, width, height, 0, (uint)targetChannel,
-                                     (uint)type, tptr);
+                Context.glTexImage2D((uint)target, level, (int)sourceChannel, width, height, 0,
+                                     (uint)targetChannel, (uint)type, (nint*)tptr);
             }
         }
 
@@ -690,55 +768,55 @@ namespace StgSharp.Graphics.OpenGL
                     Texture2DTarget target,
                     int level,
                     ImageChannel sourceChannel,
-                    uint width,
-                    uint height,
+                    int width,
+                    int height,
                     ImageChannel targetChannel,
                     PixelChannelLayout type,
-                    Span<T> pixelSpan)
-            where T: unmanaged, INumber<T>
+                    Span<T> pixelSpan
+        ) where T : unmanaged, INumber<T>
         {
             fixed (T* tPtr = pixelSpan) {
-                Context.glTexImage2D((uint)target, level, (uint)sourceChannel, width, height, 0, (uint)targetChannel,
-                                     (uint)type, tPtr);
+                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)
+        public void TextureParameter(
+                    int target,
+                    uint pname,
+                    int param
+        )
         {
             Context.glTexParameteri((uint)target, pname, param);
         }
 
-        public static bool TryGetFunctionPackage(IntPtr handle, out OpenGLFunction functionPackage)
+        public static bool TryGetFunctionPackage(
+                           IntPtr handle,
+                           out OpenGLFunction functionPackage
+        )
         {
             return contextToGLMap.TryGetValue(handle, out functionPackage);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void UseProgram(GlHandle program)
-        {
-            Context.glUseProgram(program.Value);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void VertexAttributeDivisor(uint layoutIndex, uint divisor)
+        public void VertexAttributeDivisor(
+                    uint layoutIndex,
+                    uint divisor
+        )
         {
             Context.glVertexAttribDivisor(layoutIndex, divisor);
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Viewport(int x, int y, uint width, uint height)
-        {
-            Context.glViewport(x, y, width, height);
-        }
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void WaitAccomplishment()
         {
             Context.glFinish();
         }
 
-        internal static OpenGLFunction BuildGlFunctionPackage(IntPtr handle)
+        internal static OpenGLFunction BuildGlFunctionPackage(
+                                       IntPtr handle
+        )
         {
             if (contextToGLMap.TryGetValue(handle, out OpenGLFunction pack)) {
                 return pack;

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

@@ -0,0 +1,544 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="glFunction.v4_0"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. All rights reserved.
+//     
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//     
+// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+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);
+            }
+        }
+
+    }
+}

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

@@ -0,0 +1,193 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="glFunction.v4_2"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. All rights reserved.
+//     
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//     
+// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// <auto-generated>
+// Generated by StgSharp.GenerateGL on 2025-12-30 02:54:41Z
+// Version: 4.2
+// </auto-generated>
+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);
+        }
+
+    }
+}

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

@@ -0,0 +1,586 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="glFunction.v4_3"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. All rights reserved.
+//     
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//     
+// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// <auto-generated>
+// Generated by StgSharp.GenerateGL on 2025-12-30 02:54:41Z
+// Version: 4.3
+// </auto-generated>
+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);
+        }
+
+    }
+}

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

@@ -0,0 +1,183 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="glFunction.v4_4"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. All rights reserved.
+//     
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//     
+// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// <auto-generated>
+// Generated by StgSharp.GenerateGL on 2025-12-30 02:54:41Z
+// Version: 4.4
+// </auto-generated>
+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);
+            }
+        }
+
+    }
+}

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

@@ -0,0 +1,106 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="glFunction.v4_6"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. All rights reserved.
+//     
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//     
+// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// <auto-generated>
+// Generated by StgSharp.GenerateGL on 2025-12-30 02:54:41Z
+// Version: 4.6
+// </auto-generated>
+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);
+                    }
+                }
+            }
+        }
+
+    }
+}

StgSharp.Common/Graphics/OpenGL/glRenderStream.cs

@@ -1,4 +1,4 @@
-//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 // file="glRenderStream"
 // Project: StgSharp
@@ -62,9 +62,9 @@ namespace StgSharp.Graphics.OpenGL
         {
             if (ContextHandle == default)
             {
-                ContextHandle = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(OpenglContext)));
+                ContextHandle = Marshal.AllocHGlobal(Marshal.SizeOf<OpenglContext>());
                 OpenglContext* contextID = (OpenglContext*)ContextHandle;
-                contextID->glGetString = (delegate*<uint, IntPtr>)IntPtr.Zero;
+                contextID->glGetString = (delegate*<uint,byte*>)IntPtr.Zero;
             }
             if (GL == null) {
                 _context = OpenGLFunction.BuildGlFunctionPackage(ContextHandle);
@@ -115,10 +115,15 @@ namespace StgSharp.Graphics.OpenGL
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public override void SetSizeLimit(int minWidth, int minHeight, int maxWidth, int maxHeight)
+        public override void SetSizeLimit(
+                             int minWidth,
+                             int minHeight,
+                             int maxWidth,
+                             int maxHeight
+        )
         {
-            GraphicFramework.glfwSetWindowSizeLimits(
-                this.CanvasHandle, minWidth, minHeight, maxWidth, maxHeight);
+            GraphicFramework.glfwSetWindowSizeLimits(this.CanvasHandle, minWidth, minHeight,
+                                                     maxWidth, maxHeight);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -135,7 +140,10 @@ namespace StgSharp.Graphics.OpenGL
             CustomizeDeinit();
         }
 
-        protected sealed override Uniform<Matrix44> NativeCameraUniform(ShaderProgram source, string name)
+        protected sealed override Uniform<Matrix44> NativeCameraUniform(
+                                                    ShaderProgram source,
+                                                    string name
+        )
         {
             NativeCamera.GainAllUniforms(source, name);
             return NativeCamera.convertedUniform;
@@ -145,30 +153,41 @@ namespace StgSharp.Graphics.OpenGL
         protected sealed override void NativeCameraViewRange(
                                        Radius fieldOfRange,
                                        Vec2 offset,
-                                       (float frontDepth, float backDepth) viewDepth)
+                                       (float frontDepth, float backDepth) viewDepth
+        )
         {
             NativeCamera.SetViewRange(fieldOfRange, this.Size, offset, viewDepth);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        protected sealed override void NativeCameraViewTarget(Vec3 position, Vec3 direction, Vec3 up)
+        protected sealed override void NativeCameraViewTarget(
+                                       Vec3 position,
+                                       Vec3 direction,
+                                       Vec3 up
+        )
         {
             NativeCamera.SetViewDirection(position, direction, up);
         }
 
         #region Key Control
 
-        protected KeyStatus CheckKey(KeyboardKey key)
+        protected KeyStatus CheckKey(
+                            KeyboardKey key
+        )
         {
             return GraphicFramework.glfwGetKey(this.CanvasHandle, (int)key);
         }
 
-        protected KeyStatus CheckKey(Mouse key)
+        protected KeyStatus CheckKey(
+                            Mouse key
+        )
         {
             return GraphicFramework.glfwGetKey(this.CanvasHandle, (int)key);
         }
 
-        protected KeyStatus CheckKey(Joystick key)
+        protected KeyStatus CheckKey(
+                            Joystick key
+        )
         {
             return GraphicFramework.glfwGetKey(this.CanvasHandle, (int)key);
         }

StgSharp.Common/Graphics/OpenGL/glType.cs

@@ -1,4 +1,4 @@
-//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 // file="glType"
 // Project: StgSharp
@@ -35,7 +35,9 @@ namespace StgSharp.Graphics.OpenGL
 {
     internal delegate void GLVULKANPROCNV();
 
-    public unsafe struct glHandleARB(IntPtr value) { }
+    public unsafe struct glHandleARB(
+                         IntPtr value
+    ) { }
 
     /// <summary>
     ///   OpenGL numeric type. An IEEE-754 floating-point value, clamped to the range [0,1].
@@ -46,7 +48,9 @@ namespace StgSharp.Graphics.OpenGL
 
         public float value;
 
-        public GlClampF(float a)
+        public GlClampF(
+               float a
+        )
         {
             value = a;
         }
@@ -54,7 +58,9 @@ namespace StgSharp.Graphics.OpenGL
     }
 
     [StructLayout(LayoutKind.Explicit, Size = 16)]
-    public struct glHalfNv(Half bin)
+    public struct glHalfNv(
+                  Half bin
+    )
     {
 
         [FieldOffset(0)] public Half binary = bin;
@@ -66,6 +72,14 @@ namespace StgSharp.Graphics.OpenGL
 
     }
 
+    [StructLayout(LayoutKind.Sequential)]
+    public struct glSync
+    {
+
+        public IntPtr Handle;
+
+    }
+
     [StructLayout(LayoutKind.Explicit, Size = 8)]
     public struct GlFixed
     {
@@ -86,7 +100,9 @@ namespace StgSharp.Graphics.OpenGL
 
         public double value;
 
-        public GlClampD(double a)
+        public GlClampD(
+               double a
+        )
         {
             value = a;
         }

StgSharp.Common/Graphics/framework.cs

@@ -1,4 +1,4 @@
-//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 // file="framework"
 // Project: StgSharp
@@ -43,15 +43,25 @@ namespace StgSharp.Graphics
     /// <returns>
     ///   An Intptr value representing the pointer to the function
     /// </returns>
-    public delegate IntPtr glLoader(string name);
+    public delegate IntPtr glLoader(
+                           string name
+    );
 
     #region StgSharpDele
 
     [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
-    public unsafe delegate void FrameBufferSizeHandler(IntPtr window, int width, int height);
+    public unsafe delegate void FrameBufferSizeHandler(
+                                IntPtr window,
+                                int width,
+                                int height
+    );
 
     [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
-    public unsafe delegate void FramePositionHandler(IntPtr window, float width, float height);
+    public unsafe delegate void FramePositionHandler(
+                                IntPtr window,
+                                float width,
+                                float height
+    );
 
     #endregion
 
@@ -65,7 +75,8 @@ namespace StgSharp.Graphics
                                   int severity,
                                   int length,
                                   sbyte* message,
-                                  void* userParam);
+                                  void* userParam
+    );
     internal unsafe delegate void GLDEBUGPROCARB(
                                   int source,
                                   int type,
@@ -73,7 +84,8 @@ namespace StgSharp.Graphics
                                   int severity,
                                   int length,
                                   sbyte* message,
-                                  void* userParam);
+                                  void* userParam
+    );
     internal unsafe delegate void GLDEBUGPROCKHR(
                                   int source,
                                   int type,
@@ -81,14 +93,16 @@ namespace StgSharp.Graphics
                                   int severity,
                                   int length,
                                   sbyte* message,
-                                  void* userParam);
+                                  void* userParam
+    );
     internal unsafe delegate void GLDEBUGPROCAMD(
                                   uint id,
                                   int category,
                                   int severity,
                                   int length,
                                   sbyte* message,
-                                  void* userParam);
+                                  void* userParam
+    );
 
 #endregion
 

StgSharp.Common/HighPerformance/Lable.cs

@@ -49,7 +49,7 @@ namespace StgSharp.HighPerformance
         {
             ReadOnlySpan<char> nameSpan = Name.AsSpan();
             fixed (char* cptr = nameSpan) {
-                return NativeIntrinsic.Intrinsic.city_hash_simplify(cptr, Name.Length);
+                return NativeIntrinsic.Context.city_hash_simplify(cptr, Name.Length);
             }
         }
 

StgSharp.Common/HighPerformance/MatrixPanel.cs

@@ -61,17 +61,9 @@ namespace StgSharp.HighPerformance
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int ElementSideLength<T>() where T : unmanaged, INumber<T>
         {
-            return Math.Max(8, AlignmentBytes / sizeof(T));
+            return PanelSideLength<T>();
         }
 
-        // View an existing pointer; caller guarantees lifetime/alignment.
-        public static unsafe MatrixPanel<T>* FromPointer<T>(void* ptr)
-            where T : unmanaged, INumber<T>
-        {
-            return (MatrixPanel<T>*)Align64(ptr);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int MaxElementCount<T>() where T : unmanaged, INumber<T>
         {
             int side = ElementSideLength<T>();
@@ -115,28 +107,43 @@ namespace StgSharp.HighPerformance
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static int KernelSideCountAvx2<T>() where T : unmanaged, INumber<T>
         {
-            const int minQ = 8;
-            int lanes = 32 / sizeof(T);
-            int side = Math.Max(lanes, minQ);
-            return side / 4;
+            return PanelSideFromBits<T>(256) / 4;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static int KernelSideCountAvx512<T>() where T : unmanaged, INumber<T>
         {
-            const int minQ = 8;
-            int lanes = 64 / sizeof(T);
-            int side = Math.Max(lanes, minQ);
-            return side / 4;
+            return PanelSideFromBits<T>(512) / 4;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static int KernelSideCountSse<T>() where T : unmanaged, INumber<T>
         {
-            const int minQ = 4;
-            int lanes = 16 / sizeof(T);
-            int side = Math.Max(lanes, minQ);
-            return side / 4;
+            return PanelSideFromBits<T>(128) / 4;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static int PanelSideFromBits<T>(int vectorBits) where T : unmanaged, INumber<T>
+        {
+            int elemBits = sizeof(T) * 8;
+
+            // Q = max(4, vectorBits/64, vectorBits/elemBits)
+            int by64 = vectorBits / 64;
+            int byElem = vectorBits / elemBits;
+            int side = Math.Max(4, Math.Max(by64, byElem));
+            return side;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static int PanelSideLength<T>() where T : unmanaged, INumber<T>
+        {
+            return NativeIntrinsic.IntrinsicLevel switch
+            {
+                IntrinsicLevel.SSE => PanelSideFromBits<T>(128),
+                IntrinsicLevel.AVX2 => PanelSideFromBits<T>(256),
+                IntrinsicLevel.AVX512 => PanelSideFromBits<T>(512),
+                _ => 0
+            };
         }
 
     }

StgSharp.Common/HighPerformance/UnsafeCompute.cs

@@ -1,4 +1,4 @@
-//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 // file="UnsafeCompute"
 // Project: StgSharp
@@ -35,19 +35,19 @@ namespace StgSharp.HighPerformance
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static unsafe int CityHashSimplify(char* span, int length)
         {
-            return NativeIntrinsic.Intrinsic.city_hash_simplify(span, length);
+            return NativeIntrinsic.Context.city_hash_simplify(span, length);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static unsafe int CityHashSimplify(char* span, int begin, int length)
         {
-            return NativeIntrinsic.Intrinsic.city_hash_simplify(span + begin, length);
+            return NativeIntrinsic.Context.city_hash_simplify(span + begin, length);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static unsafe int IndexOfCharPair(char* source, int pairValue, int length)
         {
-            return NativeIntrinsic.Intrinsic.index_pair(source, pairValue, length);
+            return NativeIntrinsic.Context.index_pair(source, pairValue, length);
         }
 
     }

StgSharp.Common/Internal/Intrinsic/IntrinsicContext.cs

@@ -34,24 +34,40 @@ using System.Runtime.InteropServices.Marshalling;
 
 namespace StgSharp.Internal.Intrinsic
 {
+    [StructLayout(LayoutKind.Sequential)]
+    internal unsafe struct MatrixIntrinsic
+    {
+
+        public delegate* unmanaged[Cdecl]<void*, void*, void*, long, void> buffer_add;             //f32_buffer_add
+        public delegate* unmanaged[Cdecl]<void*, ScalarPacket*, long, void> buffer_fill;                //f32_buffer_fill
+        public delegate* unmanaged[Cdecl]<void*, void*, ScalarPacket*, long, void> buffer_scalar_mul;                //f32_buffer_s_m
+        public delegate* unmanaged[Cdecl]<void*, void*, void*, long, void> buffer_sub;             //f32_kernel_sub
+        public delegate* unmanaged[Cdecl]<void*, void*, void> buffer_transpose;                //f32_kernel_transpose
+        public delegate* unmanaged[Cdecl]<MatrixPanel*, MatrixKernel*, int, int, int, int, void> build_panel;              //f32_build_panel
+        public delegate* unmanaged[Cdecl]<MatrixPanel*, void> clear_panel;                      //f32_clear_panel
+        public delegate* unmanaged[Cdecl]<void*, void*, void*, void> panel_fma;               //f32_panel_fma
+        public delegate* unmanaged[Cdecl]<void*, ulong, ulong, ulong, void> pivot;               //f32_panel_mul
+        public delegate* unmanaged[Cdecl]<void*, void*, int, int, int, int, void> store_panel; //f32_store_panel
+
+    }
+
+    [InlineArray(4)]
+    internal unsafe struct MatrixIntrinsicArray
+    {
+
+        private MatrixIntrinsic e0;
+
+    }
+
     [StructLayout(LayoutKind.Sequential)]
     internal unsafe struct IntrinsicContext
     {
 
-        public delegate* unmanaged[Cdecl]<char*, int, int> city_hash_simplify;              //city_hash_simplify
-        public delegate* unmanaged[Cdecl]<void*, void*, void*, long, void> f32_buffer_add;             //f32_buffer_add
-        public delegate* unmanaged[Cdecl]<void*, ScalarPacket*,long, void> f32_buffer_fill;                //f32_buffer_fill
-        public delegate* unmanaged[Cdecl]<void*, void*, ScalarPacket*, long, void> f32_buffer_scalar_mul;                //f32_buffer_s_m
-        public delegate* unmanaged[Cdecl]<void*, void*, void*, long, void> f32_buffer_sub;             //f32_kernel_sub
-        public delegate* unmanaged[Cdecl]<void*, void*, void> f32_buffer_transpose;                //f32_kernel_transpose
-        public delegate* unmanaged[Cdecl]<MatrixPanel*, MatrixKernel*,  int, int, int, int, void> f32_build_panel;              //f32_build_panel
-        public delegate* unmanaged[Cdecl]<MatrixPanel*, void> f32_clear_panel;
-        public delegate* unmanaged[Cdecl]<Vector4*, Vector4*, void> f32_normalize_3;                //f32_normalize_3
-        public delegate* unmanaged[Cdecl]<void*, void*, void*, void> f32_panel_fma;               //f32_panel_fma
-        public delegate* unmanaged[Cdecl]<void*, void*, int, int, int, int, void> f32_store_panel; //f32_store_panel
-        public delegate* unmanaged[Cdecl]<int, ulong> factorial_simd;               //factorial_simd
-        public delegate* unmanaged[Cdecl]<char*, int, int, int> index_pair;             //index_pair
-        public delegate* unmanaged[Cdecl]<void*, void*, ScalarPacket*, long, void> variant ;              //variant 
+        public delegate* unmanaged[Cdecl]<char*, int, int> city_hash_simplify;              // city_hash_simplify
+        public delegate* unmanaged[Cdecl]<int, ulong> factorial_simd;                       // factorial_simd
+        public delegate* unmanaged[Cdecl]<char*, int, int, int> index_pair;                 // index_pair
+        public delegate* unmanaged[Cdecl]<Vector4*, Vector4*, void> vec_f32_normalize_3;   // f32_normalize_3
+        public MatrixIntrinsicArray mat;                                              // mat[4] in native order
 
         public IntrinsicContext()
         {

StgSharp.Common/Internal/Intrinsic/intrinsicContextProvider.cs

@@ -41,7 +41,7 @@ namespace StgSharp.Internal
 
         public static IntrinsicLevel IntrinsicLevel { get; set; }
 
-        internal static IntrinsicContext Intrinsic
+        internal static IntrinsicContext Context
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             get => _intrinsicContext;

StgSharp.Common/Internal/StructDefine.cs

@@ -1,4 +1,4 @@
-//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 // file="StructDefine"
 // Project: StgSharp
@@ -39,18 +39,6 @@ namespace StgSharp.Internal
 
     using GLFWbool = Boolean;
 
-    #region glad struct
-
-    [StructLayout(LayoutKind.Sequential)]
-    internal struct GLsync
-    {
-
-        public IntPtr Handle;
-
-    }
-
-        #endregion glad struct
-
     // strucs defined in GLFW3.h
 
     #region GLFW3 struct

StgSharp.Common/MVVM/ViewModel/ShowViewPort.cs

@@ -1,4 +1,4 @@
-//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 // file="ShowViewPort"
 // Project: StgSharp
@@ -53,7 +53,9 @@ namespace StgSharp.MVVM.ViewModel
         /// <summary>
         ///   CustomizeInit this form and render it on screen, and respond with operation
         /// </summary>
-        public unsafe void UseViewModel(string viewEntryName)
+        public unsafe void UseViewModel(
+                           string viewEntryName
+        )
         {
             CustomizeInitialize();
             UseViewInNextFrame(viewEntryName);
@@ -62,7 +64,9 @@ namespace StgSharp.MVVM.ViewModel
             if (_nextView != _currentView) {
                 _ = Interlocked.Exchange(ref _currentView, _nextView);
             }
-            Thread renderThread = new Thread((token) => {
+            Thread renderThread = new Thread((
+                                             token
+            ) => {
                 try
                 {
                     ProcessFrameWithoutEvent();
@@ -92,7 +96,9 @@ namespace StgSharp.MVVM.ViewModel
             frameTimeProvider.Dispose();
         }
 
-        protected void UseViewInNextFrame(string name)
+        protected void UseViewInNextFrame(
+                       string name
+        )
         {
             if (!allView.TryGetValue(name, out ViewBase v)) {
                 throw new KeyNotFoundException(
@@ -101,7 +107,10 @@ namespace StgSharp.MVVM.ViewModel
             CurrentView = v;
         }
 
-        private void CountFps(object sender, EventArgs e)
+        private void CountFps(
+                     object sender,
+                     EventArgs e
+        )
         {
             Interlocked.Exchange(ref _frameSpeed, _frameCount);
             Interlocked.Exchange(ref _frameCount, 0);
@@ -118,7 +127,10 @@ namespace StgSharp.MVVM.ViewModel
 
         private void ProcessFrameWithoutEvent()
         {
-            frameTimeProvider.TimeSpanRefreshed += (_, _) => { };
+            frameTimeProvider.TimeSpanRefreshed += (
+                                                   _,
+                                                   _
+            ) => { };
             while (_closed)
             {
                 foreach (ViewPort context in CurrentView.Render) {

StgSharp.Common/MVVM/ViewModel/ViewModel.cs

@@ -1,4 +1,4 @@
-//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 // file="ViewModel"
 // Project: StgSharp
@@ -62,55 +62,67 @@ namespace StgSharp.MVVM.ViewModel
         internal TimeSpanProvider frameTimeProvider;
         internal Vector4 backgroundColor;
 
-        protected ViewModelBase(int frameSpeed)
+        protected ViewModelBase(
+                  int frameSpeed
+        )
         {
             viewPortDisplay = new ViewPort();
             allView = [];
-            fpsCountProvider = new TimeSpanProvider(TimeSequence.CreateLinear(double.MaxValue, 1.0 / frameSpeed), TimeSpanProvider.DefaultProvider);
+            fpsCountProvider = new TimeSpanProvider(TimeSequence.CreateLinear(double.PositiveInfinity, 1.0 / frameSpeed), TimeSpanProvider.DefaultProvider);
             _frameSpeed = 0;
             _frameCount = 0;
             long frameLength = (FrameSpeed > 0) ? (1000L * 1000L / FrameSpeed) : 0;
-            frameTimeProvider = new TimeSpanProvider(TimeSequence.CreateLinear(double.MaxValue, 1.0 / frameSpeed), TimeSpanProvider.DefaultProvider);
+            frameTimeProvider = new TimeSpanProvider(TimeSequence.CreateLinear(double.PositiveInfinity, 1.0 / frameSpeed), TimeSpanProvider.DefaultProvider);
             SetFrameSizeCallback(DefaultFrameResizeCallback);
         }
 
-        protected ViewModelBase(double frameLength)
+        protected ViewModelBase(
+                  double frameLength
+        )
         {
             viewPortDisplay = new ViewPort();
             allView = [];
-            fpsCountProvider = new TimeSpanProvider(TimeSequence.CreateLinear(double.MaxValue, frameLength), TimeSpanProvider.DefaultProvider);
+            fpsCountProvider = new TimeSpanProvider(TimeSequence.CreateLinear(double.PositiveInfinity, frameLength), TimeSpanProvider.DefaultProvider);
             _frameSpeed = 0;
             _frameCount = 0;
             long _frameLength = (FrameSpeed > 0) ? ((long)(1000 * frameLength)) : 0;
-            frameTimeProvider = new TimeSpanProvider(TimeSequence.CreateLinear(double.MaxValue, frameLength), TimeSpanProvider.DefaultProvider);
+            frameTimeProvider = new TimeSpanProvider(TimeSequence.CreateLinear(double.PositiveInfinity, frameLength), TimeSpanProvider.DefaultProvider);
             SetFrameSizeCallback(DefaultFrameResizeCallback);
         }
 
-        public ViewModelBase(ViewPort vBinding, int frameSpeed)
+        public ViewModelBase(
+               ViewPort vBinding,
+               int frameSpeed
+        )
         {
             viewPortDisplay = vBinding;
             allView = [];
-            fpsCountProvider = new TimeSpanProvider(TimeSequence.CreateLinear(double.MaxValue, 1.0), TimeSpanProvider.DefaultProvider);
+            fpsCountProvider = new TimeSpanProvider(TimeSequence.CreateLinear(double.PositiveInfinity, 1.0), TimeSpanProvider.DefaultProvider);
             _frameSpeed = 0;
             _frameCount = 0;
             long frameLength = (frameSpeed > 0) ? (1000L * 1000L / frameSpeed) : 0;
-            frameTimeProvider = new TimeSpanProvider(TimeSequence.CreateLinear(double.MaxValue, 1.0 / frameSpeed), TimeSpanProvider.DefaultProvider);
+            frameTimeProvider = new TimeSpanProvider(TimeSequence.CreateLinear(double.PositiveInfinity, 1.0 / frameSpeed), TimeSpanProvider.DefaultProvider);
             SetFrameSizeCallback(DefaultFrameResizeCallback);
         }
 
-        public ViewModelBase(ViewPort vBinding, double frameLength)
+        public ViewModelBase(
+               ViewPort vBinding,
+               double frameLength
+        )
         {
             viewPortDisplay = vBinding;
             allView = [];
-            fpsCountProvider = new TimeSpanProvider(TimeSequence.CreateLinear(double.MaxValue, 1.0), TimeSpanProvider.DefaultProvider);
+            fpsCountProvider = new TimeSpanProvider(TimeSequence.CreateLinear(double.PositiveInfinity, 1.0), TimeSpanProvider.DefaultProvider);
             _frameSpeed = 0;
             _frameCount = 0;
             long _frameLength = (FrameSpeed > 0) ? ((long)(1000 * frameLength)) : 0;
-            frameTimeProvider = new TimeSpanProvider(TimeSequence.CreateLinear(double.MaxValue, frameLength), TimeSpanProvider.DefaultProvider);
+            frameTimeProvider = new TimeSpanProvider(TimeSequence.CreateLinear(double.PositiveInfinity, frameLength), TimeSpanProvider.DefaultProvider);
             SetFrameSizeCallback(DefaultFrameResizeCallback);
         }
 
-        public DataBindingEntry this[string name]
+        public DataBindingEntry this[
+                                string name
+        ]
         {
             get
             {
@@ -189,11 +201,15 @@ namespace StgSharp.MVVM.ViewModel
         ///   Maximum Size of current form. In form of a <see cref="Vec2" /> of (width,height)
         /// </param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetSizeLimit(Vec2 minSize, Vec2 maxSize)
+        public void SetSizeLimit(
+                    Vec2 minSize,
+                    Vec2 maxSize
+        )
         {
             ThreadHelper.MainThreadAssert();
-            GraphicFramework.glfwSetWindowSizeLimits(this.viewPortDisplay.ViewPortHandle, (int)minSize.X,
-                                                     (int)minSize.Y, (int)maxSize.X, (int)maxSize.Y);
+            GraphicFramework.glfwSetWindowSizeLimits(this.viewPortDisplay.ViewPortHandle,
+                                                     (int)minSize.X, (int)minSize.Y, (int)maxSize.X,
+                                                     (int)maxSize.Y);
         }
 
         /// <summary>
@@ -212,16 +228,26 @@ namespace StgSharp.MVVM.ViewModel
         ///   Maximum height of current form
         /// </param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetSizeLimit(int minWidth, int minHeight, int maxWidth, int maxHeight)
+        public void SetSizeLimit(
+                    int minWidth,
+                    int minHeight,
+                    int maxWidth,
+                    int maxHeight
+        )
         {
             ThreadHelper.MainThreadAssert();
-            GraphicFramework.glfwSetWindowSizeLimits(this.viewPortDisplay.ViewPortHandle, minWidth, minHeight, maxWidth,
-                                                     maxHeight);
+            GraphicFramework.glfwSetWindowSizeLimits(this.viewPortDisplay.ViewPortHandle, minWidth,
+                                                     minHeight, maxWidth, maxHeight);
         }
 
-        public abstract bool TryGetObjectReference(string name, out DataBindingEntry entry);
+        public abstract bool TryGetObjectReference(
+                             string name,
+                             out DataBindingEntry entry
+        );
 
-        protected unsafe void SetFrameSizeCallback(FrameBufferSizeHandler callback)
+        protected unsafe void SetFrameSizeCallback(
+                              FrameBufferSizeHandler callback
+        )
         {
             _resizeCallback = callback;
             IntPtr handlerPtr = Marshal.GetFunctionPointerForDelegate(callback);
@@ -229,7 +255,11 @@ namespace StgSharp.MVVM.ViewModel
                     viewPortDisplay.ViewPortHandle, (delegate* unmanaged[Cdecl]<IntPtr, int, int, void>)handlerPtr);
         }
 
-        private void DefaultFrameResizeCallback(IntPtr windowHandle, int width, int height)
+        private void DefaultFrameResizeCallback(
+                     IntPtr windowHandle,
+                     int width,
+                     int height
+        )
         {
             ViewPort.GetExistedViewPort(windowHandle, out ViewPort vp);
             vp.RequestFlushSizeInNextFrame(width, height);

StgSharp.Common/Mathematics/Graphic/Matrix44.cs

@@ -1,4 +1,4 @@
-//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 // file="Matrix44"
 // Project: StgSharp
@@ -45,13 +45,20 @@ namespace StgSharp.Mathematics.Graphic
         [FieldOffset(0)] internal ColumnSet4 mat;
         [FieldOffset(0)] internal MatrixKernel<float> kernel;
 
-        internal Matrix44(ColumnSet4 mat)
+        internal Matrix44(
+                 ColumnSet4 mat
+        )
         {
             Unsafe.SkipInit(out this);
             this.mat = mat;
         }
 
-        internal Matrix44(Vector4 vec0, Vector4 vec1, Vector4 vec2, Vector4 vec3)
+        internal Matrix44(
+                 Vector4 vec0,
+                 Vector4 vec1,
+                 Vector4 vec2,
+                 Vector4 vec3
+        )
         {
             Unsafe.SkipInit(out this);
             mat.colum0 = vec0;
@@ -81,7 +88,8 @@ namespace StgSharp.Mathematics.Graphic
                       float a30,
                       float a31,
                       float a32,
-                      float a33)
+                      float a33
+        )
         {
             Unsafe.SkipInit(out this);
             mat.colum0 = new Vector4(a00, a10, a20, a30);
@@ -90,7 +98,10 @@ namespace StgSharp.Mathematics.Graphic
             mat.colum3 = new Vector4(a03, a13, a23, a33);
         }
 
-        public unsafe float this[int rowNum, int columNum]
+        public unsafe float this[
+                            int rowNum,
+                            int columNum
+        ]
         {
             get
             {
@@ -132,29 +143,29 @@ namespace StgSharp.Mathematics.Graphic
 
         public static Matrix44 Unit => new Matrix44(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
 
-        public static Matrix44 WNegativeUnit => new Matrix44(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0,
-                                                             0, 0, -1);
+        public static Matrix44 WNegativeUnit => new Matrix44(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, -1);
 
-        public static Matrix44 XNegativeUnit => new Matrix44(-1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0,
-                                                             0, 0, 1);
+        public static Matrix44 XNegativeUnit => new Matrix44(-1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
 
-        public static Matrix44 YNegativeUnit => new Matrix44(1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1, 0, 0,
-                                                             0, 0, 1);
+        public static Matrix44 YNegativeUnit => new Matrix44(1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
 
-        public static Matrix44 ZNegativeUnit => new Matrix44(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, -1, 0, 0,
-                                                             0, 0, 1);
+        public static Matrix44 ZNegativeUnit => new Matrix44(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1);
 
         public ReadOnlySpan<float> AsSpan()
         {
             return MemoryMarshal.CreateReadOnlySpan(ref Unsafe.As<ColumnSet4, float>(ref mat), 16);
         }
 
-        public override bool Equals(object? obj)
+        public override bool Equals(
+                             object? obj
+        )
         {
             return obj is Matrix44 x && Equals(x);
         }
 
-        public bool Equals(Matrix44 other)
+        public bool Equals(
+                    Matrix44 other
+        )
         {
             return mat.Equals(other.mat);
         }
@@ -166,64 +177,72 @@ namespace StgSharp.Mathematics.Graphic
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal unsafe void InternalTranspose(ref Matrix44 transpose)
+        internal unsafe void InternalTranspose(
+                             ref Matrix44 transpose
+        )
         {
+            const int f32 = 0;
             fixed (MatrixKernel<float>* source = &this.kernel, target = &transpose.kernel) {
-                NativeIntrinsic.Intrinsic.f32_buffer_transpose(source, target);
+                NativeIntrinsic.Context.mat[f32].buffer_transpose(source, target);
             }
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static unsafe Matrix44 operator -(Matrix44 left, Matrix44 right)
+        public static unsafe Matrix44 operator -(
+                                               Matrix44 left,
+                                               Matrix44 right
+        )
         {
             Matrix44 ret = new();
-            NativeIntrinsic.Intrinsic.f32_buffer_sub(&left, &right, &ret, 1);
+            const int f32 = 0;
+            NativeIntrinsic.Context.mat[f32].buffer_sub(&left, &right, &ret, 1);
             return ret;
         }
 
-        public static bool operator !=(Matrix44 left, Matrix44 right)
+        public static bool operator !=(
+                                    Matrix44 left,
+                                    Matrix44 right
+        )
         {
             return !(left == right);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static unsafe Matrix44 operator *(Matrix44 mat, float value)
+        public static unsafe Matrix44 operator *(
+                                               Matrix44 mat,
+                                               float value
+        )
         {
             return new Matrix44(mat.mat.colum0 * value, mat.mat.colum1 * value,
                                 mat.mat.colum2 * value, mat.mat.colum3 * value);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Matrix44 operator *(Matrix44 left, Matrix44 right)
+        public static Matrix44 operator *(
+                                        Matrix44 left,
+                                        Matrix44 right
+        )
         {
             Matrix44 transpose = left.Transpose;
-            return new Matrix44(Vector4.Dot(transpose.mat.colum0, right.mat.colum0),
-                                Vector4.Dot(transpose.mat.colum0, right.mat.colum1),
-                                Vector4.Dot(transpose.mat.colum0, right.mat.colum2),
-                                Vector4.Dot(transpose.mat.colum0, right.mat.colum3),
-                                Vector4.Dot(transpose.mat.colum1, right.mat.colum0),
-                                Vector4.Dot(transpose.mat.colum1, right.mat.colum1),
-                                Vector4.Dot(transpose.mat.colum1, right.mat.colum2),
-                                Vector4.Dot(transpose.mat.colum1, right.mat.colum3),
-                                Vector4.Dot(transpose.mat.colum2, right.mat.colum0),
-                                Vector4.Dot(transpose.mat.colum2, right.mat.colum1),
-                                Vector4.Dot(transpose.mat.colum2, right.mat.colum2),
-                                Vector4.Dot(transpose.mat.colum2, right.mat.colum3),
-                                Vector4.Dot(transpose.mat.colum3, right.mat.colum0),
-                                Vector4.Dot(transpose.mat.colum3, right.mat.colum1),
-                                Vector4.Dot(transpose.mat.colum3, right.mat.colum2),
-                                Vector4.Dot(transpose.mat.colum3, right.mat.colum3));
+            return new Matrix44(Vector4.Dot(transpose.mat.colum0, right.mat.colum0), Vector4.Dot(transpose.mat.colum0, right.mat.colum1), Vector4.Dot(transpose.mat.colum0, right.mat.colum2), Vector4.Dot(transpose.mat.colum0, right.mat.colum3), Vector4.Dot(transpose.mat.colum1, right.mat.colum0), Vector4.Dot(transpose.mat.colum1, right.mat.colum1), Vector4.Dot(transpose.mat.colum1, right.mat.colum2), Vector4.Dot(transpose.mat.colum1, right.mat.colum3), Vector4.Dot(transpose.mat.colum2, right.mat.colum0), Vector4.Dot(transpose.mat.colum2, right.mat.colum1), Vector4.Dot(transpose.mat.colum2, right.mat.colum2), Vector4.Dot(transpose.mat.colum2, right.mat.colum3), Vector4.Dot(transpose.mat.colum3, right.mat.colum0), Vector4.Dot(transpose.mat.colum3, right.mat.colum1), Vector4.Dot(transpose.mat.colum3, right.mat.colum2), Vector4.Dot(transpose.mat.colum3, right.mat.colum3));
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static unsafe Matrix44 operator +(Matrix44 left, Matrix44 right)
+        public static unsafe Matrix44 operator +(
+                                               Matrix44 left,
+                                               Matrix44 right
+        )
         {
             Matrix44 ret = new();
-            NativeIntrinsic.Intrinsic.f32_buffer_add(&left, &right, &ret, 1);
+            const int f32 = 0;
+            NativeIntrinsic.Context.mat[f32].buffer_add(&left, &right, &ret, 1);
             return ret;
         }
 
-        public static bool operator ==(Matrix44 left, Matrix44 right)
+        public static bool operator ==(
+                                    Matrix44 left,
+                                    Matrix44 right
+        )
         {
             return left.Equals(right);
         }

StgSharp.Common/Mathematics/Linear/Matrix.cs

@@ -57,7 +57,10 @@ namespace StgSharp.Mathematics.Numeric
             _buffer = buffer;
         }
 
-        public T this[int x, int y]
+        public T this[
+                 int x,
+                 int y
+        ]
         {
             get
             {
@@ -108,7 +111,8 @@ namespace StgSharp.Mathematics.Numeric
         /// </exception>
         public unsafe Matrix<T> this[
                                 ReadOnlySpan<MatrixIndex> column,
-                                ReadOnlySpan<MatrixIndex> row]
+                                ReadOnlySpan<MatrixIndex> row
+        ]
         {
             get { throw new NotImplementedException(); }
             set { throw new NotImplementedException(); }
@@ -137,7 +141,10 @@ namespace StgSharp.Mathematics.Numeric
         protected internal int KernelRowLength => _size.KernelRowLength;
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe ref MatrixKernel<T> GetMatrixKernel(int x, int y)
+        public unsafe ref MatrixKernel<T> GetMatrixKernel(
+                                          int x,
+                                          int y
+        )
         {
             MatrixKernelEnumerator enumerator = new(_size.KernelColumnLength, _size.KernelRowLength,
                                                     x, y);
@@ -147,7 +154,10 @@ namespace StgSharp.Mathematics.Numeric
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal unsafe ref T GetElementUnsafe(int x, int y)
+        internal unsafe ref T GetElementUnsafe(
+                              int x,
+                              int y
+        )
         {
             // Caller guarantees: indices in range, layout is dense square.
             int k_c = y >> 2;
@@ -161,5 +171,37 @@ namespace StgSharp.Mathematics.Numeric
             return ref kernel[c, r];
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal unsafe MatrixKernel<T>* GetKernelAddressUnsafe(
+                                         int x,
+                                         int y
+        )
+        {
+            // Caller guarantees: indices in range, layout is dense square.
+            int k_c = y >> 2;
+            int k_r = x >> 2;
+
+            MatrixKernelEnumerator enumerator = new(_size.KernelColumnLength, _size.KernelRowLength,
+                                                    k_c, k_r);
+            return Buffer + _boarder.GetIndexOffset(k_c, k_r, in enumerator);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal unsafe ref MatrixKernel<T> GetKernelUnsafe(
+                                            int x,
+                                            int y
+        )
+        {
+            // Caller guarantees: indices in range, layout is dense square.
+            int k_c = y >> 2;
+            int k_r = x >> 2;
+            int c = y & 3;
+            int r = x & 3;
+
+            MatrixKernelEnumerator enumerator = new(_size.KernelColumnLength, _size.KernelRowLength,
+                                                    k_c, k_r);
+            return ref _buffer[_boarder.GetIndexOffset(k_c, k_r, in enumerator)];
+        }
+
     }
 }

StgSharp.Common/Mathematics/Scalar/Factorial.cs

@@ -1,4 +1,4 @@
-//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 // file="Factorial"
 // Project: StgSharp
@@ -55,7 +55,7 @@ namespace StgSharp.Mathematics
                 return factorialResult[n];
             }
             if (n < 30) {
-                return NativeIntrinsic.Intrinsic.factorial_simd(n);
+                return NativeIntrinsic.Context.factorial_simd(n);
             }
             double 
                 dn = n,

StgSharp.Common/Stg/CollisionTexture.cs

@@ -1,4 +1,4 @@
-//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 // file="CollisionTexture"
 // Project: StgSharp
@@ -47,7 +47,10 @@ namespace StgSharp.Stg
     public interface IOneDimensionalCollisionTexture2D
     {
 
-        public void Init(Radius angleStride, string name);
+        public void Init(
+                    Radius angleStride,
+                    string name
+        );
 
     }
 
@@ -70,7 +73,9 @@ namespace StgSharp.Stg
 
         public override bool IsContextSharable => false;
 
-        public void GenerateCollisionTexture(IEnumerable<IInstancingBuffer> bufferEnumeration)
+        public void GenerateCollisionTexture(
+                    IEnumerable<IInstancingBuffer> bufferEnumeration
+        )
         {
             fbo.Bind(0);
             GL.ClearColor(0, 0, 0, 1);
@@ -92,7 +97,8 @@ namespace StgSharp.Stg
 
                 vbo.WriteVectorData<Vec4>(0, item.CoordAndRotationSpan, BufferUsage.StreamDraw);
                 vao.SetVertexAttribute(1, 3, TypeCode.Single, false, 4 * sizeof(float), 0);
-                vao.SetVertexAttribute(2, 1, TypeCode.Single, false, 4 * sizeof(float), 3 * sizeof(float));
+                vao.SetVertexAttribute(2, 1, TypeCode.Single, false, 4 * sizeof(float),
+                                       3 * sizeof(float));
 
                 vbo.WriteScalerData<float>(2, item.ScalingSpan, BufferUsage.StreamDraw);
                 vao.SetVertexAttribute(3, 1, TypeCode.Single, false, sizeof(float), 0);
@@ -100,22 +106,23 @@ namespace StgSharp.Stg
                 vbo.WriteVectorData(1, g.VertexStream, BufferUsage.StreamDraw);
                 vao.SetVertexAttribute(0, 3, TypeCode.Single, false, 4 * sizeof(float), 0);
 
-                GL.DrawElementsInstanced(
-                    GeometryType.TRIANGLES, ((uint)g.VertexIndices.Length) / 3, TypeCode.UInt32,
-                    IntPtr.Zero, (uint)item.ScalingSpan.Length);
+                GL.DrawElementsInstanced(GeometryType.TRIANGLES, (g.VertexIndices.Length) / 3,
+                                         TypeCode.UInt32, IntPtr.Zero, item.ScalingSpan.Length);
             }
 
             t.Bind2D(0);
-            GL.GetTextureImage(
-                Texture2DTarget.Texture2D, 0, ImageChannel.SingleColor, PixelChannelLayout.Float,
-                textureOutput);
+            GL.GetTextureImage(Texture2DTarget.Texture2D, 0, ImageChannel.SingleColor,
+                               PixelChannelLayout.Float, textureOutput);
             VertexArray.BindNull();
         }
 
-        public void Init(Radius angleStride, string name)
+        public void Init(
+                    Radius angleStride,
+                    string name
+        )
         {
-            primeArgs = new ViewPort(
-                1, (int)((new Radius(Scalar.Pi)) / angleStride), name, IntPtr.Zero);
+            primeArgs = new ViewPort(1, (int)((new Radius(Scalar.Pi)) / angleStride), name,
+                                     IntPtr.Zero);
 
             PlatformSpecifiedInitialize();
             CustomizeInit();
@@ -155,15 +162,15 @@ namespace StgSharp.Stg
 
             t = CreateTexture(1);
             t.Bind2D(0);
-            GL.TextureImage2d<byte>
-                (Texture2DTarget.Texture2D, 0, ImageChannel.WithAlphaChannel, (uint)Width, (uint)Height
-                 , ImageChannel.WithAlphaChannel, PixelChannelLayout.Byte, Array.Empty<byte>());
+            GL.TextureImage2d<byte>(Texture2DTarget.Texture2D, 0, ImageChannel.WithAlphaChannel,
+                                    Width, Height, ImageChannel.WithAlphaChannel,
+                                    PixelChannelLayout.Byte, Array.Empty<byte>());
 
             t.Set2dWrapProperty(0, TextureWrap.Repeat, TextureWrap.Repeat);
             t.Set2dFilterProperty(0, TextureFilter.Nearest, TextureFilter.Nearest);
 
-            GL.FrameBufferTexture2d(
-                FrameBufferTarget.All, glAttachment.Color(0), Texture2DTarget.Texture2D, t[0], 0);
+            GL.FrameBufferTexture2d(FrameBufferTarget.All, glAttachment.Color(0),
+                                    Texture2DTarget.Texture2D, t[0], 0);
 
             GL.CombineFrameBufferRenderBuffer(FrameBufferAttachment.Color, rbo[0]);
 

StgSharp.GenerateGL/CodeGen/CsTypeMapper.cs

@@ -0,0 +1,192 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="CsTypeMapper"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. All rights reserved.
+//     
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//     
+// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+using System;
+
+namespace GenerateGL.CodeGen
+{
+    internal static class CsTypeMapper
+    {
+
+        public static string MapDelegateParameter(
+                             GlParam param
+        )
+        {
+            int pointerLevel = param.PointerLevel;
+            if (param.CType.Equals("GLchar", StringComparison.Ordinal) && pointerLevel > 0) {
+                return $"byte{new string('*', pointerLevel)}";
+            }
+
+            string mapped = MapType(param.CType, allowVoid:false);
+            if (pointerLevel > 0)
+            {
+                if (mapped == "void") {
+                    return $"void{new string('*', pointerLevel)}";
+                }
+                return $"{mapped}{new string('*', pointerLevel)}";
+            }
+            return mapped;
+        }
+
+        public static string MapDelegateReturn(
+                             string cType,
+                             int pointerLevel
+        )
+        {
+            string mapped = MapType(cType, allowVoid:true);
+            if (pointerLevel > 0) {
+                return $"{mapped}{new string('*', pointerLevel)}";
+            }
+            return mapped;
+        }
+
+        public static string MapParameter(
+                             GlParam param
+        )
+        {
+            if (param.PointerLevel == 0)
+            {
+                if (param.CType.Equals("GLenum", StringComparison.Ordinal) &&
+                    LooksLikeShaderType(param.Name) &&
+                    !param.IsPointer) {
+                    return "ShaderType";
+                }
+
+                if (param.CType.Equals("GLuint", StringComparison.Ordinal) &&
+                    LooksLikeHandle(param.Name) &&
+                    !param.IsPointer) {
+                    return "GlHandle";
+                }
+            }
+
+            int pointerLevel = param.PointerLevel;
+            if (param.CType.Equals("GLchar", StringComparison.Ordinal) && pointerLevel > 0) {
+                return $"byte{new string('*', pointerLevel)}";
+            }
+
+            string mapped = MapType(param.CType, allowVoid:false);
+            if (pointerLevel > 0)
+            {
+                if (mapped == "void") {
+                    return $"void{new string('*', pointerLevel)}";
+                }
+                return $"{mapped}{new string('*', pointerLevel)}";
+            }
+            return mapped;
+        }
+
+        public static string MapReturn(
+                             string cType,
+                             int pointerLevel
+        )
+        {
+            string mapped = MapType(cType, allowVoid:true);
+            if (pointerLevel > 0) {
+                return $"{mapped}{new string('*', pointerLevel)}";
+            }
+            return mapped;
+        }
+
+        public static bool TryMapConstPointerToSpan(
+                           GlParam param,
+                           out string spanElementType
+        )
+        {
+            spanElementType = string.Empty;
+            if (!param.IsConst || param.PointerLevel != 1) {
+                return false;
+            }
+
+            string mapped = MapType(param.CType, allowVoid:false);
+            if (mapped is "void") {
+                return false;
+            }
+
+            spanElementType = mapped;
+            return true;
+        }
+
+        private static bool LooksLikeHandle(
+                            string name
+        )
+        {
+            if (string.IsNullOrWhiteSpace(name)) {
+                return false;
+            }
+
+            return name.Contains("program", StringComparison.OrdinalIgnoreCase) ||
+                   name.Contains("shader", StringComparison.OrdinalIgnoreCase) ||
+                   name.Contains("buffer", StringComparison.OrdinalIgnoreCase) ||
+                   name.Contains("texture", StringComparison.OrdinalIgnoreCase) ||
+                   name.Contains("framebuffer", StringComparison.OrdinalIgnoreCase) ||
+                   name.Contains("renderbuffer", StringComparison.OrdinalIgnoreCase) ||
+                   name.Contains("vertexarray", StringComparison.OrdinalIgnoreCase) ||
+                   name.Contains("query", StringComparison.OrdinalIgnoreCase) ||
+                   name.Contains("sampler", StringComparison.OrdinalIgnoreCase) ||
+                   name.Contains("transformfeedback", StringComparison.OrdinalIgnoreCase);
+        }
+
+        private static bool LooksLikeShaderType(
+                            string name
+        )
+        {
+            if (string.IsNullOrWhiteSpace(name)) {
+                return false;
+            }
+            return name.Contains("shadertype", StringComparison.OrdinalIgnoreCase) ||
+                   name.Equals("type", StringComparison.OrdinalIgnoreCase);
+        }
+
+        private static string MapType(
+                              string cType,
+                              bool allowVoid
+        )
+        {
+            return cType switch
+            {
+                "void" when allowVoid => "void",
+                "GLenum" or "GLbitfield" => "uint",
+                "GLboolean" => "byte",
+                "GLuint" or "GLhandleARB" => "uint",
+                "GLint" or "GLsizei" or "GLfixed" => "int",
+                "GLshort" => "short",
+                "GLbyte" => "sbyte",
+                "GLubyte" => "byte",
+                "GLushort" => "ushort",
+                "GLfloat" => "float",
+                "GLdouble" => "double",
+                "GLclampf" or "GLclampd" => "float",
+                "GLintptr" => "nint",
+                "GLsizeiptr" => "nuint",
+                "GLchar" => "byte",
+                "GLsync" => "GLsync",
+                _ => allowVoid && cType == "void" ? "void" : "IntPtr"
+            };
+        }
+
+    }
+}

StgSharp.GenerateGL/CodeGen/Generator.cs

@@ -0,0 +1,422 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="Generator"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. All rights reserved.
+//     
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//     
+// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+using System;
+using System.Collections.Frozen;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+
+namespace GenerateGL.CodeGen
+{
+    internal sealed class Generator
+    {
+
+        private static readonly string[] TargetVersions = {
+            "3.3", "4.0", "4.1", "4.2", "4.3", "4.4", "4.5", "4.6"
+        };
+
+        private static readonly FrozenDictionary<string, string> ReservedNames =
+            new Dictionary<string, string>(StringComparer.Ordinal) {
+            { "string", "@string" }, { "class", "@class" }, { "namespace", "@namespace" }, { "checked", "@checked" }, { "unchecked", "@unchecked" }, { "ref", "@ref" }, { "out", "@out" }, { "in", "@in" }, { "object", "@object" }, { "event", "@event" }, { "params", "@params" }, { "base", "@base" }, { "this", "@this" }, { "void", "@void" }, { "int", "@int" }, { "uint", "@uint" }, { "long", "@long" }, { "ulong", "@ulong" }, { "short", "@short" }, { "ushort", "@ushort" }, { "float", "@float" }, { "double", "@double" }, { "decimal", "@decimal" }, { "bool", "@bool" }, { "byte", "@byte" }, { "sbyte", "@sbyte" }, { "char", "@char" }, { "struct", "@struct" }, { "public", "@public" }, { "private", "@private" }, { "protected", "@protected" }, { "internal", "@internal" }, { "fixed", "@fixed" }
+        }.ToFrozenDictionary(StringComparer.Ordinal);
+
+        private readonly IReadOnlyDictionary<string, GlCommand> _commands;
+        private readonly IReadOnlyList<GlFeature> _features;
+        private readonly string _outputRoot;
+
+        public Generator(
+               IReadOnlyDictionary<string, GlCommand> commands,
+               IReadOnlyList<GlFeature> features,
+               string outputRoot
+        )
+        {
+            _commands = commands;
+            _features = features;
+            _outputRoot = outputRoot;
+        }
+
+        public void Run()
+        {
+            if (Directory.Exists(_outputRoot)) {
+                Directory.Delete(_outputRoot, recursive:true);
+            }
+            Directory.CreateDirectory(_outputRoot);
+            List<GlCommand> all = new List<GlCommand>();
+            HashSet<string> previous = new HashSet<string>(StringComparer.Ordinal);
+            foreach (string v in TargetVersions)
+            {
+                IReadOnlyList<GlCommand> cmdsUpTo = CollectCommandsUpToVersion(v);
+                List<GlCommand> versionCmds = cmdsUpTo.Where(c => !previous.Contains(c.Name))
+                                                      .ToList();
+                foreach (GlCommand cmd in versionCmds) {
+                    previous.Add(cmd.Name);
+                }
+                all.AddRange(versionCmds);
+                WriteOpenGLFunctionFile(v, versionCmds);
+                WriteGlContextFile(v, versionCmds);
+            }
+            WriteMergedGlContextFile(all);
+            WriteCommandHistoryFile(BuildCommandHistory());
+        }
+
+        private IReadOnlyDictionary<string, List<CommandHistoryEntry>> BuildCommandHistory()
+        {
+            Dictionary<string, List<CommandHistoryEntry>> history = new(StringComparer.Ordinal);
+
+            IEnumerable<GlFeature> ordered = _features.Where(f => Version.TryParse(f.Version, out _))
+                                                      .OrderBy(f => Version.Parse(f.Version));
+
+            foreach (GlFeature feature in ordered)
+            {
+                string version = feature.Version;
+
+                foreach (string name in feature.RequiresCommands.Distinct(StringComparer.Ordinal))
+                {
+                    if (!_commands.ContainsKey(name) || ShouldSkip(name))
+                    {
+                        continue;
+                    }
+
+                    if (!history.TryGetValue(name, out List<CommandHistoryEntry>? list))
+                    {
+                        list = new List<CommandHistoryEntry>();
+                        history[name] = list;
+                    }
+
+                    if (list.Count == 0 ||
+                        list[^1].Action != CommandHistoryAction.Added ||
+                        list[^1].Version != version) {
+                        list.Add(new CommandHistoryEntry(version, CommandHistoryAction.Added));
+                    }
+                }
+
+                foreach (string name in feature.RemovedCommands.Distinct(StringComparer.Ordinal))
+                {
+                    if (!_commands.ContainsKey(name) || ShouldSkip(name))
+                    {
+                        continue;
+                    }
+
+                    if (!history.TryGetValue(name, out List<CommandHistoryEntry>? list))
+                    {
+                        list = new List<CommandHistoryEntry>();
+                        history[name] = list;
+                    }
+
+                    if (list.Count == 0 ||
+                        list[^1].Action != CommandHistoryAction.Removed ||
+                        list[^1].Version != version) {
+                        list.Add(new CommandHistoryEntry(version, CommandHistoryAction.Removed));
+                    }
+                }
+            }
+
+            return history;
+        }
+
+        private IReadOnlyList<GlCommand> CollectCommandsUpToVersion(
+                                         string version
+        )
+        {
+            Version target = Version.Parse(version);
+            IEnumerable<GlFeature> ordered = _features.Where(f => Version.TryParse(f.Version, out Version? fv) &&
+                                                                  fv <= target)
+                                                      .OrderBy(f => Version.Parse(f.Version));
+
+            HashSet<string> active = new HashSet<string>(StringComparer.Ordinal);
+
+            foreach (GlFeature feature in ordered)
+            {
+                foreach (string name in feature.RequiresCommands.Distinct(StringComparer.Ordinal))
+                {
+                    if (_commands.ContainsKey(name)) {
+                        active.Add(name);
+                    }
+                }
+
+                foreach (string name in feature.RemovedCommands.Distinct(StringComparer.Ordinal)) {
+                    active.Remove(name);
+                }
+            }
+
+            return active.Select(name => _commands.TryGetValue(name, out GlCommand? c) ? c : null)
+                         .Where(c => c != null)!
+                         .Cast<GlCommand>()
+                         .ToList();
+        }
+
+        private static string DelegateSignature(
+                              string ret,
+                              IReadOnlyList<string> paramTypes
+        )
+        {
+            if (paramTypes.Count == 0) {
+                return $"delegate*<{ret}>";
+            }
+            return $"delegate*<{string.Join(", ", paramTypes)}, {ret}>";
+        }
+
+        private static string SafeName(
+                              string name
+        )
+        {
+            if (string.IsNullOrWhiteSpace(name)) {
+                return "arg";
+            }
+
+            if (ReservedNames.TryGetValue(name, out string? mapped)) {
+                return mapped;
+            }
+
+            return name;
+        }
+
+        private static bool ShouldSkip(
+                            string name
+        )
+        {
+            // No skipping; include legacy/fixed-function APIs as well.
+            return false;
+        }
+
+        private static string TrimGlPrefix(
+                              string name
+        )
+        {
+            if (name.StartsWith("gl", StringComparison.Ordinal) && name.Length > 2) {
+                return name.Substring(2);
+            }
+            return name;
+        }
+
+        private void WriteCommandHistoryFile(
+                     IReadOnlyDictionary<string, List<CommandHistoryEntry>> history
+        )
+        {
+            StringBuilder sb = new StringBuilder();
+            sb.AppendLine("// <auto-generated>");
+            sb.AppendLine($"// Generated by StgSharp.GenerateGL on {DateTime.UtcNow.ToString("u", CultureInfo.InvariantCulture)}");
+            sb.AppendLine("// Command availability history");
+            sb.AppendLine("// </auto-generated>");
+            sb.AppendLine("using System;\nusing System.Collections.Frozen;\nusing System.Collections.Generic;\n");
+            sb.AppendLine("namespace StgSharp.Graphics.OpenGL");
+            sb.AppendLine("{");
+            sb.AppendLine("    internal enum CommandHistoryAction { Added, Removed }");
+            sb.AppendLine();
+            sb.AppendLine("    internal readonly record struct CommandHistoryEntry(string Version, CommandHistoryAction Action);");
+            sb.AppendLine();
+            sb.AppendLine("    internal static class GlCommandHistory");
+            sb.AppendLine("    {");
+            sb.AppendLine("        internal static readonly FrozenDictionary<string, CommandHistoryEntry[]> History = new Dictionary<string, CommandHistoryEntry[]>(StringComparer.Ordinal)");
+            sb.AppendLine("        {");
+
+            foreach (KeyValuePair<string, List<CommandHistoryEntry>> kvp in history.OrderBy(k => k.Key, StringComparer.Ordinal))
+            {
+                string events = string.Join(", ", kvp.Value
+                                                     .OrderBy(v => Version.Parse(v.Version))
+                                                     .Select(v => $"new CommandHistoryEntry(\"{v.Version}\", CommandHistoryAction.{v.Action})"));
+                sb.AppendLine($"            {{ \"{kvp.Key}\", new CommandHistoryEntry[] {{ {events} }} }},");
+            }
+
+            sb.AppendLine("        }.ToFrozenDictionary(StringComparer.Ordinal);");
+            sb.AppendLine("    }");
+            sb.AppendLine("}");
+
+            string fileName = Path.Combine(_outputRoot, "glCommandHistory.cs");
+            File.WriteAllText(fileName, sb.ToString(), Encoding.UTF8);
+        }
+
+        private void WriteGlContextFile(
+                     string version,
+                     IReadOnlyList<GlCommand> commands
+        )
+        {
+            StringBuilder sb = new StringBuilder();
+            sb.AppendLine("// <auto-generated>");
+            sb.AppendLine($"// Generated by StgSharp.GenerateGL on {DateTime.UtcNow.ToString("u", CultureInfo.InvariantCulture)}");
+            sb.AppendLine($"// Version: {version}");
+            sb.AppendLine("// </auto-generated>");
+            sb.AppendLine("using System;\nusing System.Runtime.CompilerServices;\n");
+            sb.AppendLine("namespace StgSharp.Graphics.OpenGL");
+            sb.AppendLine("{");
+            sb.AppendLine("    public unsafe partial struct OpenglContext");
+            sb.AppendLine("    {");
+            foreach (GlCommand cmd in commands.OrderBy(c => c!.Name, StringComparer.Ordinal))
+            {
+                string ret = CsTypeMapper.MapDelegateReturn(cmd.ReturnType, cmd.ReturnPointerLevel);
+                List<string> paramTypes = new List<string>();
+                foreach (GlParam p in cmd.Parameters)
+                {
+                    string mapped = CsTypeMapper.MapDelegateParameter(p);
+                    paramTypes.Add(mapped);
+                }
+                string decl = DelegateSignature(ret, paramTypes);
+                sb.AppendLine($"        internal unsafe {decl} {cmd.Name};");
+            }
+            sb.AppendLine("    }");
+            sb.AppendLine("}");
+
+            string fileName = Path.Combine(_outputRoot, $"glContext.v{version.Replace('.', '_')}.cs");
+            File.WriteAllText(fileName, sb.ToString(), Encoding.UTF8);
+        }
+
+        private void WriteMergedGlContextFile(
+                     IReadOnlyList<GlCommand> commands
+        )
+        {
+            List<GlCommand> distinct = commands.Where(c => !ShouldSkip(c.Name))
+                                               .GroupBy(c => c.Name, StringComparer.Ordinal)
+                                               .Select(g => g.First())
+                                               .OrderBy(c => c.Name, StringComparer.Ordinal)
+                                               .ToList();
+
+            StringBuilder sb = new StringBuilder();
+            sb.AppendLine("// <auto-generated>");
+            sb.AppendLine($"// Generated by StgSharp.GenerateGL on {DateTime.UtcNow.ToString("u", CultureInfo.InvariantCulture)}");
+            sb.AppendLine("// Aggregated GL3+ commands");
+            sb.AppendLine("// </auto-generated>");
+            sb.AppendLine("using System;\nusing System.Runtime.CompilerServices;\n");
+            sb.AppendLine("namespace StgSharp.Graphics.OpenGL");
+            sb.AppendLine("{");
+            sb.AppendLine("    public unsafe partial struct OpenglContext");
+            sb.AppendLine("    {");
+            foreach (GlCommand cmd in distinct)
+            {
+                string ret = CsTypeMapper.MapDelegateReturn(cmd.ReturnType, cmd.ReturnPointerLevel);
+                List<string> paramTypes = new List<string>();
+                foreach (GlParam p in cmd.Parameters)
+                {
+                    string mapped = CsTypeMapper.MapDelegateParameter(p);
+                    paramTypes.Add(mapped);
+                }
+                string decl = DelegateSignature(ret, paramTypes);
+                sb.AppendLine($"        internal unsafe {decl} {cmd.Name};");
+            }
+            sb.AppendLine("    }");
+            sb.AppendLine("}");
+
+            string fileName = Path.Combine(_outputRoot, "glContext.cs");
+            File.WriteAllText(fileName, sb.ToString(), Encoding.UTF8);
+        }
+
+        private void WriteOpenGLFunctionFile(
+                     string version,
+                     IReadOnlyList<GlCommand> commands
+        )
+        {
+            StringBuilder sb = new StringBuilder();
+            sb.AppendLine("// <auto-generated>");
+            sb.AppendLine($"// Generated by StgSharp.GenerateGL on {DateTime.UtcNow.ToString("u", CultureInfo.InvariantCulture)}");
+            sb.AppendLine($"// Version: {version}");
+            sb.AppendLine("// </auto-generated>");
+            sb.AppendLine("using System;\nusing System.Runtime.CompilerServices;\nusing System.Runtime.InteropServices;\nusing StgSharp.Graphics.OpenGL;\n");
+            sb.AppendLine("namespace StgSharp.Graphics.OpenGL");
+            sb.AppendLine("{");
+            sb.AppendLine("    public unsafe partial class OpenGLFunction");
+            sb.AppendLine("    {");
+            foreach (GlCommand cmd in commands.OrderBy(c => c!.Name, StringComparer.Ordinal))
+            {
+                string ret = CsTypeMapper.MapReturn(cmd.ReturnType, cmd.ReturnPointerLevel);
+                string rawName = cmd.Name; // original glXxx
+                string methodName = TrimGlPrefix(rawName);
+                List<string> paramList = new List<string>();
+                List<string> callArgs = new List<string>();
+                List<(string Type,string Name)> pinned = new();
+                foreach (GlParam p in cmd.Parameters)
+                {
+                    string pname = SafeName(p.Name);
+                    if (CsTypeMapper.TryMapConstPointerToSpan(p, out string spanElementType))
+                    {
+                        paramList.Add($"ReadOnlySpan<{spanElementType}> {pname}");
+                        pinned.Add((spanElementType, pname));
+                        callArgs.Add($"{pname}Ptr");
+                    } else
+                    {
+                        string mapped = CsTypeMapper.MapParameter(p);
+                        paramList.Add($"{mapped} {pname}");
+                        if (mapped == "GlHandle")
+                        {
+                            callArgs.Add($"{pname}.Value");
+                        } else
+                        {
+                            callArgs.Add(pname);
+                        }
+                    }
+                }
+                string signature = string.Join(", ", paramList);
+                string call = string.Join(", ", callArgs);
+                sb.AppendLine($"        [MethodImpl(MethodImplOptions.AggressiveInlining)]");
+                sb.AppendLine($"        public {ret} {methodName}({signature})");
+                sb.AppendLine("        {");
+                string prefix = ret == "void" ? string.Empty : "return ";
+                if (pinned.Count == 0)
+                {
+                    sb.AppendLine($"            {prefix}Context.{rawName}({call});");
+                } else
+                {
+                    string indent = "            ";
+                    foreach ((string Type, string Name) pin in pinned)
+                    {
+                        sb.AppendLine($"{indent}fixed ({pin.Type}* {pin.Name}Ptr = {pin.Name})");
+                        sb.AppendLine($"{indent}{{");
+                        indent += "    ";
+                    }
+                    sb.AppendLine($"{indent}{prefix}Context.{rawName}({call});");
+                    for (int i = 0; i < pinned.Count; i++)
+                    {
+                        indent = indent.Substring(0, indent.Length - 4);
+                        sb.AppendLine($"{indent}}}");
+                    }
+                }
+                sb.AppendLine("        }");
+                sb.AppendLine();
+            }
+            sb.AppendLine("    }");
+            sb.AppendLine("}");
+
+            string fileName = Path.Combine(_outputRoot, $"glFunction.v{version.Replace('.', '_')}.cs");
+            File.WriteAllText(fileName, sb.ToString(), Encoding.UTF8);
+        }
+
+        private enum CommandHistoryAction
+        {
+
+            Added,
+            Removed
+
+        }
+
+        private readonly record struct CommandHistoryEntry(
+                                       string Version,
+                                       CommandHistoryAction Action
+        );
+
+    }
+}

StgSharp.GenerateGL/CodeGen/GlXmlParser.cs

@@ -0,0 +1,184 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="GlXmlParser"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. All rights reserved.
+//     
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//     
+// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+
+namespace GenerateGL.CodeGen
+{
+    internal static class GlXmlParser
+    {
+
+        public static (IReadOnlyDictionary<string, GlCommand> Commands, IReadOnlyList<GlFeature> Features) Parse(
+                                                                                                           string xmlPath
+        )
+        {
+            XDocument doc = XDocument.Load(xmlPath, LoadOptions.PreserveWhitespace);
+            Dictionary<string, GlCommand> commands = ParseCommands(doc);
+            List<GlFeature> features = ParseFeatures(doc);
+            return (commands, features);
+        }
+
+        private static string BuildCType(
+                              XElement element
+        )
+        {
+            return BuildCType(element, out _, out _, out _);
+        }
+
+        private static string BuildCType(
+                              XElement element,
+                              out int pointerLevel,
+                              out bool isPointer,
+                              out bool isConst
+        )
+        {
+            // CType is usually text parts + <ptype>
+            IEnumerable<string> parts = element.Nodes()
+                                               .Select(n => n switch
+                                               {
+                                                   XText t => t.Value,
+                                                   XElement el when el.Name == "ptype" => el.Value,
+                                                   _ => string.Empty
+                                               });
+            string raw = string.Concat(parts).Trim();
+            pointerLevel = raw.Count(ch => ch == '*');
+            isPointer = pointerLevel > 0;
+            isConst = raw.Contains("const", StringComparison.OrdinalIgnoreCase);
+            string cleaned = raw.Replace("const", string.Empty, StringComparison.OrdinalIgnoreCase)
+                                .Replace("*", string.Empty)
+                                .Trim();
+            return cleaned;
+        }
+
+        private static Dictionary<string, GlCommand> ParseCommands(
+                                                     XDocument doc
+        )
+        {
+            Dictionary<string, GlCommand> dict = new Dictionary<string, GlCommand>(StringComparer.Ordinal);
+            IEnumerable<XElement> commandElements = doc.Root?.Element("commands")?.Elements("command") ??
+                Enumerable.Empty<XElement>();
+            foreach (XElement cmd in commandElements)
+            {
+                XElement? proto = cmd.Element("proto");
+                if (proto is null)
+                {
+                    continue;
+                }
+
+                string name = proto.Element("name")?.Value ?? string.Empty;
+                string returnType = BuildCType(proto, out int retPtrLevel, out _,
+                                               out bool retIsConst);
+
+                List<GlParam> parameters = new List<GlParam>();
+                foreach (XElement p in cmd.Elements("param"))
+                {
+                    string pName = p.Element("name")?.Value ?? string.Empty;
+                    string cType = BuildCType(p, out int pointerLevel, out _, out bool isConst);
+                    parameters.Add(new GlParam(pName, cType, pointerLevel, isConst));
+                }
+
+                if (!string.IsNullOrEmpty(name)) {
+                    dict[name] = new GlCommand(name, returnType, retPtrLevel, retIsConst,
+                                               parameters);
+                }
+            }
+            return dict;
+        }
+
+        private static List<GlFeature> ParseFeatures(
+                                       XDocument doc
+        )
+        {
+            List<GlFeature> list = new List<GlFeature>();
+            IEnumerable<XElement> featureElements = doc.Root?.Elements("feature") ??
+                Enumerable.Empty<XElement>();
+            foreach (XElement feature in featureElements)
+            {
+                string? api = feature.Attribute("api")?.Value;
+                if (!string.Equals(api, "gl", StringComparison.Ordinal))
+                {
+                    continue;
+                }
+
+                string? profile = feature.Attribute("profile")?.Value;
+
+                // Only core (or no profile for legacy) to stay aligned with core profile
+                if (!string.IsNullOrEmpty(profile) &&
+                    !string.Equals(profile, "core", StringComparison.Ordinal))
+                {
+                    continue;
+                }
+
+                string version = feature.Attribute("number")?.Value ?? string.Empty;
+                List<string> requires = new List<string>();
+                foreach (XElement req in feature.Elements("require"))
+                {
+                    string? reqProfile = req.Attribute("profile")?.Value;
+                    if (!string.IsNullOrEmpty(reqProfile) &&
+                        !string.Equals(reqProfile, "core", StringComparison.Ordinal))
+                    {
+                        continue;
+                    }
+
+                    foreach (XElement cmd in req.Elements("command"))
+                    {
+                        string? name = cmd.Attribute("name")?.Value;
+                        if (!string.IsNullOrEmpty(name)) {
+                            requires.Add(name);
+                        }
+                    }
+                }
+
+                List<string> removes = new List<string>();
+                foreach (XElement rem in feature.Elements("remove"))
+                {
+                    string? remProfile = rem.Attribute("profile")?.Value;
+                    if (!string.IsNullOrEmpty(remProfile) &&
+                        !string.Equals(remProfile, "core", StringComparison.Ordinal))
+                    {
+                        continue;
+                    }
+
+                    foreach (XElement cmd in rem.Elements("command"))
+                    {
+                        string? name = cmd.Attribute("name")?.Value;
+                        if (!string.IsNullOrEmpty(name)) {
+                            removes.Add(name);
+                        }
+                    }
+                }
+
+                list.Add(new GlFeature(version, requires, removes));
+            }
+            return list;
+        }
+
+    }
+}

StgSharp.GenerateGL/CodeGen/Models.cs

@@ -0,0 +1,57 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="Models"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. All rights reserved.
+//     
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//     
+// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+using System.Collections.Generic;
+
+namespace GenerateGL.CodeGen
+{
+    internal sealed record GlCommand(
+                           string Name,
+                           string ReturnType,
+                           int ReturnPointerLevel,
+                           bool ReturnIsConst,
+                           IReadOnlyList<GlParam> Parameters
+    );
+
+    internal sealed record GlParam(
+                           string Name,
+                           string CType,
+                           int PointerLevel,
+                           bool IsConst
+    )
+    {
+
+        public bool IsPointer => PointerLevel > 0;
+
+    }
+
+    internal sealed record GlFeature(
+                           string Version,
+                           IReadOnlyList<string> RequiresCommands,
+                           IReadOnlyList<string> RemovedCommands
+    );
+}

StgSharp.GenerateGL/Docs/SourceGenerator.md

@@ -0,0 +1,71 @@
+# StgSharp.GenerateGL 源生成器技术文档
+
+## 目标与范围
+- **输入**：Khronos OpenGL Registry `gl.xml`（Core Profile 为主，版本 3.3→4.6，可选扩展）。
+- **输出**：分版本 partial `glContext`（`delegate*` 字段）与 `OpenGLFunction` 包装方法（调用 `Context.glXxx`），以及新增常量/枚举补全文件，写入 `StgSharp.Common\Graphics\OpenGL\Generated\`。不改动现有手写文件。
+- **风格**：保持现有函数指针字段 + 薄封装方法模式；兼容现有命名和类型定义（如 `GlHandle`）。
+
+---
+
+## 阶段 1：输入解析（XML 读取与过滤）
+- 将 `gl.xml` 作为 AdditionalFile 或 EmbeddedResource，使用 `XmlReader` 流式解析。
+- 解析节点：
+  - `<commands><command>`：函数名、返回类型、参数。
+  - `<enums>`：常量。
+  - `<feature profile="core">`：按 `version` 收录命令/常量。
+  - `<extensions>`：可选扩展（ARB/KHR/EXT/NV）。
+- 过滤策略：仅 Core Profile 且版本 ≥ 3.3（3.3→4.6 递进）；扩展按启用列表追加。
+
+---
+
+## 阶段 2：类型映射与句柄规则
+- 整数：`GLenum`/`GLbitfield`→`uint`；`GLint`/`GLsizei`/`GLfixed`→`int`；`GLuint`→`uint`；`GLboolean`→`byte`（包装层可 bool→byte）。
+- 浮点：`GLfloat`→`float`；`GLdouble`→`double`。
+- 指针与尺寸：`void*`/`const void*`→`void*`；`GLintptr`→`nint`/`IntPtr`；`GLsizeiptr`/`size_t`→`nuint`/`UIntPtr`；`GLsync`→现有 `GLsync`/`IntPtr` 包装。
+- 字符串：`const GLchar*`→`byte*`（UTF-8），包装层可另行提供 string/Span<byte> 重载。
+- 调用约定：OpenGL APIENTRY 通常 stdcall（Windows）；保持与现有 `glContext` 字段一致（`delegate* unmanaged[Stdcall]` 或 `unmanaged[Cdecl]`，需与 loader 对齐）。
+- 句柄识别：包含 program/shader/buffer/texture/framebuffer/renderbuffer/vertexarray/query/sampler/transformfeedback 等对象名的 `GLuint` 参数 → 包装层使用 `GlHandle`，内部传 `handle.Value`。
+- glGet* 输出：保留指针签名，或另行生成 unsafe Span/stackalloc 适配器；核心先生成指针版。
+
+---
+
+## 阶段 3：版本分组与文件组织
+- 输出目录：`StgSharp.Common\Graphics\OpenGL\Generated\`
+- 每个版本生成独立 partial：
+  - `glContext.v33.cs`, `glContext.v40.cs`, …, `glContext.v46.cs`：`delegate*` 字段。
+  - `OpenGLFunction.v33.cs`, …：包装方法 `public void Foo(...) => Context.glFoo(...);`
+- 常量/枚举：`glConst.generated.cs`（或分版本补丁），避免与现有重复，先查已有定义再生成。
+- 命名空间：`StgSharp.Graphics.OpenGL`；类声明：`partial struct/partial class glContext`（按现有定义），`partial class OpenGLFunction`。
+
+---
+
+## 阶段 4：生成规则（函数表与包装）
+- `glContext` 字段：`internal unsafe delegate*<converted_sig> glFoo;`
+- `OpenGLFunction` 包装：薄封装直接转发；句柄参数用 `GlHandle`，内部传 `handle.Value`；`bool` 参数按底层 `GLboolean` 需要转换为 `byte/uint`。
+- 去重：若同名字段/方法已存在，跳过或比对签名避免重复生成。
+
+---
+
+## 阶段 5：增量源生成器结构
+- 步骤：
+  1. 收集 AdditionalFiles（`gl.xml`）。
+  2. 解析→建模（CommandModel, EnumModel, FeatureModel）。
+  3. 按版本/profile 过滤。
+  4. Emit：分文件输出（`SourceProductionContext.AddSource`）。
+- 配置建议：`LangVersion=preview`（支持 `delegate* unmanaged[Stdcall]`）；仅引用必要的 XML 解析库。
+
+---
+
+## 阶段 6：兼容性与发布注意
+- 不改动现有手写文件，仅追加 partial。
+- 常量值需与现有 `glConst` 保持一致，生成前检查重复。
+- 大 `gl.xml` 使用流式解析避免内存压力。
+- Loader（`wglGetProcAddress/glXGetProcAddress/eglGetProcAddress`）不在本轮生成，字段调用约定需与 loader 对齐。
+
+---
+
+## 下一步实施建议
+1. 将 `gl.xml` 添加为 AdditionalFile。
+2. 搭建增量生成器骨架：Parse → Filter → Emit。
+3. 先生成 3.3 子集验证编译，再扩展到 4.6。
+4. 按需追加扩展（ARB/KHR），保持可配置启用列表。

StgSharp.GenerateGL/GenerateGL.csproj

@@ -0,0 +1,65 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <Platforms>AnyCPU;x64</Platforms>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <None Update="xml\Genglvnd">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Update="xml\genglvnd.py">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Update="xml\genheaders.py">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Update="xml\gl.xml">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Update="xml\glx.xml">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Update="xml\glxproto.reserved.txt">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Update="xml\Makefile">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Update="xml\README.adoc">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Update="xml\readme.pdf">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Update="xml\readme.tex">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Update="xml\reg.py">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Update="xml\registry.rnc">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Update="xml\testesext.c">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Update="xml\testglext.c">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Update="xml\vendors.txt">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Update="xml\wgl.xml">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Update="xml\wgltypes.txt">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+
+</Project>

StgSharp.GenerateGL/Program.cs

@@ -0,0 +1,56 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="Program"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. All rights reserved.
+//     
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//     
+// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+using GenerateGL.CodeGen;
+using System;
+using System.IO;
+
+namespace GenerateGL
+{
+    internal class Program
+    {
+
+        private static void Main(
+                            string[] args
+        )
+        {
+            string baseDir = AppContext.BaseDirectory;
+            string xmlPath = Path.GetFullPath(Path.Combine(baseDir, "xml", "gl.xml"));
+            string outputRoot = Path.GetFullPath(Path.Combine(baseDir, "Generated"));
+
+            Console.WriteLine($"[GenerateGL] Loading registry: {xmlPath}");
+            var (commands, features) = GlXmlParser.Parse(xmlPath);
+            Console.WriteLine($"[GenerateGL] Commands: {commands.Count}, Features: {features.Count}");
+
+            Generator generator = new Generator(commands, features, outputRoot);
+            generator.Run();
+
+            Console.WriteLine($"[GenerateGL] Generated files under: {outputRoot}");
+        }
+
+    }
+}

StgSharp.GenerateGL/xml/Genglvnd

@@ -0,0 +1,4 @@
+#!/bin/sh
+for header in glcorearb.h glext.h gl.h ; do
+    ./genglvnd.py -registry drafts/GL/gl.xml drafts/GL/$header
+done

StgSharp.GenerateGL/xml/Makefile

@@ -0,0 +1,74 @@
+# Copyright 2013-2025 The Khronos Group Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# Generator scripts and options
+# GENOPTS can be e.g. '-noprotect'
+
+PYFILES = genheaders.py reg.py
+GENOPTS =
+GENHEADERS = ./genheaders.py $(GENOPTS)
+
+# Generate all headers for GL / GLES / WGL / GLX
+# Different headers depend on different XML registry files
+# The $(GENHEADERS) script has targets for the additional headers
+#   $(API)/GL/gl.h
+#   $(API)/GL/glx.h
+#   $(API)/GL/wgl.h
+# but these are experimental and not supported by Khronos. OpenGL
+# drivers and SDKs provided by OS vendors and IHVs include their own
+# platform-specific versions of these headers, where appropriate.
+
+API	   = ../api
+GLHEADERS  = $(API)/GL/glext.h \
+	     $(API)/GL/glcorearb.h \
+	     $(API)/GLES/gl.h \
+	     $(API)/GLES/glext.h \
+	     $(API)/GLES2/gl2.h \
+	     $(API)/GLES2/gl2ext.h \
+	     $(API)/GLES3/gl3.h \
+	     $(API)/GLSC2/glsc2.h \
+	     $(API)/GLSC2/glsc2ext.h
+
+GLXHEADERS = $(API)/GL/glxext.h
+WGLHEADERS = $(API)/GL/wglext.h \
+	     $(API)/GL/wgl.h
+ALLHEADERS = $(GLHEADERS) $(GLXHEADERS) $(WGLHEADERS)
+
+# Generated files to clean up
+TEXDIRT = readme.aux readme.idx readme.ilg readme.ind readme.log readme.toc readme.out
+PYDIRT	= diag.txt dumpReg.txt errwarn.txt reg.pyc
+
+default: $(ALLHEADERS)
+
+$(GLHEADERS): gl.xml $(PYFILES)
+	$(GENHEADERS) $@
+
+$(GLXHEADERS): glx.xml $(PYFILES)
+	$(GENHEADERS) $@ -registry glx.xml
+
+$(WGLHEADERS): wgl.xml $(PYFILES)
+	$(GENHEADERS) $@ -registry wgl.xml
+
+# Generate Relax NG XML schema from Compact schema
+
+registry.rng: registry.rnc
+	trang registry.rnc registry.rng
+
+# Verify all registry XML files against the schema
+
+validate:
+	jing -c registry.rnc gl.xml
+	jing -c registry.rnc glx.xml
+	jing -c registry.rnc wgl.xml
+
+# Documentation target
+
+readme.pdf: readme.tex
+	touch readme.ind
+	pdflatex readme.tex
+	pdflatex readme.tex
+	makeindex readme.idx
+	pdflatex readme.tex
+
+clean:
+	-rm -f $(PYDIRT) $(TEXDIRT)

StgSharp.GenerateGL/xml/README.adoc

@@ -0,0 +1,25 @@
+// Copyright 2017-2021 The Khronos Group Inc.
+// SPDX-License-Identifier: CC-BY-4.0
+
+# OpenGL XML API Registry
+
+This directory contains the OpenGL, GLX, and WGL XML API registries, in
+gl.xml, glx.xml, and wgl.xml respectively. They are used to reserve
+enumerant ranges for vendors working on new extensions, to register
+extension interfaces when an extension is published, and to generate the
+Khronos-supplied header files in ../api .
+
+The canonical versions are always found in the master branch of the github
+repository at https://github.com/KhronosGroup/OpenGL-Registry
+
+The 'validate' Makefile target uses the 'jing' tool to confirm that each XML
+file is structurally valid and conforms to the registry schema in
+registry.rnc. The schema is described in detail in readme.pdf.
+
+The 'default' Makefile target generates updated headers in ../api/ from the
+XML files.
+
+Note that while there are targets for ../api/{gl.h,glx.h,wgl.h} in
+genglvnd.py and genheaders.py, these targets are not generated by default
+and are experimental. At present, you should use the versions of these
+headers shipped with your OS or IHV SDK.

StgSharp.GenerateGL/xml/genglvnd.py

@@ -0,0 +1,628 @@
+#!/usr/bin/env python
+#
+# Copyright 2013-2025 The Khronos Group Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+import sys, time, pdb, string, cProfile
+from reg import *
+
+# debug - start header generation in debugger
+# dump - dump registry after loading
+# profile - enable Python profiling
+# protect - whether to use #ifndef protections
+# registry <filename> - use specified XML registry instead of gl.xml
+# target - string name of target header, or all targets if None
+# timeit - time length of registry loading & header generation
+# validate - validate return & parameter group tags against <group>
+debug   = False
+dump    = False
+profile = False
+protect = True
+target  = None
+timeit  = False
+validate= False
+# Default input / log files
+errFilename = None
+diagFilename = 'diag.txt'
+regFilename = 'gl.xml'
+
+if __name__ == '__main__':
+    i = 1
+    while (i < len(sys.argv)):
+        arg = sys.argv[i]
+        i = i + 1
+        if (arg == '-debug'):
+            write('Enabling debug (-debug)', file=sys.stderr)
+            debug = True
+        elif (arg == '-dump'):
+            write('Enabling dump (-dump)', file=sys.stderr)
+            dump = True
+        elif (arg == '-noprotect'):
+            write('Disabling inclusion protection in output headers', file=sys.stderr)
+            protect = False
+        elif (arg == '-profile'):
+            write('Enabling profiling (-profile)', file=sys.stderr)
+            profile = True
+        elif (arg == '-registry'):
+            regFilename = sys.argv[i]
+            i = i+1
+            write('Using registry ', regFilename, file=sys.stderr)
+        elif (arg == '-time'):
+            write('Enabling timing (-time)', file=sys.stderr)
+            timeit = True
+        elif (arg == '-validate'):
+            write('Enabling group validation (-validate)', file=sys.stderr)
+            validate = True
+        elif (arg[0:1] == '-'):
+            write('Unrecognized argument:', arg, file=sys.stderr)
+            exit(1)
+        else:
+            target = arg
+            write('Using target', target, file=sys.stderr)
+
+# Simple timer functions
+startTime = None
+def startTimer():
+    global startTime
+    startTime = time.process_time()
+def endTimer(msg):
+    global startTime
+    endTime = time.process_time()
+    if (timeit):
+        write(msg, endTime - startTime)
+        startTime = None
+
+# Load & parse registry
+reg = Registry()
+
+startTimer()
+tree = etree.parse(regFilename)
+endTimer('Time to make ElementTree =')
+
+startTimer()
+reg.loadElementTree(tree)
+endTimer('Time to parse ElementTree =')
+
+if (validate):
+    reg.validateGroups()
+
+if (dump):
+    write('***************************************')
+    write('Performing Registry dump to regdump.txt')
+    write('***************************************')
+    reg.dumpReg(filehandle = open('regdump.txt','w'))
+
+# Turn a list of strings into a regexp string matching exactly those strings
+def makeREstring(list):
+    return '^(' + '|'.join(list) + ')$'
+
+# These are "mandatory" OpenGL ES 1 extensions, to
+# be included in the core GLES/gl.h header.
+es1CoreList = [
+    'GL_OES_read_format',
+    'GL_OES_compressed_paletted_texture',
+    'GL_OES_point_size_array',
+    'GL_OES_point_sprite'
+]
+
+# These are extensions to be included in the libglvnd GL/gl.h header.
+glVndList = [
+    'GL_ARB_imaging',
+    'GL_ARB_multitexture'
+]
+
+# Descriptive names for various regexp patterns used to select
+# versions and extensions
+
+allVersions       = allExtensions = '.*'
+noVersions        = noExtensions = None
+gl13Pat           = r'1\.[0-3]'
+gl12andLaterPat   = r'1\.[2-9]|[234]\.[0-9]'
+gles2onlyPat      = r'2\.[0-9]'
+gles2through30Pat = r'2\.[0-9]|3\.0'
+gles2through31Pat = r'2\.[0-9]|3\.[01]'
+gles2through32Pat = r'2\.[0-9]|3\.[012]'
+es1CorePat        = makeREstring(es1CoreList)
+glVndPat          = makeREstring(glVndList)
+
+# Extensions in old glcorearb.h but not yet tagged accordingly in gl.xml
+glCoreARBPat      = None
+glx13andLaterPat  = r'1\.[3-9]'
+
+# Copyright text prefixing all headers (list of strings).
+prefixStrings = [
+    '/*',
+    '** Copyright 2013-2025 The Khronos Group Inc.',
+    '** SPDX-' + 'License-Identifier: MIT',
+    '**',
+    '** This header is generated from the Khronos OpenGL / OpenGL ES XML',
+    '** API Registry. The current version of the Registry, generator scripts',
+    '** used to make the header, and the header can be found at',
+    '**   https://github.com/KhronosGroup/OpenGL-Registry',
+    '*/',
+    ''
+]
+
+# glext.h / glcorearb.h define calling conventions inline (no GL *platform.h)
+glExtPlatformStrings = [
+    '#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__)',
+    '#ifndef WIN32_LEAN_AND_MEAN',
+    '#define WIN32_LEAN_AND_MEAN 1',
+    '#endif',
+    '#include <windows.h>',
+    '#endif',
+    '',
+    '#ifndef APIENTRY',
+    '#define APIENTRY',
+    '#endif',
+    '#ifndef APIENTRYP',
+    '#define APIENTRYP APIENTRY *',
+    '#endif',
+    '#ifndef GLAPI',
+    '#define GLAPI extern',
+    '#endif',
+    ''
+]
+
+glCorearbPlatformStrings = glExtPlatformStrings + [
+    '/* glcorearb.h is for use with OpenGL core profile implementations.',
+    '** It should should be placed in the same directory as gl.h and',
+    '** included as <GL/glcorearb.h>.',
+    '**',
+    '** glcorearb.h includes only APIs in the latest OpenGL core profile',
+    '** implementation together with APIs in newer ARB extensions which ',
+    '** can be supported by the core profile. It does not, and never will',
+    '** include functionality removed from the core profile, such as',
+    '** fixed-function vertex and fragment processing.',
+    '**',
+    '** Do not #include both <GL/glcorearb.h> and either of <GL/gl.h> or',
+    '** <GL/glext.h> in the same source file.',
+    '*/',
+    ''
+]
+
+# wglext.h needs Windows include
+wglPlatformStrings = [
+    '#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__)',
+    '#define WIN32_LEAN_AND_MEAN 1',
+    '#include <windows.h>',
+    '#endif',
+    '',
+]
+
+# Different APIs use different *platform.h files to define calling
+# conventions
+glPlatformStrings    = [ '#include <GL/glplatform.h>', '' ]
+gles1PlatformStrings = [ '#include <GLES/glplatform.h>', '' ]
+gles2PlatformStrings = [ '#include <GLES2/gl2platform.h>', '' ]
+gles3PlatformStrings = [ '#include <GLES3/gl3platform.h>', '' ]
+glsc2PlatformStrings = [ '#include <GLSC2/gl2platform.h>', '' ]
+eglPlatformStrings   = [ '#include <EGL/eglplatform.h>', '' ]
+
+# GLES headers have a small addition to calling convention headers for function pointer typedefs
+apiEntryPrefixStrings = [
+    '#ifndef GL_APIENTRYP',
+    '#define GL_APIENTRYP GL_APIENTRY*',
+    '#endif',
+    ''
+]
+
+# Insert generation date in a comment for headers not having *GLEXT_VERSION macros
+genDateCommentString = [
+    format("/* Generated on date %s */" % time.strftime("%Y%m%d")),
+    ''
+]
+
+# GL_GLEXT_VERSION is defined only in glext.h and gl2ext.h
+glextVersionStrings = [
+    format("#define GL_GLEXT_VERSION %s" % time.strftime("%Y%m%d")),
+    ''
+]
+# WGL_WGLEXT_VERSION is defined only in wglext.h
+wglextVersionStrings = [
+    format("#define WGL_WGLEXT_VERSION %s" % time.strftime("%Y%m%d")),
+    ''
+]
+# GLX_GLXEXT_VERSION is defined only in glxext.h
+glxextVersionStrings = [
+    format("#define GLX_GLXEXT_VERSION %s" % time.strftime("%Y%m%d")),
+    ''
+]
+# EGL_EGLEXT_VERSION is defined only in eglext.h
+eglextVersionStrings = [
+    format("#define EGL_EGLEXT_VERSION %s" % time.strftime("%Y%m%d")),
+    ''
+]
+
+# Defaults for generating re-inclusion protection wrappers (or not)
+protectFile = protect
+protectFeature = protect
+protectProto = protect
+
+buildList = [
+    # GL API 1.2+ + extensions - GL/glext.h
+    CGeneratorOptions(
+        filename          = 'drafts/GL/glext.h',
+        apiname           = 'gl',
+        profile           = 'compatibility',
+        versions          = allVersions,
+        emitversions      = gl12andLaterPat,
+        defaultExtensions = 'gl',                   # Default extensions for GL
+        addExtensions     = None,
+        removeExtensions  = None,
+        prefixText        = prefixStrings + glExtPlatformStrings + glextVersionStrings,
+        genFuncPointers   = True,
+        protectFile       = protectFile,
+        protectFeature    = protectFeature,
+        protectProto      = protectProto,
+        protectProtoStr   = 'GL_GLEXT_PROTOTYPES',
+        apicall           = 'GLAPI ',
+        apientry          = 'APIENTRY ',
+        apientryp         = 'APIENTRYP '),
+    # GL compatibility profile through GL 1.3 (for libglvnd) - GL/gl.h
+    CGeneratorOptions(
+        filename          = 'drafts/GL/gl.h',
+        apiname           = 'gl',
+        profile           = 'compatibility',
+        versions          = allVersions,
+        emitversions      = gl13Pat,
+        defaultExtensions = None,                   # No extensions for gl.h
+        addExtensions     = glVndPat,
+        removeExtensions  = None,
+        prefixText        = prefixStrings + glPlatformStrings,
+        genFuncPointers   = True,
+        protectFile       = protectFile,
+        protectFeature    = protectFeature,
+        protectProto      = False,                  # gl.h always includes prototypes
+        protectProtoStr   = 'GL_GLEXT_PROTOTYPES',
+        apicall           = 'GLAPI ',
+        apientry          = 'APIENTRY ',
+        apientryp         = 'APIENTRYP '),
+    # GL core profile + extensions - GL/glcorearb.h
+    CGeneratorOptions(
+        filename          = 'drafts/GL/glcorearb.h',
+        apiname           = 'gl',
+        profile           = 'core',
+        versions          = allVersions,
+        emitversions      = allVersions,
+        defaultExtensions = 'glcore',               # Default extensions for GL core profile (only)
+        addExtensions     = glCoreARBPat,
+        removeExtensions  = None,
+        prefixText        = prefixStrings + glCorearbPlatformStrings,
+        genFuncPointers   = True,
+        protectFile       = protectFile,
+        protectFeature    = protectFeature,
+        protectProto      = protectProto,
+        protectProtoStr   = 'GL_GLEXT_PROTOTYPES',
+        apicall           = 'GLAPI ',
+        apientry          = 'APIENTRY ',
+        apientryp         = 'APIENTRYP '),
+    # GLES 1.x API + mandatory extensions - GLES/gl.h (no function pointers)
+    CGeneratorOptions(
+        filename          = 'GLES/gl.h',
+        apiname           = 'gles1',
+        profile           = 'common',
+        versions          = allVersions,
+        emitversions      = allVersions,
+        defaultExtensions = None,                   # No default extensions
+        addExtensions     = es1CorePat,             # Add mandatory ES1 extensions in GLES1/gl.h
+        removeExtensions  = None,
+        prefixText        = prefixStrings + gles1PlatformStrings + genDateCommentString,
+        genFuncPointers   = False,
+        protectFile       = protectFile,
+        protectFeature    = protectFeature,
+        protectProto      = False,                  # Core ES API functions are in the static link libraries
+        protectProtoStr   = 'GL_GLEXT_PROTOTYPES',
+        apicall           = 'GL_API ',
+        apientry          = 'GL_APIENTRY ',
+        apientryp         = 'GL_APIENTRYP '),
+    # GLES 1.x extensions - GLES/glext.h
+    CGeneratorOptions(
+        filename          = 'GLES/glext.h',
+        apiname           = 'gles1',
+        profile           = 'common',
+        versions          = allVersions,
+        emitversions      = noVersions,
+        defaultExtensions = 'gles1',                # Default extensions for GLES 1
+        addExtensions     = None,
+        removeExtensions  = es1CorePat,             # Remove mandatory ES1 extensions in GLES1/glext.h
+        prefixText        = prefixStrings + apiEntryPrefixStrings + genDateCommentString,
+        genFuncPointers   = True,
+        protectFile       = protectFile,
+        protectFeature    = protectFeature,
+        protectProto      = protectProto,
+        protectProtoStr   = 'GL_GLEXT_PROTOTYPES',
+        apicall           = 'GL_API ',
+        apientry          = 'GL_APIENTRY ',
+        apientryp         = 'GL_APIENTRYP '),
+    # GLES 2.0 API - GLES2/gl2.h (now with function pointers)
+    CGeneratorOptions(
+        filename          = 'GLES2/gl2.h',
+        apiname           = 'gles2',
+        profile           = 'common',
+        versions          = gles2onlyPat,
+        emitversions      = allVersions,
+        defaultExtensions = None,                   # No default extensions
+        addExtensions     = None,
+        removeExtensions  = None,
+        prefixText        = prefixStrings + gles2PlatformStrings + apiEntryPrefixStrings + genDateCommentString,
+        genFuncPointers   = True,
+        protectFile       = protectFile,
+        protectFeature    = protectFeature,
+        protectProto      = protectProto,           # Core ES API functions are in the static link libraries
+        protectProtoStr   = 'GL_GLEXT_PROTOTYPES',
+        apicall           = 'GL_APICALL ',
+        apientry          = 'GL_APIENTRY ',
+        apientryp         = 'GL_APIENTRYP '),
+    # GLES 3.1 / 3.0 / 2.0 extensions - GLES2/gl2ext.h
+    CGeneratorOptions(
+        filename          = 'GLES2/gl2ext.h',
+        apiname           = 'gles2',
+        profile           = 'common',
+        versions          = gles2onlyPat,
+        emitversions      = None,
+        defaultExtensions = 'gles2',                # Default extensions for GLES 2
+        addExtensions     = None,
+        removeExtensions  = None,
+        prefixText        = prefixStrings + apiEntryPrefixStrings + glextVersionStrings,
+        genFuncPointers   = True,
+        protectFile       = protectFile,
+        protectFeature    = protectFeature,
+        protectProto      = protectProto,
+        protectProtoStr   = 'GL_GLEXT_PROTOTYPES',
+        apicall           = 'GL_APICALL ',
+        apientry          = 'GL_APIENTRY ',
+        apientryp         = 'GL_APIENTRYP '),
+    # GLES 3.2 API - GLES3/gl32.h (now with function pointers)
+    CGeneratorOptions(
+        filename          = 'GLES3/gl32.h',
+        apiname           = 'gles2',
+        profile           = 'common',
+        versions          = gles2through32Pat,
+        emitversions      = allVersions,
+        defaultExtensions = None,                   # No default extensions
+        addExtensions     = None,
+        removeExtensions  = None,
+        prefixText        = prefixStrings + gles3PlatformStrings + apiEntryPrefixStrings + genDateCommentString,
+        genFuncPointers   = True,
+        protectFile       = protectFile,
+        protectFeature    = protectFeature,
+        protectProto      = protectProto,           # Core ES API functions are in the static link libraries
+        protectProtoStr   = 'GL_GLEXT_PROTOTYPES',
+        apicall           = 'GL_APICALL ',
+        apientry          = 'GL_APIENTRY ',
+        apientryp         = 'GL_APIENTRYP '),
+    # GLES 3.1 API - GLES3/gl31.h (now with function pointers)
+    CGeneratorOptions(
+        filename          = 'GLES3/gl31.h',
+        apiname           = 'gles2',
+        profile           = 'common',
+        versions          = gles2through31Pat,
+        emitversions      = allVersions,
+        defaultExtensions = None,                   # No default extensions
+        addExtensions     = None,
+        removeExtensions  = None,
+        prefixText        = prefixStrings + gles3PlatformStrings + apiEntryPrefixStrings + genDateCommentString,
+        genFuncPointers   = True,
+        protectFile       = protectFile,
+        protectFeature    = protectFeature,
+        protectProto      = protectProto,           # Core ES API functions are in the static link libraries
+        protectProtoStr   = 'GL_GLEXT_PROTOTYPES',
+        apicall           = 'GL_APICALL ',
+        apientry          = 'GL_APIENTRY ',
+        apientryp         = 'GL_APIENTRYP '),
+    # GLES 3.0 API - GLES3/gl3.h (now with function pointers)
+    CGeneratorOptions(
+        filename          = 'GLES3/gl3.h',
+        apiname           = 'gles2',
+        profile           = 'common',
+        versions          = gles2through30Pat,
+        emitversions      = allVersions,
+        defaultExtensions = None,                   # No default extensions
+        addExtensions     = None,
+        removeExtensions  = None,
+        prefixText        = prefixStrings + gles3PlatformStrings + apiEntryPrefixStrings + genDateCommentString,
+        genFuncPointers   = True,
+        protectFile       = protectFile,
+        protectFeature    = protectFeature,
+        protectProto      = protectProto,           # Core ES API functions are in the static link libraries
+        protectProtoStr   = 'GL_GLEXT_PROTOTYPES',
+        apicall           = 'GL_APICALL ',
+        apientry          = 'GL_APIENTRY ',
+        apientryp         = 'GL_APIENTRYP '),
+    # GLSC 2.0 API - GLSC2/glsc2.h
+    CGeneratorOptions(
+        filename          = 'GLSC2/glsc2.h',
+        apiname           = 'glsc2',
+        profile           = 'common',
+        versions          = gles2onlyPat,
+        emitversions      = allVersions,
+        defaultExtensions = None,                   # No default extensions
+        addExtensions     = None,
+        removeExtensions  = None,
+        prefixText        = prefixStrings + glsc2PlatformStrings + apiEntryPrefixStrings + genDateCommentString,
+        genFuncPointers   = False,
+        protectFile       = protectFile,
+        protectFeature    = protectFeature,
+        protectProto      = False,
+        protectProtoStr   = 'GL_GLEXT_PROTOTYPES',
+        apicall           = 'GL_APICALL ',
+        apientry          = 'GL_APIENTRY ',
+        apientryp         = 'GL_APIENTRYP '),
+    # GLSC 2.0 extensions - GLSC2/gl2ext.h
+    CGeneratorOptions(
+        filename          = 'GLSC2/glsc2ext.h',
+        apiname           = 'glsc2',
+        profile           = 'common',
+        versions          = gles2onlyPat,
+        emitversions      = None,
+        defaultExtensions = 'glsc2',                # Default extensions for GLSC 2
+        addExtensions     = None,
+        removeExtensions  = None,
+        prefixText        = prefixStrings + apiEntryPrefixStrings + genDateCommentString,
+        genFuncPointers   = False,
+        protectFile       = protectFile,
+        protectFeature    = protectFeature,
+        protectProto      = False,
+        protectProtoStr   = 'GL_GLEXT_PROTOTYPES',
+        apicall           = 'GL_APICALL ',
+        apientry          = 'GL_APIENTRY ',
+        apientryp         = 'GL_APIENTRYP '),
+    # EGL API - EGL/egl.h (no function pointers, yet @@@)
+    CGeneratorOptions(
+        filename          = 'EGL/egl.h',
+        apiname           = 'egl',
+        profile           = None,
+        versions          = allVersions,
+        emitversions      = allVersions,
+        defaultExtensions = None,                   # No default extensions
+        addExtensions     = None,
+        removeExtensions  = None,
+        prefixText        = prefixStrings + eglPlatformStrings + genDateCommentString,
+        genFuncPointers   = False,
+        protectFile       = protectFile,
+        protectFeature    = protectFeature,
+        protectProto      = False,
+        protectProtoStr   = 'EGL_EGLEXT_PROTOTYPES',
+        apicall           = 'EGLAPI ',
+        apientry          = 'EGLAPIENTRY ',
+        apientryp         = 'EGLAPIENTRYP '),
+    # EGL extensions - EGL/eglext.h (no function pointers, yet @@@)
+    CGeneratorOptions(
+        filename          = 'EGL/eglext.h',
+        apiname           = 'egl',
+        profile           = None,
+        versions          = allVersions,
+        emitversions      = None,
+        defaultExtensions = 'egl',                  # Default extensions for EGL
+        addExtensions     = None,
+        removeExtensions  = None,
+        prefixText        = prefixStrings + eglPlatformStrings + eglextVersionStrings,
+        genFuncPointers   = True,
+        protectFile       = protectFile,
+        protectFeature    = protectFeature,
+        protectProto      = protectProto,
+        protectProtoStr   = 'EGL_EGLEXT_PROTOTYPES',
+        apicall           = 'EGLAPI ',
+        apientry          = 'EGLAPIENTRY ',
+        apientryp         = 'EGLAPIENTRYP '),
+    # GLX 1.* API - GL/glx.h
+    CGeneratorOptions(
+        filename          = 'GL/glx.h',
+        apiname           = 'glx',
+        profile           = None,
+        versions          = allVersions,
+        emitversions      = allVersions,
+        defaultExtensions = None,                   # No default extensions
+        addExtensions     = None,
+        removeExtensions  = None,
+        # add glXPlatformStrings?
+        prefixText        = prefixStrings + genDateCommentString,
+        genFuncPointers   = True,
+        protectFile       = protectFile,
+        protectFeature    = protectFeature,
+        protectProto      = protectProto,
+        protectProtoStr   = 'GLX_GLXEXT_PROTOTYPES',
+        apicall           = '',
+        apientry          = '',
+        apientryp         = ' *'),
+    # GLX 1.3+ API + extensions - GL/glxext.h (no function pointers, yet @@@)
+    CGeneratorOptions(
+        filename          = 'GL/glxext.h',
+        apiname           = 'glx',
+        profile           = None,
+        versions          = allVersions,
+        emitversions      = glx13andLaterPat,
+        defaultExtensions = 'glx',                  # Default extensions for GLX
+        addExtensions     = None,
+        removeExtensions  = None,
+        # add glXPlatformStrings?
+        prefixText        = prefixStrings + glxextVersionStrings,
+        genFuncPointers   = True,
+        protectFile       = protectFile,
+        protectFeature    = protectFeature,
+        protectProto      = protectProto,
+        protectProtoStr   = 'GLX_GLXEXT_PROTOTYPES',
+        apicall           = '',
+        apientry          = '',
+        apientryp         = ' *'),
+    # WGL API + extensions - GL/wgl.h (no function pointers, yet @@@)
+    CGeneratorOptions(
+        filename          = 'GL/wgl.h',
+        apiname           = 'wgl',
+        profile           = None,
+        versions          = allVersions,
+        emitversions      = allVersions,
+        defaultExtensions = 'wgl',                  # Default extensions for WGL
+        addExtensions     = None,
+        removeExtensions  = None,
+        prefixText        = prefixStrings + wglPlatformStrings + genDateCommentString,
+        genFuncPointers   = True,
+        protectFile       = protectFile,
+        protectFeature    = protectFeature,
+        protectProto      = protectProto,
+        protectProtoStr   = 'WGL_WGLEXT_PROTOTYPES',
+        apicall           = '',
+        apientry          = 'WINAPI ',
+        apientryp         = 'WINAPI * '),
+    # WGL extensions - GL/wglext.h (no function pointers, yet @@@)
+    CGeneratorOptions(
+        filename          = 'GL/wglext.h',
+        apiname           = 'wgl',
+        profile           = None,
+        versions          = allVersions,
+        emitversions      = None,
+        defaultExtensions = 'wgl',                  # Default extensions for WGL
+        addExtensions     = None,
+        removeExtensions  = None,
+        prefixText        = prefixStrings + wglPlatformStrings + wglextVersionStrings,
+        genFuncPointers   = True,
+        protectFile       = protectFile,
+        protectFeature    = protectFeature,
+        protectProto      = protectProto,
+        protectProtoStr   = 'WGL_WGLEXT_PROTOTYPES',
+        apicall           = '',
+        apientry          = 'WINAPI ',
+        apientryp         = 'WINAPI * '),
+    # End of list
+    None
+]
+
+# create error/warning & diagnostic files
+if (errFilename):
+    errWarn = open(errFilename,'w')
+else:
+    errWarn = sys.stderr
+diag = open(diagFilename, 'w')
+
+def genHeaders():
+    # Loop over targets, building each
+    generated = 0
+    for genOpts in buildList:
+        if (genOpts == None):
+            break
+        if (target and target != genOpts.filename):
+            # write('*** Skipping', genOpts.filename)
+            continue
+        write('*** Building', genOpts.filename)
+        generated = generated + 1
+        startTimer()
+        gen = COutputGenerator(errFile=errWarn,
+                               warnFile=errWarn,
+                               diagFile=diag)
+        reg.setGenerator(gen)
+        reg.apiGen(genOpts)
+        write('** Generated', genOpts.filename)
+        endTimer('Time to generate ' + genOpts.filename + ' =')
+    if (target and generated == 0):
+        write('Failed to generate target:', target)
+
+if (debug):
+    pdb.run('genHeaders()')
+elif (profile):
+    import cProfile, pstats
+    cProfile.run('genHeaders()', 'profile.txt')
+    p = pstats.Stats('profile.txt')
+    p.strip_dirs().sort_stats('time').print_stats(50)
+else:
+    genHeaders()

StgSharp.GenerateGL/xml/genheaders.py

@@ -0,0 +1,577 @@
+#!/usr/bin/env python3
+#
+# Copyright 2013-2025 The Khronos Group Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+import sys, time, pdb, string, cProfile
+from reg import *
+
+# debug - start header generation in debugger
+# dump - dump registry after loading
+# profile - enable Python profiling
+# protect - whether to use #ifndef protections
+# registry <filename> - use specified XML registry instead of gl.xml
+# target - string name of target header, or all targets if None
+# timeit - time length of registry loading & header generation
+# validate - validate return & parameter group tags against <group>
+debug   = False
+dump    = False
+profile = False
+protect = True
+target  = None
+timeit  = False
+validate= False
+# Default input / log files
+errFilename = None
+diagFilename = 'diag.txt'
+regFilename = 'gl.xml'
+
+# Simple timer functions
+startTime = None
+def startTimer():
+    global startTime
+    startTime = time.process_time()
+def endTimer(msg):
+    global startTime
+    endTime = time.process_time()
+    if (timeit):
+        write(msg, endTime - startTime)
+        startTime = None
+
+# Turn a list of strings into a regexp string matching exactly those strings
+def makeREstring(list):
+    return '^(' + '|'.join(list) + ')$'
+
+# These are "mandatory" OpenGL ES 1 extensions, to
+# be included in the core GLES/gl.h header.
+es1CoreList = [
+    'GL_OES_read_format',
+    'GL_OES_compressed_paletted_texture',
+    'GL_OES_point_size_array',
+    'GL_OES_point_sprite'
+]
+
+# Descriptive names for various regexp patterns used to select
+# versions and extensions
+
+allVersions       = allExtensions = '.*'
+noVersions        = noExtensions = None
+gl12andLaterPat   = r'1\.[2-9]|[234]\.[0-9]'
+gles2onlyPat      = r'2\.[0-9]'
+gles2through30Pat = r'2\.[0-9]|3\.0'
+gles2through31Pat = r'2\.[0-9]|3\.[01]'
+gles2through32Pat = r'2\.[0-9]|3\.[012]'
+es1CorePat        = makeREstring(es1CoreList)
+# Extensions in old glcorearb.h but not yet tagged accordingly in gl.xml
+glCoreARBPat      = None
+glx13andLaterPat  = r'1\.[3-9]'
+
+# Copyright text prefixing all headers (list of strings).
+prefixStrings = [
+    '/*',
+    '** Copyright 2013-2025 The Khronos Group Inc.',
+    '** SPDX-' + 'License-Identifier: MIT',
+    '**',
+    '** This header is generated from the Khronos OpenGL / OpenGL ES XML',
+    '** API Registry. The current version of the Registry, generator scripts',
+    '** used to make the header, and the header can be found at',
+    '**   https://github.com/KhronosGroup/OpenGL-Registry',
+    '*/',
+    ''
+]
+
+# glext.h / glcorearb.h define calling conventions inline (no GL *platform.h)
+glExtPlatformStrings = [
+    '#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__)',
+    '#ifndef WIN32_LEAN_AND_MEAN',
+    '#define WIN32_LEAN_AND_MEAN 1',
+    '#endif',
+    '#include <windows.h>',
+    '#endif',
+    '',
+    '#ifndef APIENTRY',
+    '#define APIENTRY',
+    '#endif',
+    '#ifndef APIENTRYP',
+    '#define APIENTRYP APIENTRY *',
+    '#endif',
+    '#ifndef GLAPI',
+    '#define GLAPI extern',
+    '#endif',
+    ''
+]
+
+glCorearbPlatformStrings = glExtPlatformStrings + [
+    '/* glcorearb.h is for use with OpenGL core profile implementations.',
+    '** It should should be placed in the same directory as gl.h and',
+    '** included as <GL/glcorearb.h>.',
+    '**',
+    '** glcorearb.h includes only APIs in the latest OpenGL core profile',
+    '** implementation together with APIs in newer ARB extensions which ',
+    '** can be supported by the core profile. It does not, and never will',
+    '** include functionality removed from the core profile, such as',
+    '** fixed-function vertex and fragment processing.',
+    '**',
+    '** Do not #include both <GL/glcorearb.h> and either of <GL/gl.h> or',
+    '** <GL/glext.h> in the same source file.',
+    '*/',
+    ''
+]
+
+# wglext.h needs Windows include
+wglPlatformStrings = [
+    '#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__)',
+    '#define WIN32_LEAN_AND_MEAN 1',
+    '#include <windows.h>',
+    '#endif',
+    '',
+]
+
+# Different APIs use different *platform.h files to define calling
+# conventions
+gles1PlatformStrings = [ '#include <GLES/glplatform.h>', '' ]
+gles2PlatformStrings = [ '#include <GLES2/gl2platform.h>', '' ]
+gles3PlatformStrings = [ '#include <GLES3/gl3platform.h>', '' ]
+glsc2PlatformStrings = [ '#include <GLSC2/gl2platform.h>', '' ]
+eglPlatformStrings   = [ '#include <EGL/eglplatform.h>', '' ]
+
+# GLES headers have a small addition to calling convention headers for function pointer typedefs
+apiEntryPrefixStrings = [
+    '#ifndef GL_APIENTRYP',
+    '#define GL_APIENTRYP GL_APIENTRY*',
+    '#endif',
+    ''
+]
+
+# GLES 2/3 core API headers use a different protection mechanism for
+# prototypes, per bug 14206.
+glesProtoPrefixStrings = [
+    '#ifndef GL_GLES_PROTOTYPES',
+    '#define GL_GLES_PROTOTYPES 1',
+    '#endif',
+    ''
+]
+
+# Insert generation date in a comment for headers not having *GLEXT_VERSION macros
+genDateCommentString = [
+    format('/* Generated on date %s */' % time.strftime('%Y%m%d')),
+    ''
+]
+
+# GL_GLEXT_VERSION is defined only in glext.h and gl2ext.h
+glextVersionStrings = [
+    format('#define GL_GLEXT_VERSION %s' % time.strftime('%Y%m%d')),
+    ''
+]
+# WGL_WGLEXT_VERSION is defined only in wglext.h
+wglextVersionStrings = [
+    format('#define WGL_WGLEXT_VERSION %s' % time.strftime('%Y%m%d')),
+    ''
+]
+# GLX_GLXEXT_VERSION is defined only in glxext.h
+glxextVersionStrings = [
+    format('#define GLX_GLXEXT_VERSION %s' % time.strftime('%Y%m%d')),
+    ''
+]
+# This is a bad but functional workaround for a structural problem in the scripts
+# identified in https://github.com/KhronosGroup/OpenGL-Registry/pull/186#issuecomment-416196246
+glextKHRplatformStrings = [
+    '#include <KHR/khrplatform.h>',
+    ''
+]
+# EGL_EGLEXT_VERSION is defined only in eglext.h
+eglextVersionStrings = [
+    format('#define EGL_EGLEXT_VERSION %s' % time.strftime('%Y%m%d')),
+    ''
+]
+
+# Defaults for generating re-inclusion protection wrappers (or not)
+protectFile = protect
+protectFeature = protect
+protectProto = protect
+
+buildList = [
+    # GL API 1.2+ + extensions - GL/glext.h
+    CGeneratorOptions(
+        filename          = '../api/GL/glext.h',
+        apiname           = 'gl',
+        profile           = 'compatibility',
+        versions          = allVersions,
+        emitversions      = gl12andLaterPat,
+        defaultExtensions = 'gl',                   # Default extensions for GL
+        addExtensions     = None,
+        removeExtensions  = None,
+        prefixText        = prefixStrings + glExtPlatformStrings + glextVersionStrings + glextKHRplatformStrings,
+        genFuncPointers   = True,
+        protectFile       = protectFile,
+        protectFeature    = protectFeature,
+        protectProto      = protectProto,
+        protectProtoStr   = 'GL_GLEXT_PROTOTYPES',
+        apicall           = 'GLAPI ',
+        apientry          = 'APIENTRY ',
+        apientryp         = 'APIENTRYP '),
+    # GL core profile + extensions - GL/glcorearb.h
+    CGeneratorOptions(
+        filename          = '../api/GL/glcorearb.h',
+        apiname           = 'gl',
+        profile           = 'core',
+        versions          = allVersions,
+        emitversions      = allVersions,
+        defaultExtensions = 'glcore',               # Default extensions for GL core profile (only)
+        addExtensions     = glCoreARBPat,
+        removeExtensions  = None,
+        prefixText        = prefixStrings + glCorearbPlatformStrings,
+        genFuncPointers   = True,
+        protectFile       = protectFile,
+        protectFeature    = protectFeature,
+        protectProto      = protectProto,
+        protectProtoStr   = 'GL_GLEXT_PROTOTYPES',
+        apicall           = 'GLAPI ',
+        apientry          = 'APIENTRY ',
+        apientryp         = 'APIENTRYP '),
+    # GLES 1.x API + mandatory extensions - GLES/gl.h (no function pointers)
+    CGeneratorOptions(
+        filename          = '../api/GLES/gl.h',
+        apiname           = 'gles1',
+        profile           = 'common',
+        versions          = allVersions,
+        emitversions      = allVersions,
+        defaultExtensions = None,                   # No default extensions
+        addExtensions     = es1CorePat,             # Add mandatory ES1 extensions in GLES1/gl.h
+        removeExtensions  = None,
+        prefixText        = prefixStrings + gles1PlatformStrings + genDateCommentString,
+        genFuncPointers   = False,
+        protectFile       = protectFile,
+        protectFeature    = protectFeature,
+        protectProto      = False,                  # Core ES API functions are in the static link libraries
+        protectProtoStr   = 'GL_GLEXT_PROTOTYPES',
+        apicall           = 'GL_API ',
+        apientry          = 'GL_APIENTRY ',
+        apientryp         = 'GL_APIENTRYP '),
+    # GLES 1.x extensions - GLES/glext.h
+    CGeneratorOptions(
+        filename          = '../api/GLES/glext.h',
+        apiname           = 'gles1',
+        profile           = 'common',
+        versions          = allVersions,
+        emitversions      = noVersions,
+        defaultExtensions = 'gles1',                # Default extensions for GLES 1
+        addExtensions     = None,
+        removeExtensions  = es1CorePat,             # Remove mandatory ES1 extensions in GLES1/glext.h
+        prefixText        = prefixStrings + apiEntryPrefixStrings + genDateCommentString,
+        genFuncPointers   = True,
+        protectFile       = protectFile,
+        protectFeature    = protectFeature,
+        protectProto      = protectProto,
+        protectProtoStr   = 'GL_GLEXT_PROTOTYPES',
+        apicall           = 'GL_API ',
+        apientry          = 'GL_APIENTRY ',
+        apientryp         = 'GL_APIENTRYP '),
+    # GLES 2.0 API - GLES2/gl2.h (now with function pointers)
+    CGeneratorOptions(
+        filename          = '../api/GLES2/gl2.h',
+        apiname           = 'gles2',
+        profile           = 'common',
+        versions          = gles2onlyPat,
+        emitversions      = allVersions,
+        defaultExtensions = None,                   # No default extensions
+        addExtensions     = None,
+        removeExtensions  = None,
+        prefixText        = prefixStrings + gles2PlatformStrings + apiEntryPrefixStrings + glesProtoPrefixStrings + genDateCommentString,
+        genFuncPointers   = True,
+        protectFile       = protectFile,
+        protectFeature    = protectFeature,
+        protectProto      = 'nonzero',              # Core ES API functions are in the static link libraries
+        protectProtoStr   = 'GL_GLES_PROTOTYPES',
+        apicall           = 'GL_APICALL ',
+        apientry          = 'GL_APIENTRY ',
+        apientryp         = 'GL_APIENTRYP '),
+    # GLES 3.1 / 3.0 / 2.0 extensions - GLES2/gl2ext.h
+    CGeneratorOptions(
+        filename          = '../api/GLES2/gl2ext.h',
+        apiname           = 'gles2',
+        profile           = 'common',
+        versions          = gles2onlyPat,
+        emitversions      = None,
+        defaultExtensions = 'gles2',                # Default extensions for GLES 2
+        addExtensions     = None,
+        removeExtensions  = None,
+        prefixText        = prefixStrings + apiEntryPrefixStrings + glextVersionStrings,
+        genFuncPointers   = True,
+        protectFile       = protectFile,
+        protectFeature    = protectFeature,
+        protectProto      = protectProto,
+        protectProtoStr   = 'GL_GLEXT_PROTOTYPES',
+        apicall           = 'GL_APICALL ',
+        apientry          = 'GL_APIENTRY ',
+        apientryp         = 'GL_APIENTRYP '),
+    # GLES 3.2 API - GLES3/gl32.h (now with function pointers)
+    CGeneratorOptions(
+        filename          = '../api/GLES3/gl32.h',
+        apiname           = 'gles2',
+        profile           = 'common',
+        versions          = gles2through32Pat,
+        emitversions      = allVersions,
+        defaultExtensions = None,                   # No default extensions
+        addExtensions     = None,
+        removeExtensions  = None,
+        prefixText        = prefixStrings + gles3PlatformStrings + apiEntryPrefixStrings + glesProtoPrefixStrings + genDateCommentString,
+        genFuncPointers   = True,
+        protectFile       = protectFile,
+        protectFeature    = protectFeature,
+        protectProto      = 'nonzero',              # Core ES API functions are in the static link libraries
+        protectProtoStr   = 'GL_GLES_PROTOTYPES',
+        apicall           = 'GL_APICALL ',
+        apientry          = 'GL_APIENTRY ',
+        apientryp         = 'GL_APIENTRYP '),
+    # GLES 3.1 API - GLES3/gl31.h (now with function pointers)
+    CGeneratorOptions(
+        filename          = '../api/GLES3/gl31.h',
+        apiname           = 'gles2',
+        profile           = 'common',
+        versions          = gles2through31Pat,
+        emitversions      = allVersions,
+        defaultExtensions = None,                   # No default extensions
+        addExtensions     = None,
+        removeExtensions  = None,
+        prefixText        = prefixStrings + gles3PlatformStrings + apiEntryPrefixStrings + glesProtoPrefixStrings + genDateCommentString,
+        genFuncPointers   = True,
+        protectFile       = protectFile,
+        protectFeature    = protectFeature,
+        protectProto      = 'nonzero',              # Core ES API functions are in the static link libraries
+        protectProtoStr   = 'GL_GLES_PROTOTYPES',
+        apicall           = 'GL_APICALL ',
+        apientry          = 'GL_APIENTRY ',
+        apientryp         = 'GL_APIENTRYP '),
+    # GLES 3.0 API - GLES3/gl3.h (now with function pointers)
+    CGeneratorOptions(
+        filename          = '../api/GLES3/gl3.h',
+        apiname           = 'gles2',
+        profile           = 'common',
+        versions          = gles2through30Pat,
+        emitversions      = allVersions,
+        defaultExtensions = None,                   # No default extensions
+        addExtensions     = None,
+        removeExtensions  = None,
+        prefixText        = prefixStrings + gles3PlatformStrings + apiEntryPrefixStrings + glesProtoPrefixStrings + genDateCommentString,
+        genFuncPointers   = True,
+        protectFile       = protectFile,
+        protectFeature    = protectFeature,
+        protectProto      = 'nonzero',              # Core ES API functions are in the static link libraries
+        protectProtoStr   = 'GL_GLES_PROTOTYPES',
+        apicall           = 'GL_APICALL ',
+        apientry          = 'GL_APIENTRY ',
+        apientryp         = 'GL_APIENTRYP '),
+    # GLSC 2.0 API - GLSC2/glsc2.h
+    CGeneratorOptions(
+        filename          = '../api/GLSC2/glsc2.h',
+        apiname           = 'glsc2',
+        profile           = 'common',
+        versions          = gles2onlyPat,
+        emitversions      = allVersions,
+        defaultExtensions = None,                   # No default extensions
+        addExtensions     = None,
+        removeExtensions  = None,
+        prefixText        = prefixStrings + glsc2PlatformStrings + apiEntryPrefixStrings + genDateCommentString,
+        genFuncPointers   = False,
+        protectFile       = protectFile,
+        protectFeature    = protectFeature,
+        protectProto      = False,
+        protectProtoStr   = 'GL_GLEXT_PROTOTYPES',
+        apicall           = 'GL_APICALL ',
+        apientry          = 'GL_APIENTRY ',
+        apientryp         = 'GL_APIENTRYP '),
+    # GLSC 2.0 extensions - GLSC2/gl2ext.h
+    CGeneratorOptions(
+        filename          = '../api/GLSC2/glsc2ext.h',
+        apiname           = 'glsc2',
+        profile           = 'common',
+        versions          = gles2onlyPat,
+        emitversions      = None,
+        defaultExtensions = 'glsc2',                # Default extensions for GLSC 2
+        addExtensions     = None,
+        removeExtensions  = None,
+        prefixText        = prefixStrings + apiEntryPrefixStrings + genDateCommentString,
+        genFuncPointers   = False,
+        protectFile       = protectFile,
+        protectFeature    = protectFeature,
+        protectProto      = False,
+        protectProtoStr   = 'GL_GLEXT_PROTOTYPES',
+        apicall           = 'GL_APICALL ',
+        apientry          = 'GL_APIENTRY ',
+        apientryp         = 'GL_APIENTRYP '),
+    # GLX 1.* API - GL/glx.h (experimental)
+    CGeneratorOptions(
+        filename          = '../api/GL/glx.h',
+        apiname           = 'glx',
+        profile           = None,
+        versions          = allVersions,
+        emitversions      = allVersions,
+        defaultExtensions = None,                   # No default extensions
+        addExtensions     = None,
+        removeExtensions  = None,
+        # add glXPlatformStrings?
+        prefixText        = prefixStrings + genDateCommentString,
+        genFuncPointers   = True,
+        protectFile       = protectFile,
+        protectFeature    = protectFeature,
+        protectProto      = protectProto,
+        protectProtoStr   = 'GLX_GLXEXT_PROTOTYPES',
+        apicall           = '',
+        apientry          = '',
+        apientryp         = ' *'),
+    # GLX 1.3+ API + extensions - GL/glxext.h (no function pointers, yet @@@)
+    CGeneratorOptions(
+        filename          = '../api/GL/glxext.h',
+        apiname           = 'glx',
+        profile           = None,
+        versions          = allVersions,
+        emitversions      = glx13andLaterPat,
+        defaultExtensions = 'glx',                  # Default extensions for GLX
+        addExtensions     = None,
+        removeExtensions  = None,
+        # add glXPlatformStrings?
+        prefixText        = prefixStrings + glxextVersionStrings,
+        genFuncPointers   = True,
+        protectFile       = protectFile,
+        protectFeature    = protectFeature,
+        protectProto      = protectProto,
+        protectProtoStr   = 'GLX_GLXEXT_PROTOTYPES',
+        apicall           = '',
+        apientry          = '',
+        apientryp         = ' *'),
+    # WGL API + extensions - GL/wgl.h (experimenta; no function pointers, yet @@@)
+    CGeneratorOptions(
+        filename          = '../api/GL/wgl.h',
+        apiname           = 'wgl',
+        profile           = None,
+        versions          = allVersions,
+        emitversions      = allVersions,
+        defaultExtensions = 'wgl',                  # Default extensions for WGL
+        addExtensions     = None,
+        removeExtensions  = None,
+        prefixText        = prefixStrings + wglPlatformStrings + genDateCommentString,
+        genFuncPointers   = True,
+        protectFile       = protectFile,
+        protectFeature    = protectFeature,
+        protectProto      = protectProto,
+        protectProtoStr   = 'WGL_WGLEXT_PROTOTYPES',
+        apicall           = '',
+        apientry          = 'WINAPI ',
+        apientryp         = 'WINAPI * '),
+    # WGL extensions - GL/wglext.h (no function pointers, yet @@@)
+    CGeneratorOptions(
+        filename          = '../api/GL/wglext.h',
+        apiname           = 'wgl',
+        profile           = None,
+        versions          = allVersions,
+        emitversions      = None,
+        defaultExtensions = 'wgl',                  # Default extensions for WGL
+        addExtensions     = None,
+        removeExtensions  = None,
+        prefixText        = prefixStrings + wglPlatformStrings + wglextVersionStrings,
+        genFuncPointers   = True,
+        protectFile       = protectFile,
+        protectFeature    = protectFeature,
+        protectProto      = protectProto,
+        protectProtoStr   = 'WGL_WGLEXT_PROTOTYPES',
+        apicall           = '',
+        apientry          = 'WINAPI ',
+        apientryp         = 'WINAPI * '),
+    # End of list
+    None
+]
+
+def genHeaders():
+    # Loop over targets, building each
+    generated = 0
+    for genOpts in buildList:
+        if (genOpts == None):
+            break
+        if (target and target != genOpts.filename):
+            # write('*** Skipping', genOpts.filename)
+            continue
+        write('*** Building', genOpts.filename)
+        generated = generated + 1
+        startTimer()
+        gen = COutputGenerator(errFile=errWarn,
+                               warnFile=errWarn,
+                               diagFile=diag)
+        reg.setGenerator(gen)
+        reg.apiGen(genOpts)
+        write('** Generated', genOpts.filename)
+        endTimer('Time to generate ' + genOpts.filename + ' =')
+    if (target and generated == 0):
+        write('Failed to generate target:', target)
+
+
+if __name__ == '__main__':
+    i = 1
+    while (i < len(sys.argv)):
+        arg = sys.argv[i]
+        i = i + 1
+        if (arg == '-debug'):
+            write('Enabling debug (-debug)', file=sys.stderr)
+            debug = True
+        elif (arg == '-dump'):
+            write('Enabling dump (-dump)', file=sys.stderr)
+            dump = True
+        elif (arg == '-noprotect'):
+            write('Disabling inclusion protection in output headers', file=sys.stderr)
+            protect = False
+        elif (arg == '-profile'):
+            write('Enabling profiling (-profile)', file=sys.stderr)
+            profile = True
+        elif (arg == '-registry'):
+            regFilename = sys.argv[i]
+            i = i+1
+            write('Using registry ', regFilename, file=sys.stderr)
+        elif (arg == '-time'):
+            write('Enabling timing (-time)', file=sys.stderr)
+            timeit = True
+        elif (arg == '-validate'):
+            write('Enabling group validation (-validate)', file=sys.stderr)
+            validate = True
+        elif (arg[0:1] == '-'):
+            write('Unrecognized argument:', arg, file=sys.stderr)
+            exit(1)
+        else:
+            target = arg
+            write('Using target', target, file=sys.stderr)
+
+    # Load & parse registry
+    reg = Registry()
+
+    startTimer()
+    tree = etree.parse(regFilename)
+    endTimer('Time to make ElementTree =')
+
+    startTimer()
+    reg.loadElementTree(tree)
+    endTimer('Time to parse ElementTree =')
+
+    if (validate):
+        reg.validateGroups()
+
+    if (dump):
+        write('***************************************')
+        write('Performing Registry dump to regdump.txt')
+        write('***************************************')
+        reg.dumpReg(filehandle = open('regdump.txt','w'))
+
+    # create error/warning & diagnostic files
+    if (errFilename):
+        errWarn = open(errFilename,'w')
+    else:
+        errWarn = sys.stderr
+    diag = open(diagFilename, 'w')
+
+    if (debug):
+        pdb.run('genHeaders()')
+    elif (profile):
+        import cProfile, pstats
+        cProfile.run('genHeaders()', 'profile.txt')
+        p = pstats.Stats('profile.txt')
+        p.strip_dirs().sort_stats('time').print_stats(50)
+    else:
+        genHeaders()

StgSharp.GenerateGL/xml/glxproto.reserved.txt

@@ -0,0 +1,729 @@
+This is the registry of GLX opcodes, error codes, and event codes. It is
+very rarely modified since there is almost no interest in supporting GLX
+with modern OpenGL features, and the work of extending the XML schema to
+express it is not worthwhile.
+
+When new GLX protocol is needed for extension specifications, allocate it
+here and reflect it in the extension specification document as well as, if
+appropriate, glx.xml.
+
+Reserved opcode ranges assigned to vendors, and in some cases, opcodes
+actually assigned within that range are tracked here. Not all opcodes used
+by vendors are known.
+
+GLX Opcodes (8 bits)
+====================
+     1-15   GLX 1.0
+    16      Vendor Private
+    17      Vendor Private with Reply
+    18-20   GLX 1.1
+    21-32   GLX 1.3
+    33      glXSetClientInfoARB (GLX_ARB_create_context)
+    34      glXCreateContextAttribsARB (GLX_ARB_create_context)
+    35      glXSetClientInfo2ARB (GLX_ARB_create_context)
+
+GLX Vendor Private / Vendor Private with Reply opcodes (32-bits)
+                          (first 4 bytes past standard X header)
+================================================================
+
+     0     255  EXT (various - contact SGI)
+   256     271  HP (originally Compaq)
+      (272-511 unused)
+   512     575  E&S
+      (576-1023 unused)
+  1024    1269  EXT (various - contact SGI)
+      1024              GLX_EXT_import_context
+  1270    1275          NV_register_combiners
+  1276    1280          NV_fence
+  1281    1292          NVIDIA (use TBD; was intended for NV_vertex_program)
+  1293    1308          NV_vertex_program / ARB_vertex_program / ARB_fragment_program
+  1309                  NVIDIA (use TBD)
+  1310    1311          NV_fragment_program
+  1312                  NV_fence
+  1313    1318          GLX_NV_video_output
+  1319    1320          NV_vertex_program
+  1321    1326          NVIDIA (use TBD)
+  1327                  NV_register_combiners2
+  1328    1329          EXT_timer_query
+  1330    1331          GLX_EXT_texture_from_pixmap
+  1332    1339          NV_present_video
+  1340                  NVIDIA (use TBD)
+  1341                  GLX_NV_delay_before_swap
+  1342    1359          NVIDIA (use TBD)
+  1360                  GLX_NV_copy_image
+  1361    1364          NVIDIA (use TBD)
+  1365    1368          NV_gpu_program4
+  1369    1386          NVIDIA (use TBD)
+  1387    1388          GLX_NV_copy_buffer
+  1389    1399          NVIDIA (use TBD)
+  1400    1415          NV_video_capture
+  1416                  GLX_EXT_swap_control
+  1417    1420          NVIDIA (use TBD)
+  1421                  OES_single_precision (Khronos OpenGL ES 1.0)
+  1422    1428          EXT_framebuffer_object
+      (1429-2047 unused)
+  2048    2064  SUN
+  3000    3999  IBM
+  4096    5151  SGI (4106-5151 unused)
+      4096              SGIS_detail_texture
+      4097              SGIS_sharpen_texture
+      4098    4100      SGI_color_table
+      4101              SGIS_texture_filter4
+      4102    4104      SGIX_instruments
+      4105              SGIX_flush_raster
+  5152    5184  Mesa (unknown use)
+  8192    8207  HP
+ 16384   16399  ADD
+ 65536   66575  SGI (various GLX extensions)
+      65536             GLX_SGI_swap_control
+      65537             GLX_SGI_make_current_read
+      65538  65539      GLX_SGIX_video_source
+      65540  65542      GLX_SGIX_fbconfig
+      65543  65546      GLX_SGIX_pbuffer
+      65547             GLX_SGIX_swap_group
+      65548  65549      GLX_SGIX_swap_barrier
+      65550  65553      GLX_SGIX_hyperpipe_group
+      65554             GLX_SGIX_query_board_num (internal, for shm)
+
+OpenGL Single Opcodes (8 Bits)
+===============================
+
+   167-up Reserved
+         0     146  OpenGL 1.0/1.1 core
+       147     159  OpenGL 1.2 core
+       160     160  ARB_texture_compression
+       161     166  ARB_occlusion_query
+       167     178  ARB_shader_objects
+       179     181  ARB_vertex_shader
+       182     183  EXT_gpu_shader4
+       184     185  NV_vertex_program4
+       186     194  ARB_vertex_buffer_object
+       195     202  OpenGL 2.0 core
+       203     204  EXT_texture_integer
+       205     205  ARB_map_buffer_range
+       206     209  ARB_vertex_array_object
+       210     212  EXT_draw_buffers2
+       213     214  OpenGL 3.0 core
+       215     220  ARB_uniform_buffer_object
+       221          ARB_copy_buffer
+
+OpenGL Rendering Opcodes (16 Bits)
+==================================
+
+     0-1007 Reserved to ARB (231-1007 unused)
+         0     191  OpenGL 1.0 core (140 deprecated?)
+       192     194  OpenGL 1.1 core
+       195     196  OpenGL 1.2 core
+       197     213  ARB_multitexture
+       214     219  ARB_texture_compression
+       220     228  ARB_vertex_blend
+       229          ARB_multisample
+       230          ARB_window_pos
+       231     232  ARB_occlusion_query
+       233          ARB_draw_buffers
+       234          ARB_color_buffer_float
+       235     237  ARB_framebuffer_object
+       238     264  ARB_shader_object
+       265          ARB_vertex_shader
+       266     268  ARB_geometry_shader4
+       269     277  EXT_gpu_shader4
+       278     289  NV_vertex_program4
+       290     301  ARB_vertex_buffer_object
+       302     304  ARB_stencil_two_side
+       305     310  OpenGL 2.1 core
+       311     345  ARB_pixel_buffer_object
+       346     347  EXT_texture_integer
+       348     349  NV_conditional_render
+       350     351  ARB_vertex_array_object
+       352     354  EXT_draw_buffers2
+       355     363  OpenGL 3.0 core
+       364     365  NV_primitive_restart
+       366          ARB_uniform_buffer_object
+       367          ARB_texture_buffer_object
+  1008-1023 Reserved to IBM (unknown usage)
+  1024-1039 Reserved to HP (originally Compaq) (unknown usage)
+  1040-2047 Unused
+  2048-3071 Reserved to SGI (2083-3071 unused)
+      2048    2049  SGIS_multisample
+      2050          SGIX_tag_sample_buffer
+      2051          SGIS_detail_texture
+      2052          SGIS_sharpen_texture
+      2053    2056  SGI_color_table
+      2057    2058  SGIS_texture4D
+      2059          SGIX_pixel_texture
+      2060    2063  SGIX_sprite
+      2064          SGIS_texture_filter4
+      2065    2066  EXT_point_parameters/SGIS_point_parameters
+      2067          SGIS_fog_function
+      2068          unused?
+      2069    2070  SGIX_instruments
+      2071          SGIX_reference_plane
+      2072          SGIX_framezoom
+      2073    2076  unused?
+      2077          SGIX_instruments
+      2078    2081  SGIX_list_priority
+      2082          SGIS_texture_color_mask
+  3072-4095 Reserved to ARB (unused)
+  4096-5151 Reserved to EXT (4460-5151 unused)
+      4096          EXT_blend_color/1.2
+      4097          EXT_blend_minmax/1.2
+      4098          EXT_polygon_offset
+      4099    4100  EXT_subtexture
+      4101    4109  EXT_convolution/1.2
+      4110    4113  EXT_histogram/1.2
+      4114          EXT_texture3D/1.2
+      4115          EXT_subtexture/1.2
+      4116          EXT_vertex_array
+      4117    4118  EXT_texture_object/1.1
+      4119    4123  EXT_copy_texture/1.1
+      4124    4125  EXT_fog_coord
+      4126    4133  EXT_secondary_color
+      4134          EXT_blend_func_separate
+      4135          EXT_vertex_weighting
+      4136    4142  NV_register_combiners
+      4143    4144  NV_fence (4144 retired, used to be for FinishFence)
+      4145    4179  NVIDIA (use TBD; was intended for NV_vertex_program)
+      4180    4214  NV_vertex_program
+      4215    4217  ARB_vertex_program
+      4218    4219  NV_fragment_program
+      4220          EXT_stencil_two_side
+      4221    4222  NV_point_sprite
+      4223          EXT_stencil_clear_tag
+      4225          EXT_polygon_offset_clamp
+      4228          EXT_blend_equation_separate
+      4229          EXT_depth_bounds_test
+      4230    4239  ARB_vertex_program
+      4240    4264  NV_half_float
+      4265    4280  NVIDIA (use TBD)
+      4281    4282  EXT_gpu_program_parameters
+      4283    4285  NV_depth_buffer_float
+      4286    4290  NVIDIA (use TBD)
+      4291          NV_copy_image
+      4292    4293  EXT_texture_integer
+      4294    4307  NVIDIA (use TBD)
+      4308    4312  OES_single_precision (Khronos OpenGL ES 1.0)
+      4313    4315  SUN (use TBD)
+      4316    4325  EXT_framebuffer_object
+      4326    4329  ARB_matrix_palette
+      4330          EXT_framebuffer_blit
+      4331          EXT_framebuffer_multisample
+      4332    4347  NVIDIA (use TBD, bug 6720)
+      4348          NV_texture_barrier
+      4349    4459  NVIDIA (use TBD, bug 6720)
+
+  8192-8207  Reserved to HP (unknown usage)
+ 16384-16415 Reserved to SUN (unknown usage)
+ 24576-24607 Reserved to ADD (unknown usage)
+
+
+GLX Enumerateds (32 Bits)
+=========================
+0x0-0xFF      Reserved to EXT (visual attribute names)
+       0x1    0x11  GLX 1.0 (attribute names)
+      0x12    0x1F  unused?
+      0x20          GLX_EXT_visual_rating (attribute names)
+      0x21          unused?
+      0x22    0x28  GLX_EXT_visual_info (attribute names)
+0x1F00-0x1F02 Reserved to ARB (shared with WGL)
+    0x1F00  0x1F02  GLX_AMD_gpu_association
+0x2070-0x209F Reserved to ARB (shared with WGL)
+    0x2090  0x2094  GLX_ARB_create_context
+    0x2095          GL_ARB_vertex_buffer_object
+    0x2097  0x2098  GLX_ARB_context_flush_control
+0x20A0-0x219F Reserved to NVIDIA (shared with WGL)
+    0x20B0          GLX_NV_float_buffer
+    0x20B1          GLX_EXT_fbconfig_packed_float
+    0x20B2          GLX_ARB_framebuffer_sRGB (nee EXT)
+    0x20B3          GLX_NV_multisample_coverage
+    0x20B9          GLX_ARB_fbconfig_float
+    0x20C3  0x20CC  GLX_NV_video_out
+    0x20CD  0x20CF  GLX_NV_video_capture
+    0x20D0  0x20EB  GLX_EXT_texture_from_pixmap
+    0x20F0          GLX_NV_present_video
+    0x20F1  0x20F2  GLX_EXT_swap_control
+    0x20F3          GLX_EXT_swap_control_tear
+    0x20F4          GLX_EXT_buffer_age
+    0x20F5          GLX_EXT_stereo_tree
+    0x20F6          GLX_EXT_libglvnd
+    0x20F7          GLX_NV_robustness_video_memory_purge
+0x21A0-0x21AF Reserved to AMD (shared with WGL)
+    0x21A2  0x21A8  GLX_AMD_gpu_association
+0x31B3 Reserved to ARB (shared with WGL)
+    0x31B3          GLX_ARB_create_context_no_error
+0x8000-0x800F Reserved to EXT (0x800E-0x800F unused)
+    0x8000  0x8009  GLX_EXT_visual_info
+    0x800A  0x800C  GLX_EXT_import_context
+    0x800D          GLX_EXT_visual_rating
+0x8010-0x803F Reserved to SGI (0x8029-0x803F unused)
+    0x8010  0x8015  GLX_SGIX_fbconfig
+    0x8016  0x8023  GLX_SGIX_pbuffer
+    0x8024          GLX_SGIX_dm_buffer
+    0x8025          GLX_SGIS_blended_overlay
+    0x8026  0x8027  GLX_SGIS_shared_multisample
+    0x8028          GLX_SGIX_visual_select_group
+    0x8030          GLX_SGIX_hyperpipe
+0x8040-0x804F Reserved to OpenGL ARB
+    0x8040  0x8041  GLX 1.3
+0x8050-0x805F Reserved to 3Dfx
+    0x8050  0x8051  GLX_3DFX_multisample
+0x8060-0x806F Reserved to OpenML SIG
+    0x8060  0x8063  GLX_OML_swap_method
+0x8070-0x816F Reserved to NVIDIA
+0x8170-0x817F Reserved to SUN
+0x8180-0x818F Reserved to Intel (0x818F unused)
+    0x8180  0x8182  GLX_INTEL_swap_event
+    0x8183  0x818E  GLX_MESA_query_renderer
+0x8250-0x826F Reserved to ARB (Shared with GL and WGL)
+    0x8252          GLX_ARB_create_context_robustness
+    0x8256          GLX_ARB_create_context_robustness
+    0x8261          GLX_ARB_create_context_robustness
+0x9126        GLX_ARB_create_context_profile (shared with WGL)
+
+100000-100011 Reserved to SGI (100002-100011 unused)
+    100000  100001  GLX_SGIS_multisample/GLX_ARB_multisample
+
+GLX Error Codes
+===============
+
+(Extension reservations for vendor extensions should start sufficiently
+high so they don't interfere with GLX core and GLX ARB extensions.)
+
+0   GLXBadContext                   OpenGL ARB (GLX core)
+1   GLXBadContextState              OpenGL ARB (GLX core)
+2   GLXBadDrawable                  OpenGL ARB (GLX core)
+3   GLXBadPixmap                    OpenGL ARB (GLX core)
+4   GLXBadContextTag                OpenGL ARB (GLX core)
+5   GLXBadCurrentWindow             OpenGL ARB (GLX core)
+6   GLXBadRenderRequest             OpenGL ARB (GLX core)
+7   GLXBadLargeRequest              OpenGL ARB (GLX core)
+8   GLXUnsupportedPrivateRequest    OpenGL ARB (GLX core)
+9   GLXBadFBConfig                  OpenGL ARB (GLX core)
+10  GLXBadPbuffer                   OpenGL ARB (GLX core)
+11  GLXBadCurrentDrawable           OpenGL ARB (GLX core)
+12  GLXBadWindow                    OpenGL ARB (GLX core)
+13  GLXBadProfileARB                OpenGL ARB (GLX_ARB_create_context)
+
+
+GLX Event Masks
+===============
+0x08000000      GLX 1.3 / SGIX_pbuffer
+0x04000000      Intel (INTEL_swap_event)
+
+GLX Event Codes
+===============
+
+(The X.org/Mesa GLX implementation derived from the SGI Sample
+Implementation has __GLX_NUMBER_EVENTS == 17, suggesting that vendor
+events should be allocated downwards from the first free value <= 16
+(14), and core GLX events allocated upwards).
+
+0               OpenGL ARB (GLX_PbufferClobber in GLX 1.3)
+15              Intel (GLX_BufferSwapINTEL)
+16              SGI (GLX_PbufferClobberSGIX)
+64              SGI
+
+GLX protocol encoding for GL >= 2.0
+===================================
+
+(This section - this whole file really - should eventually be incorporated
+in a proper update of the GLX protocol specification.)
+
+OpenGL 2.0
+----------
+
+    DeleteShader
+
+        1           CARD8           opcode (X assigned)
+        1           195             GLX opcode
+        2           3               request length
+        4           GLX_CONTEXT_TAG context tag
+        4           CARD32          shader
+
+    IsShader
+
+        1           CARD8           opcode (X assigned)
+        1           196             GLX opcode
+        2           3               request length
+        4           GLX_CONTEXT_TAG context tag
+        4           CARD32          shader
+      =>
+        1           1               reply
+        1                           unused
+        2           CARD16          sequence number
+        4           0               reply length
+        4           BOOL32          return value
+        20                          unused
+
+    IsProgram
+
+        1           CARD8           opcode (X assigned)
+        1           197             GLX opcode
+        2           3               request length
+        4           GLX_CONTEXT_TAG context tag
+        4           CARD32          program
+      =>
+        1           1               reply
+        1                           unused
+        2           CARD16          sequence number
+        4           0               reply length
+        4           BOOL32          return value
+        20                          unused
+
+    GetShaderiv
+
+        1           CARD8           opcode (X assigned)
+        1           198             GLX opcode
+        2           4               request length
+        4           GLX_CONTEXT_TAG context tag
+        4           CARD32          program
+        4           CARD32          pname
+      =>
+        1           1               reply
+        1                           unused
+        2           CARD16          sequence number
+        4           m               reply length, m = (n == 1 ? 0 : n)
+        4                           unused
+        4           CARD32          n
+
+        if (n == 1) this follows:
+
+        4           CARD32          params
+        12                          unused
+
+        otherwise this follows:
+
+        16                          unused
+        n*4         LISTOFCARD32    params
+
+        Note that n may be 0, indicating that a GL error occurred.
+
+    GetProgramiv
+
+        1           CARD8           opcode (X assigned)
+        1           199             GLX opcode
+        2           4               request length
+        4           GLX_CONTEXT_TAG context tag
+        4           CARD32          program
+        4           CARD32          pname
+      =>
+        1           1               reply
+        1                           unused
+        2           CARD16          sequence number
+        4           m               reply length, m = (n == 1 ? 0 : n)
+        4                           unused
+        4           CARD32          n
+
+        if (n == 1) this follows:
+
+        4           CARD32          params
+        12                          unused
+
+        otherwise this follows:
+
+        16                          unused
+        n*4         LISTofCARD32    params
+
+        Note that n may be 0, indicating that a GL error occurred.
+
+    GetShaderInfoLog
+
+        1           CARD8           opcode (X assigned)
+        1           200             GLX opcode
+        2           4               request length
+        4           GLX_CONTEXT_TAG context tag
+        4           CARD32          shader
+        4           CARD32          bufSize
+      =>
+        1           1               reply
+        1                           unused
+        2           CARD16          sequence number
+        4           m               reply length, m = (n + p) / 4
+        4                           unused
+        4           CARD32          n, n = length + 1
+        16                          unused
+        n           LISTofBYTE      infoLog
+        p                           unused, p=pad(n)
+
+        Note that n may be 0, indicating that a GL error occurred.
+
+    GetProgramInfoLog
+
+        1           CARD8           opcode (X assigned)
+        1           201             GLX opcode
+        2           4               request length
+        4           GLX_CONTEXT_TAG context tag
+        4           CARD32          program
+        4           CARD32          bufSize
+      =>
+        1           1               reply
+        1                           unused
+        2           CARD16          sequence number
+        4           m               reply length, m = (n + p) / 4
+        4                           unused
+        4           CARD32          n, n = length + 1
+        16                          unused
+        n           LISTofBYTE      infoLog
+        p                           unused, p=pad(n)
+
+        Note that n may be 0, indicating that a GL error occurred.
+
+    DeleteProgram
+
+        1           CARD8           opcode (X assigned)
+        1           202             GLX opcode
+        2           3               request length
+        4           GLX_CONTEXT_TAG context tag
+        4           CARD32          program
+
+OpenGL 2.1
+----------
+
+    UniformMatrix2x3fv
+
+        2           16+4*count*2*3  rendering command length
+        2           305             rendering command opcode
+        4           CARD32          location
+        4           CARD32          count
+        1           BOOL            transpose
+        3                           unused
+        4*count*2*3 LISTofFLOAT32   value
+
+    If the command is encoded in a glXRenderLarge request, the
+    command opcode and command length fields above are expanded to
+    4 bytes each:
+
+        4           20+4*count*2*2  rendering command length
+        4           305             rendering command opcode
+
+    UniformMatrix3x2fv
+
+        2           16+4*count*3*2  rendering command length
+        2           306             rendering command opcode
+        4           CARD32          location
+        4           CARD32          count
+        1           BOOL            transpose
+        3                           unused
+        4*count*3*2 LISTofFLOAT32   value
+
+    If the command is encoded in a glXRenderLarge request, the
+    command opcode and command length fields above are expanded to
+    4 bytes each:
+
+        4           20+4*count*3*2  rendering command length
+        4           306             rendering command opcode
+
+    UniformMatrix2x4fv
+
+        2           16+4*count*2*4  rendering command length
+        2           307             rendering command opcode
+        4           CARD32          location
+        4           CARD32          count
+        1           BOOL            transpose
+        3                           unused
+        4*count*2*4 LISTofFLOAT32   value
+
+    If the command is encoded in a glXRenderLarge request, the
+    command opcode and command length fields above are expanded to
+    4 bytes each:
+
+        4           20+4*count*2*4  rendering command length
+        4           307             rendering command opcode
+
+    UniformMatrix4x2fv
+
+        2           16+4*count*4*2  rendering command length
+        2           308             rendering command opcode
+        4           CARD32          location
+        4           CARD32          count
+        1           BOOL            transpose
+        3                           unused
+        4*count*4*2 LISTofFLOAT32   value
+
+    If the command is encoded in a glXRenderLarge request, the
+    command opcode and command length fields above are expanded to
+    4 bytes each:
+
+        4           20+4*count*4*2  rendering command length
+        4           308             rendering command opcode
+
+    UniformMatrix3x4fv
+
+        2           16+4*count*3*4  rendering command length
+        2           309             rendering command opcode
+        4           CARD32          location
+        4           CARD32          count
+        1           BOOL            transpose
+        3                           unused
+        4*count*3*4 LISTofFLOAT32   value
+
+    If the command is encoded in a glXRenderLarge request, the
+    command opcode and command length fields above are expanded to
+    4 bytes each:
+
+        4           20+4*count*3*4  rendering command length
+        4           309             rendering command opcode
+
+    UniformMatrix4x3fv
+
+        2           16+4*count*4*3  rendering command length
+        2           310             rendering command opcode
+        4           CARD32          location
+        4           CARD32          count
+        1           BOOL            transpose
+        3                           unused
+        4*count*4*3 LISTofFLOAT32   value
+
+    If the command is encoded in a glXRenderLarge request, the
+    command opcode and command length fields above are expanded to
+    4 bytes each:
+
+        4           20+4*count*4*3  rendering command length
+        4           310             rendering command opcode
+
+OpenGL 3.0
+----------
+
+    The following rendering commands are sent to the sever as part of a
+    glXRender request:
+
+        BindBufferRange
+
+            2           32              rendering command length
+            2           355             rendering command opcode
+            8           INT64           offset
+            8           INT64           size
+            4           ENUM            target
+            4           CARD32          index
+            4           CARD32          buffer
+
+        BindBufferBase
+
+            2           16              rendering command length
+            2           356             rendering command opcode
+            4           ENUM            target
+            4           CARD32          index
+            4           CARD32          buffer
+
+        BeginTransformFeedback
+
+            2           8               rendering command length
+            2           357             rendering command opcode
+            4           ENUM            primitiveMode
+
+        EndTransformFeedback
+
+            2           4               rendering command length
+            2           358             rendering command opcode
+
+        ClearBufferfi
+
+            2           20              rendering command length
+            2           360             rendering command opcode
+            4           ENUM            buffer
+            4           CARD32          drawbuffer
+            4           FLOAT32         depth
+            4           CARD32          stencil
+
+        ClearBufferfv
+
+            2           12+(4*n)        rendering command length
+            2           361             rendering command opcode
+            4           ENUM            buffer
+                        0x1800   n=4    GL_COLOR
+                        0x1801   n=1    GL_STENCIL
+                        0x1802   n=1    GL_DEPTH
+                        else     n=0
+            4           CARD32          drawbuffer
+            4*n         LISTofFLOAT32   value
+
+        ClearBufferiv
+
+            2           12+(4*n)        rendering command length
+            2           362             rendering command opcode
+            4           ENUM            buffer
+                        0x1800   n=4    GL_COLOR
+                        0x1801   n=1    GL_STENCIL
+                        0x1802   n=1    GL_DEPTH
+                        else     n=0
+            4           CARD32          drawbuffer
+            4*n         LISTofINT32     value
+
+        ClearBufferuiv
+
+            2           12+(4*n)        rendering command length
+            2           363             rendering command opcode
+            4           ENUM            buffer
+                        0x1800   n=4    GL_COLOR
+                        0x1801   n=1    GL_STENCIL
+                        0x1802   n=1    GL_DEPTH
+                        else     n=0
+            4           CARD32          drawbuffer
+            4*n         LISTofCARD32    value
+
+    The following rendering commands can be sent in a glXRender
+    or glXRenderLarge request.
+
+        TransformFeedbackVaryings
+
+            2      16+(n*4)+s+p    rendering command length
+            2      359             rendering command opcode
+            4      CARD32          program
+            4      INT32           count
+            4      ENUM            buffermode
+            n*4    LISTofINT32     lengths[n], n = count
+            s      LISTofCHAR      varyings, s = sum of all entries in the lengths
+                                   array
+            p                      unused, p = pad(s)
+
+    If the command is encoded in a glXRenderLarge request, the command
+    opcode and command length fields are expanded to 4 bytes each.
+
+            4      20+(n*4)+s+p    rendering command length
+            4      359             rendering command opcode
+
+    lengths[i] is calculated as strlen(varyings[i]) + 1. The NUL terminator
+    is included when sending the varyings.
+
+    The following single commands are sent to the server as part of a
+    glXSingle request:
+
+        GetTransformFeedbackVarying
+
+            1      CARD8           opcode(X assigned)
+            1      213             GLX opcode
+            2      5               request length
+            4      GLX_CONTEXT_TAG context tag
+            4      CARD32          program
+            4      CARD32          index
+            4      CARD32          bufsize
+            =>
+            1      1               reply
+            1                      unused
+            2      CARD16          sequence number
+            4      m               reply length, m = (n == 0 ? 0 : (n + p) / 4)
+            4                      unused
+            4      n-1             length
+            4      INT32           size
+            4      INT32           type
+            8                      unused
+            n      LISTofCHAR      name, n = strlen(name)+1
+            p                      unused, p = pad(m)
+
+        GetStringi
+
+            1           CARD8           opcode (X assigned)
+            1           214             GLX opcode
+            2           4               request length
+            4           GLX_CONTEXT_TAG context tag
+            4           ENUM            name
+            4           CARD32          index
+          =>
+            1           1               reply
+            1           1               unused
+            2           CARD16          sequence number
+            4           m               reply length, m = (n + p) / 4
+            4                           unused
+            4           CARD32          n
+            16                          unused
+            n           STRING8         string
+            p                           unused, p=pad(n)

StgSharp.GenerateGL/xml/registry.rnc

@@ -0,0 +1,289 @@
+# Copyright 2013-2020 The Khronos Group Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# Relax NG schema for Khronos Registry XML
+# See https://github.com/KhronosGroup/OpenGL-Registry
+#
+# Last modified 2013/06/14
+# This definition is subject to change (mostly in the form of additions)
+
+namespace xsd = "http://www.w3.org/2001/XMLSchema-datatypes"
+
+# Toplevel is a <registry> tag.
+# May be led by an optional <comment> tag containing e.g. copyrights.
+start = element registry {
+    (
+        element comment { text } ? |
+        Types      * |
+        Kinds      * |
+        Groups     * |
+        Enums      * |
+        Commands   * |
+        Feature    * |
+        Extensions *
+    ) *
+}
+
+# <types> defines a group of types
+Types = element types {
+    Type *
+}
+
+# <type> defines a single type. It is usually a C typedef but
+# may contain arbitrary C code.
+#   name - name of this type, if not present in the <name> tag
+#   api - matches a <feature> api attribute, if present
+#   requires - name of another type definition required by this one
+#   type - "group", if present, indicating a group of values in the
+#       corresponding <enums> definition.
+#   comment - unused
+#   <apientry /> - substitutes for an APIENTRY-style macro on output
+#   <name> - contains typename
+Type = element type {
+    attribute api { text } ? ,
+    attribute requires { text } ? ,
+    attribute name { TypeName } ? ,
+    attribute type { text } ? ,
+    Comment ? ,
+    text ,
+    element apientry { text } ? ,
+    text ,
+    element name { TypeName } ? ,
+    text
+}
+
+# <kinds> defines descriptions for kinds.
+Kinds = element kinds {
+    Kind *
+}
+
+# <kind> defines a description for a single kind.
+Kind = element kind {
+    Name ,
+    attribute desc { text }
+}
+
+# <groups> defines a group of enum groups
+Groups = element groups {
+    Group *
+}
+
+# <group> defines a single enum group. Enums may
+# be in multiple groups.
+#   name - group name
+#   comment - unused
+#   <enum name=""> - members of the group
+
+Group = element group {
+    Name ,
+    Comment ? ,
+    element enum { Name } *
+}
+
+# <enums> defines a group of enumerants
+#   namespace - identifies a numeric namespace
+#   group - identifies a functional subset of the namespace - same as group=""
+#   start, end - beginning and end of a numeric range in the namespace
+#   vendor - owner of the numeric range
+#   type - "bitmask", if present
+#   comment - unused
+Enums = element enums {
+    attribute namespace { text } ? ,
+    attribute group { text } ? ,
+    attribute type { text } ? ,
+    attribute start { Integer } ? ,
+    attribute end { Integer } ? ,
+    Vendor ? ,
+    Comment ? ,
+    (Enum | Unused) *
+}
+# <enum> defines a single enumerant
+#   value - integer (including hex) value of the enumerant
+#   api - matches a <feature> api attribute, if present
+#   type - "u" (unsigned), "ull" (uint64), or integer if not present
+#   name - enumerant name
+#   group - identifies a functional subset of the namespace
+#   alias - another enumerant this is semantically identical to
+#   comment - unused
+Enum = element enum {
+    (
+        attribute value { Integer } &
+        attribute api { text } ? &
+        attribute type { TypeSuffix } ? &
+        attribute name { text } &
+        attribute group { text } ? &
+        attribute alias { text } ? &
+        Comment ?
+    )
+}
+# <unused> defines a range of enumerants not currently being used
+#   start, end - beginning and end of an unused numeric range
+#   vendor - unused
+#   comment - unused
+Unused = element unused {
+    attribute start { Integer } ,
+    attribute end { Integer } ? ,
+    Vendor ? ,
+    Comment ?
+}
+# <commands> defines a group of commands
+#   namespace - identifies a function namespace
+Commands = element commands {
+    attribute namespace { text } ? ,
+    Command *
+}
+# <command> defines a single command
+#   <proto> is the C function prototype, including the return type
+#   <param> are function parameters, in order
+#     class - type of object name (object handle). Handles with different types are not compatible. So handle created as [class=buffer] can not be passed to [class=shader]
+#     <ptype> is a <type> name, if present
+#     <name> is the function / parameter name
+# The textual contents of <proto> and <param> should be legal C
+# for those parts of a function declaration.
+#   <alias> - denotes function aliasing
+#     name - name of aliased function
+#   <vecequiv> - denotes scalar / vector function equivalence
+#     name - name of corresponding vector form, e.g. (glColor3f -> glColor3fv)
+#   <glx> - information about GLX protocol
+#     type - "render", "single", or "vendor" for GLXRender, GLXSingle, GLXVendorPrivate{WithReply}
+#     opcode - numeric opcode of specified type for this function
+#     name - if present, protocol name (defaults to command name)
+#     comment - unused
+Command = element command {
+    Comment ? ,
+    element proto {
+        attribute group { text } ? ,
+        attribute kind { text } ? ,
+        attribute class { text } ? ,
+        text ,
+        element ptype { TypeName } ? ,
+        text ,
+        element name { text } ,
+        text
+    } ,
+    element param {
+        attribute group { text } ? ,
+        attribute kind { text } ? ,
+        attribute class { text } ? ,
+        attribute len { text } ? ,
+        text ,
+        element ptype { TypeName } ? ,
+        text ,
+        element name { text } ,
+        text
+    } * ,
+    (
+        element alias {
+            Name
+        } ? &
+        element vecequiv {
+            Name
+        } ? &
+        element glx {
+            attribute type { text } ,
+            attribute opcode { xsd:integer } ,
+            Name ? ,
+            Comment ?
+        } *
+    )
+}
+# Each <feature> defines the interface of an API version (e.g. OpenGL 1.2)
+#   api - API tag (e.g. 'gl', 'gles2', etc. - used internally, not
+#     neccessarily an actual API name
+#   name - version name (C preprocessor name, e.g. GL_VERSION_4_2)
+#   number - version number, e.g. 4.2
+#   protect - additional #ifdef symbol to place around the feature
+#   <require> / <remove> contains features to require or remove in
+#                        this version
+#     profile - only require/remove when generated profile matches
+#     comment - unused
+Feature = element feature {
+    attribute api { text } ,
+    Name ,
+    attribute number { xsd:float } ,
+    attribute protect { text } ?,
+    Comment ? ,
+    (
+        element require {
+            ProfileName ? ,
+            Comment ? ,
+            InterfaceElement *
+        } |
+        element remove {
+            ProfileName ? ,
+            Comment ? ,
+            InterfaceElement *
+        }
+    ) *
+}
+Extensions = element extensions {
+    Extension *
+}
+# Defines the interface of an API <extension>. Like a <feature>
+# tag, but with a slightly different api attribute.
+#   api - regexp pattern matching one or more API tags, indicating
+#     which APIs the extension is known to work with. The only
+#     syntax supported is <name>{|<name>}* and each name must
+#     exactly match an API being generated (implicit ^$ surrounding).
+# In addition, <require> / <remove> tags also support an
+# api attribute:
+#     api - only require/remove these features for the matching API.
+#       Not a regular expression.
+Extension = element extension {
+    Name ,
+    attribute protect { text } ?,
+    attribute supported { StringGroup } ? ,
+    Comment ? ,
+    (
+        element require {
+            attribute api { text } ? ,
+            ProfileName ? ,
+            Comment ? ,
+            InterfaceElement *
+        } |
+        element remove {
+            attribute api { text } ? ,
+            ProfileName ? ,
+            Comment ? ,
+            InterfaceElement *
+        }
+    ) *
+}
+# Contents of a <require> / <remove> tag, defining a group
+# of features to require or remove.
+#   <type> / <enum> / <command> all have attributes
+#     name - feature name which must match
+InterfaceElement =
+    element type {
+        Name ,
+        Comment ?
+    } |
+    element enum {
+        Name ,
+        Comment ?
+    } |
+    element command {
+        Name ,
+        Comment ?
+    }
+
+# Integers are allowed to be either decimal or C-hex (0x[0-9A-F]+), but
+# XML Schema types don't seem to support hex notation, so we use this
+# as a placeholder.
+Integer = text
+
+# TypeName is an argument/return value C type name
+TypeName = text
+
+# TypeSuffix is a C numeric type suffix, e.g. 'u' or 'ull'
+TypeSuffix = text
+
+# StringGroup is a regular expression with an implicit
+#   '^(' and ')$' bracketing it.
+StringGroup = text
+
+# Repeatedly used attributes
+ProfileName = attribute profile { text }
+Vendor = attribute vendor { text }
+Comment = attribute comment { text }
+Name = attribute name { text }

StgSharp.GenerateGL/xml/testesext.c

@@ -0,0 +1,14 @@
+/*% cc -I. -I../api -I../../../../../registry/trunk/egl/api/ -c % ; rm testesext.o
+ *
+ * Test to make sure gl3.h builds properly.
+ * Will also use SVN internal versions of gl3platform.h
+ * and khrplatform.h (if needed) (via GLES and KHR symlinks into
+ * appropriate parts of the tree).
+ */
+#define GL_GLEXT_PROTOTYPES
+#include "GLES3/gl31.h"
+#include "GLES2/gl2ext.h"
+
+#if GL_NV_non_square_matrices != 1
+#error "No extension GL_NV_non_square_matrices!"
+#endif

StgSharp.GenerateGL/xml/testglext.c

@@ -0,0 +1,27 @@
+/*% /lib/cpp -I../api testglext.c > testglext.i ; cc -c % ; rm testglext.[oi]
+*/
+#define GL_GLEXT_LEGACY
+#include <GL/gl.h>
+#define GL_GLEXT_PROTOTYPES
+#include "GL/glext.h"
+
+#define GLX_GLXEXT_LEGACY
+#include <GL/glx.h>
+
+/* Necessary to avoid token redefinition warnings */
+#undef GLX_SAMPLE_BUFFERS
+#undef GLX_SAMPLES
+#undef GLX_FRONT_EXT
+#undef GLX_BACK_EXT
+
+#define GLX_GLXEXT_PROTOTYPES
+#include "GL/glxext.h"
+
+int VERSION_4_3 = GL_VERSION_4_3;
+/* These should be the same */
+int mcsor = GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES;
+int mciufo = GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS;
+
+/* See if latest extension is included */
+int latest_ext = GL_NV_blend_equation_advanced;
+GLenum latest_enum = GL_CONJOINT_NV;

StgSharp.GenerateGL/xml/vendors.txt

@@ -0,0 +1,58 @@
+Miscellaneous data about extensions:
+
+  - GLU enumerant reserved values
+  - Information about extension vendors (probably out of date and incomplete)
+
+GLU Enumerants
+==============
+
+Value Range     Definition      Contact
+                Control         (if different)
+
+100208          SGI
+
+
+Definition      Contact             Email
+Control
+==========      =======             =====
+OpenGL ARB      Jon Leech           jon 'at' alumni.caltech.edu
+Khronos         Jon Leech           jon 'at' alumni.caltech.edu (OpenML, OpenGL ES)
+Apple           Bob Beretta         beretta 'at' apple.com
+ARM             Tom Olson           tom.olson 'at' arm.com
+AMD and ATI     Graham Sellers      graham.sellers 'at' amd.com
+ATI/NVIDIA      Graham Sellers      graham.sellers 'at' amd.com
+Broadcom        Gary Sweet          gsweet 'at' broadcom.com
+HP              Andrew Wiltzius     andrew.wiltzius 'at' hp.com
+Imagination     Graham Connor       gconnor 'at' videologic.com
+Intel           Ian Romanick        ian.d.romanick 'at' intel.com
+Mesa            Brian Paul          brianp 'at' mesa3d.org
+Microsoft       Dave Aronson        daronson 'at' microsoft.com
+NEC             Seiji Uchida        uchida 'at' hpc.bs1.fc.nec.co.jp
+NVIDIA          James Jones         jajones 'at' nvidia.com
+S3              Yanjun Zhang        YanjunZhang 'at' s3graphics.com
+Vivante         Frido Garritsen     TBD
+Samsung         Jeff Vigil          j.vigil 'at' samsung.com
+Qualcomm        Ashish Mathur       asmathur@qti.qualcomm.com
+
+Out of business / acquired / unknown:
+
+3Dfx - Acquired by NVIDIA
+3Dlabs - Acquired by Creative, refocused on mobile, renamed ZiiLabs
+ADD - Out of business
+ATI - Acquired by AMD
+Compaq - Acquired by HP
+DEC - Acquired by Compaq, then HP
+E&S - No longer in the graphics business (sells planetarium displays)
+HP - No longer in the graphics business (other than as a system integrator)
+IBM - No longer in the graphics business (other than as a system integrator)
+Intense3D - Acquired by 3Dlabs
+Intergraph - Acquired by 3Dlabs. Spinoff of Intense3D.
+Micron - No longer in the graphics business
+KPC (Kubota) - Out of business
+PGI (Pacific Graphics Inc.) - Acquired by Template Graphics Systems
+Pixelfusion - No longer in the graphics business
+Rendition - Acquired by Micron
+SGI (Silicon Graphics Inc.) - Acquired by Silicon Graphics International, then HP
+SUN - Acquired by Oracle. No longer in the graphics business.
+XGI - Acquired by Silicon Integrated Systems. No longer in the graphics business.
+ZiiLabs - Still has a website but appears to be inactive as of 2017-01-12.

StgSharp.GenerateGL/xml/wgltypes.txt

@@ -0,0 +1,106 @@
+        <type>struct <name>_POINTFLOAT</name> {
+    FLOAT x;
+    FLOAT y;
+};</type>
+        <type>typedef struct _POINTFLOAT <name>POINTFLOAT</name>;</type>
+        <type>typedef struct _POINTFLOAT *<name>PPOINTFLOAT</name>;</type>
+        <type requires="POINTFLOAT">struct <name>_GLYPHMETRICSFLOAT</name> {
+    FLOAT      gmfBlackBoxX;
+    FLOAT      gmfBlackBoxY;
+    POINTFLOAT gmfptGlyphOrigin;
+    FLOAT      gmfCellIncX;
+    FLOAT      gmfCellIncY;
+};</type>
+        <type requires="_GLYPHMETRICSFLOAT">typedef struct _GLYPHMETRICSFLOAT <name>GLYPHMETRICSFLOAT</name>;</type>
+        <type requires="_GLYPHMETRICSFLOAT">typedef struct _GLYPHMETRICSFLOAT *<name>PGLYPHMETRICSFLOAT</name>;</type>
+
+typedef struct tagPIXELFORMATDESCRIPTOR {
+  WORD  nSize;
+  WORD  nVersion;
+  DWORD dwFlags;
+  BYTE  iPixelType;
+  BYTE  cColorBits;
+  BYTE  cRedBits;
+  BYTE  cRedShift;
+  BYTE  cGreenBits;
+  BYTE  cGreenShift;
+  BYTE  cBlueBits;
+  BYTE  cBlueShift;
+  BYTE  cAlphaBits;
+  BYTE  cAlphaShift;
+  BYTE  cAccumBits;
+  BYTE  cAccumRedBits;
+  BYTE  cAccumGreenBits;
+  BYTE  cAccumBlueBits;
+  BYTE  cAccumAlphaBits;
+  BYTE  cDepthBits;
+  BYTE  cStencilBits;
+  BYTE  cAuxBuffers;
+  BYTE  iLayerType;
+  BYTE  bReserved;
+  DWORD dwLayerMask;
+  DWORD dwVisibleMask;
+  DWORD dwDamageMask;
+} PIXELFORMATDESCRIPTOR, *PPIXELFORMATDESCRIPTOR;
+
+PFD_DRAW_TO_WINDOW      The buffer can draw to a window or device surface.
+PFD_DRAW_TO_BITMAP      The buffer can draw to a memory bitmap.
+PFD_SUPPORT_GDI The buffer supports GDI drawing. This flag and PFD_DOUBLEBUFFER are mutually exclusive in the current generic implementation.
+PFD_SUPPORT_OPENGL      The buffer supports OpenGL drawing.
+PFD_GENERIC_ACCELERATED The pixel format is supported by a device driver that accelerates the generic implementation. If this flag is clear and the PFD_GENERIC_FORMAT flag is set, the pixel format is supported by the generic implementation only.
+PFD_GENERIC_FORMAT      The pixel format is supported by the GDI software implementation, which is also known as the generic implementation. If this bit is clear, the pixel format is supported by a device driver or hardware.
+PFD_NEED_PALETTE        The buffer uses RGBA pixels on a palette-managed device. A logical palette is required to achieve the best results for this pixel type. Colors in the palette should be specified according to the values of the cRedBits, cRedShift, cGreenBits, cGreenShift, cBluebits, and cBlueShift members. The palette should be created and realized in the device context before calling wglMakeCurrent.
+PFD_NEED_SYSTEM_PALETTE Defined in the pixel format descriptors of hardware that supports one hardware palette in 256-color mode only. For such systems to use hardware acceleration, the hardware palette must be in a fixed order (for example, 3-3-2) when in RGBA mode or must match the logical palette when in color-index mode.
+PFD_DOUBLEBUFFER        The buffer is double-buffered. This flag and PFD_SUPPORT_GDI are mutually exclusive in the current generic implementation.
+PFD_STEREO      The buffer is stereoscopic. This flag is not supported in the current generic implementation.
+PFD_SWAP_LAYER_BUFFERS  Indicates whether a device can swap individual layer planes with pixel formats that include double-buffered overlay or underlay planes. Otherwise all layer planes are swapped together as a group. When this flag is set, wglSwapLayerBuffers is supported.
+PFD_DEPTH_DONTCARE      The requested pixel format can either have or not have a depth buffer. To select a pixel format without a depth buffer, you must specify this flag. The requested pixel format can be with or without a depth buffer. Otherwise, only pixel formats with a depth buffer are considered.
+PFD_DOUBLEBUFFER_DONTCARE       The requested pixel format can be either single- or double-buffered.
+PFD_STEREO_DONTCARE     The requested pixel format can be either monoscopic or stereoscopic.
+PFD_SWAP_COPY   Specifies the content of the back buffer in the double-buffered main color plane following a buffer swap. Swapping the color buffers causes the content of the back buffer to be copied to the front buffer. The content of the back buffer is not affected by the swap. PFD_SWAP_COPY is a hint only and might not be provided by a driver.
+PFD_SWAP_EXCHANGE       Specifies the content of the back buffer in the double-buffered main color plane following a buffer swap. Swapping the color buffers causes the exchange of the back buffer's content with the front buffer's content. Following the swap, the back buffer's content contains the front buffer's content before the swap. PFD_SWAP_EXCHANGE is a hint only and might not be provided by a driver.
+PFD_TYPE_RGBA   RGBA pixels. Each pixel has four components in this order: red, green, blue, and alpha.
+PFD_TYPE_COLORINDEX     Color-index pixels. Each pixel uses a color-index value.
+typedef struct tag_LAYERPLANEDESCRIPTOR {
+  WORD     nSize;
+  WORD     nVersion;
+  DWORD    dwFlags;
+  BYTE     iPixelType;
+  BYTE     cColorBits;
+  BYTE     cRedBits;
+  BYTE     cRedShift;
+  BYTE     cGreenBits;
+  BYTE     cGreenShift;
+  BYTE     cBlueBits;
+  BYTE     cBlueShift;
+  BYTE     cAlphaBits;
+  BYTE     cAlphaShift;
+  BYTE     cAccumBits;
+  BYTE     cAccumRedBits;
+  BYTE     cAccumGreenBits;
+  BYTE     cAccumBlueBits;
+  BYTE     cAccumAlphaBits;
+  BYTE     cDepthBits;
+  BYTE     cStencilBits;
+  BYTE     cAuxBuffers;
+  BYTE     iLayerType;
+  BYTE     bReserved;
+  COLORREF crTransparent;
+} LAYERPLANEDESCRIPTOR, *PLAYERPLANEDESCRIPTOR;
+LPD_SUPPORT_OPENGL      The layer plane supports OpenGL drawing.
+LPD_SUPPORT_GDI The layer plane supports GDI drawing. The current implementation of OpenGL doesn't support this flag.
+LPD_DOUBLEBUFFER        The layer plane is double-buffered. A layer plane can be double-buffered even when the main plane is single-buffered and vice versa.
+LPD_STEREO      The layer plane is stereoscopic. A layer plane can be stereoscopic even when the main plane is monoscopic and vice versa.
+LPD_SWAP_EXCHANGE       In a double-buffered layer plane, swapping the color buffer exchanges the front buffer and back buffer contents. The back buffer then contains the contents of the front buffer before the swap. This flag is a hint only and might not be provided by a driver.
+LPD_SWAP_COPY   In a double-buffered layer plane, swapping the color buffer copies the back buffer contents to the front buffer. The swap does not affect the back buffer contents. This flag is a hint only and might not be provided by a driver.
+LPD_TRANSPARENT The crTransparent member of this structure contains a transparent color or index value that enables underlying layers to show through this layer. All layer planes, except the lowest-numbered underlay layer, have a transparent color or index.
+LPD_SHARE_DEPTH The layer plane shares the depth buffer with the main plane.
+LPD_SHARE_STENCIL       The layer plane shares the stencil buffer with the main plane.
+LPD_SHARE_ACCUM The layer plane shares the accumulation buffer with the main plane.
+ 
+iPixelType
+Specifies the type of pixel data. The following types are defined.
+Value   Meaning
+LPD_TYPE_RGBA   RGBA pixels. Each pixel has four components: red, green, blue, and alpha.
+LPD_TYPE_COLORINDEX     Color-index pixels. Each pixel uses a color-index value.
+ 

StgSharp.Mathematics/Numeric/MatrixCompute.Additional.cs

@@ -1,84 +0,0 @@
-//-----------------------------------------------------------------------
-// -----------------------------------------------------------------------
-// file="MatrixCompute.Additional"
-// Project: StgSharp
-// AuthorGroup: Nitload
-// Copyright (c) Nitload. All rights reserved.
-//     
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-//     
-// -----------------------------------------------------------------------
-// -----------------------------------------------------------------------
-using StgSharp.HighPerformance;
-using StgSharp.Internal;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Runtime.CompilerServices;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace StgSharp.Mathematics.Numeric
-{
-    public partial class MatrixCompute
-    {
-
-        internal static unsafe void ComputeFmaPanelF32(MatrixParallelTaskPackage* p)
-        {
-            int size = p->ElementSize;
-            MatrixKernel* leftBuffer = (MatrixKernel*)p->Left;
-            MatrixKernel* rightBuffer = (MatrixKernel*)p->Right;
-            MatrixKernel* ansBuffer = (MatrixKernel*)p->Answer;
-            MatrixPanel<float>* leftPanel = MatrixPanel.Create<float>();
-            MatrixPanel<float>* rightPanel = MatrixPanel.Create<float>();
-            MatrixPanel<float>* ansPanel = MatrixPanel.Create<float>();
-            ref long offsetRef = ref Unsafe.As<int, long>(ref p->PrimTileOffset);
-            ref long lengthRef = ref Unsafe.As<int, long>(ref p->PrimCount);
-            int ansWidth = p-> AnsPrimOffset;
-            int ansHeight = p->AnsSecOffset;
-            int commonK = p->LeftPrimOffset;
-            int blocksPerRow = ansWidth / size;
-
-            for (long c = offsetRef; c < offsetRef + lengthRef; c++)
-            {
-                int i = (int)(c / blocksPerRow) * size;
-                int j = (int)(c % blocksPerRow) * size;
-                NativeIntrinsic.Intrinsic.f32_clear_panel((MatrixPanel*)ansPanel);
-                for (int k = 0; k < commonK; k += size)
-                {
-                    NativeIntrinsic.Intrinsic
-                                   .f32_build_panel((MatrixPanel*)leftPanel, leftBuffer, commonK,
-                                                    ansHeight, k, i);
-                    NativeIntrinsic.Intrinsic
-                                   .f32_build_panel((MatrixPanel*)rightPanel, rightBuffer, ansWidth,
-                                                    commonK, j, k);
-                    NativeIntrinsic.Intrinsic
-                                   .f32_panel_fma((MatrixPanel*)leftPanel, (MatrixPanel*)rightPanel, (MatrixPanel*)ansPanel);
-                }
-                NativeIntrinsic.Intrinsic
-                               .f32_store_panel((MatrixPanel*)ansPanel, ansBuffer, ansWidth,
-                                                ansHeight, j, i);
-            }
-            MatrixPanel.Destroy(leftPanel);
-            MatrixPanel.Destroy(rightPanel);
-            MatrixPanel.Destroy(ansPanel);
-        }
-
-    }
-}

StgSharp.Mathematics/Numeric/MatrixCompute.Factorize.cs

@@ -25,6 +25,7 @@
 //     
 // -----------------------------------------------------------------------
 // -----------------------------------------------------------------------
+using StgSharp.Internal;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -36,11 +37,12 @@ namespace StgSharp.Mathematics.Numeric
     public static partial class MatrixCompute
     {
 
-        public static void FactorizePLU(
+        public static unsafe void FactorizePLU(
                                   Matrix<float> matrix,
-                           Span<float> pivot,
+                                  Span<int> pivot,
                                   Matrix<float> lower,
-                           Matrix<float> upper)
+                                  Matrix<float> upper
+        )
         {
             if (matrix.ColumnLength != matrix.RowLength) {
                 throw new InvalidOperationException("Matrix must be square.");
@@ -54,7 +56,7 @@ namespace StgSharp.Mathematics.Numeric
             }
             if (lower.RowLength != n ||
                 lower.ColumnLength != n ||
-                lower.Layout != MatrixLayout.LowerTriangle) {
+                lower.Layout != MatrixLayout.UpperTriangle) {
                 throw new ArgumentException("Lower matrix must be lower-triangular with same dimensions as input.", nameof(lower));
             }
             if (upper.RowLength != n ||
@@ -66,15 +68,64 @@ namespace StgSharp.Mathematics.Numeric
             int size = matrix.KernelColumnLength * matrix.KernelRowLength;
             if (size < 256)
             {
-                // Naive Doolittle-style PLU without row swaps (for illustration).
                 for (int i = 0; i < n; i++)
                 {
-                    pivot[i] = i;          // identity pivot
-                    lower[i, i] = 1.0f;    // unit diagonal for L
+                    pivot[i] = i; // identity permutation
                 }
 
-                for (int k = 0; k < n; k++)
+                // Aggressive: always call native pivot to fetch four-column candidates
+                ulong* pivots = stackalloc ulong[4];
+                for (int kBlock = 0; kBlock < n; kBlock += 4)
                 {
+                    NativeIntrinsic.Context
+                                   .mat[(int)MatrixElementType.F32].pivot(matrix.Buffer,
+                                                                          (ulong)(kBlock >> 2),
+                                                                          (ulong)(matrix.KernelRowLength - (kBlock >> 2)),
+                                                                          (ulong)pivots);
+                    int colsInBlock = Math.Min(4, n - kBlock);
+                    for (int offset = 0; offset < colsInBlock; offset++)
+                    {
+                        int k = kBlock + offset;
+                        int pivotRow = k;
+                        float maxAbs;
+
+                        int candidateRow = (int)pivots[offset];
+                        int idx = -1;
+                        for (int r = k; r < n; r++)
+                        {
+                            if (pivot[r] == candidateRow)
+                            {
+                                idx = r;
+                                break;
+                            }
+                        }
+
+                        if (idx != -1)
+                        {
+                            pivotRow = idx;
+                            maxAbs = MathF.Abs(matrix.GetElementUnsafe(pivot[idx], k));
+                        } else
+                        {
+                            maxAbs = MathF.Abs(matrix.GetElementUnsafe(pivot[k], k));
+                            for (int r = k + 1; r < n; r++)
+                            {
+                                float val = MathF.Abs(matrix.GetElementUnsafe(pivot[r], k));
+                                if (val > maxAbs)
+                                {
+                                    maxAbs = val;
+                                    pivotRow = r;
+                                }
+                            }
+                        }
+
+                        if (maxAbs == 0f) {
+                            throw new InvalidOperationException("Zero pivot encountered in PLU.");
+                        }
+                        if (pivotRow != k) {
+                            (pivot[k], pivot[pivotRow]) = (pivot[pivotRow], pivot[k]);
+                        }
+                        lower[k, k] = 1.0f;    // unit diagonal for L
+
                         // Compute U[k, j] for j >= k
                         for (int j = k; j < n; j++)
                         {
@@ -82,7 +133,7 @@ namespace StgSharp.Mathematics.Numeric
                             for (int s = 0; s < k; s++) {
                                 sum += lower[k, s] * upper[s, j];
                             }
-                        upper[k, j] = matrix[k, j] - sum;
+                            upper[k, j] = matrix.GetElementUnsafe(pivot[k], j) - sum;
                         }
 
                         // Compute L[i, k] for i > k
@@ -94,9 +145,10 @@ namespace StgSharp.Mathematics.Numeric
                             }
                             float u = upper[k, k];
                             if (u == 0f) {
-                            throw new InvalidOperationException("Zero pivot encountered in demonstration PLU.");
+                                throw new InvalidOperationException("Zero pivot encountered in PLU.");
+                            }
+                            lower[i, k] = (matrix.GetElementUnsafe(pivot[i], k) - sum) / u;
                         }
-                        lower[i, k] = (matrix.GetElementUnsafe(i, k) - sum) / u;
                     }
                 }
 

StgSharp.Mathematics/Numeric/MatrixCompute.Float.cs

@@ -0,0 +1,343 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="MatrixCompute.Float"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. All rights reserved.
+//     
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//     
+// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+using StgSharp.Collections;
+using StgSharp.HighPerformance;
+using StgSharp.Internal;
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Linq;
+using System.Numerics;
+using System.Security.AccessControl;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Mathematics.Numeric
+{
+    public static partial class MatrixCompute
+    {
+
+        public static unsafe void Add(
+                                  Matrix<float> left,
+                                  Matrix<float> right,
+                                  Matrix<float> ans
+        )
+        {
+            int f32 = (int)MatrixElementType.F32;
+            if (left.ColumnLength != right.ColumnLength ||
+                left.RowLength != right.RowLength ||
+                left.ColumnLength != ans.ColumnLength ||
+                left.RowLength != ans.RowLength) {
+                throw new IndexOutOfRangeException("Matrix dimensions must agree.");
+            }
+            long count = (long)left.KernelColumnLength * left.KernelRowLength;
+            if (count <= 256)
+            {
+                MatrixKernel<float>* leftPtr = left.Buffer;
+                MatrixKernel<float>* rightPtr = right.Buffer;
+                MatrixKernel<float>* ansPtr = ans.Buffer;
+                NativeIntrinsic.Context.mat[f32].buffer_add(leftPtr, rightPtr, ansPtr, count);
+
+                return;
+            } else if (count <= 1024)
+            {
+                MatrixParallelThread[] pool = MatrixParallel.LeadParallel(1);
+
+                MatrixKernel<float>* leftPtr = left.Buffer;
+                MatrixKernel<float>* rightPtr = right.Buffer;
+                MatrixKernel<float>* ansPtr = ans.Buffer;
+                NativeIntrinsic.Context.mat[f32].buffer_add(leftPtr, rightPtr, ansPtr, count);
+
+                MatrixParallel.ReturnParallelResources(ref pool);
+                return;
+            }
+            MatrixParallelTaskPackage* package = MatrixParallelFactory.CreateBaseTask<float>();
+            package->Left = (nint)left.Buffer;
+            package->Right = (nint)right.Buffer;
+            package->Answer = (nint)ans.Buffer;
+            package->ElementSize = sizeof(float);
+            package->PrimCount = ans.KernelColumnLength;
+            package->SecCount = ans.KernelRowLength;
+            package->ComputeMode = new MatrixOpMode(MatrixIndexStyle.BUFFER_INDEX, MatrixOperationParam.LEFT_RIGHT_ANS_PARAM);
+            package->ComputeHandle = (IntPtr)NativeIntrinsic.Context.mat[f32].buffer_add;
+            MatrixParallelHandle taskGroup = MatrixParallel.ScheduleTask(package);
+
+            MatrixParallel.LaunchParallel(taskGroup, SleepMode.DeepSleep);
+            taskGroup.Dispose();
+            return;
+        }
+
+        public static unsafe void Fill(
+                                  Matrix<float> ans,
+                                  float value
+        )
+        {
+            int f32 = (int)MatrixElementType.F32;
+            long count = (long)ans.KernelColumnLength * ans.KernelRowLength;
+            ScalarPacket* scalar = MatrixParallelFactory.CreateScalarPacket();
+            scalar->Data<float>(0) = value;
+            if (count <= 256)
+            {
+                NativeIntrinsic.Context.mat[f32].buffer_fill(ans.Buffer, scalar, count);
+                return;
+            } else if (count <= 1024)
+            {
+                MatrixParallelThread[] pool = MatrixParallel.LeadParallel(1);
+                NativeIntrinsic.Context.mat[f32].buffer_fill(ans.Buffer, scalar, count);
+                MatrixParallel.ReturnParallelResources(ref pool);
+                return;
+            }
+            MatrixParallelTaskPackage* package = MatrixParallelFactory.CreateBaseTask<float>();
+            package->Answer = (nint)ans.Buffer;
+            package->ElementSize = sizeof(float);
+            package->PrimCount = ans.KernelColumnLength;
+            package->SecCount = ans.KernelRowLength;
+            package->ComputeMode = new MatrixOpMode(MatrixIndexStyle.BUFFER_INDEX, MatrixOperationParam.ANS_SCALAR_PARAM);
+            package->ComputeHandle = (IntPtr)NativeIntrinsic.Context.mat[f32].buffer_fill;
+            package->Scalar = scalar;
+            MatrixParallelHandle taskGroup = MatrixParallel.ScheduleTask(package);
+            MatrixParallel.LaunchParallel(taskGroup, SleepMode.DeepSleep);
+            MatrixParallelFactory.Release(scalar);
+            taskGroup.Dispose();
+        }
+
+        public static unsafe void Mul(
+                                  Matrix<float> left,
+                                  Matrix<float> right,
+                                  Matrix<float> ans
+        )
+        {
+            int f32 = (int)MatrixElementType.F32;
+
+            // For matrix multiplication (left: MxK) * (right: KxN) => ans: MxN
+            // ColumnLength = number of columns (N), RowLength = number of rows (M)
+            if (left.ColumnLength != right.RowLength ||
+                ans.ColumnLength != right.ColumnLength ||
+                ans.RowLength != left.RowLength)
+            {
+                throw new IndexOutOfRangeException("Matrix dimensions must agree.");
+            }
+            long count = (long)left.KernelColumnLength * left.KernelRowLength;
+            int size = MatrixPanel.KernelSideCount<float>();
+            if (count <= 1024)
+            {
+                MatrixParallelThread[] pool = null;
+                if (count > 256) {
+                    pool = MatrixParallel.LeadParallel(1);
+                }
+                if (NativeIntrinsic.Context.mat[f32].build_panel == null)
+                {
+                    for (int i = 0; i < ans.KernelRowLength; i += size)
+                    {
+                        for (int j = 0; j < ans.KernelColumnLength; j += size)
+                        {
+                            MatrixKernel<float>* ansPanel = ans.GetKernelAddressUnsafe(i, j);
+                            NativeIntrinsic.Context.mat[f32].clear_panel((MatrixPanel*)ansPanel);
+
+                            // Console.WriteLine($"{i}{j}");
+                            for (int k = 0; k < left.KernelColumnLength; k += size)
+                            {
+                                NativeIntrinsic.Context
+                                               .mat[f32].panel_fma((MatrixPanel*)left.GetKernelAddressUnsafe(i, k),
+                                                                (MatrixPanel*)right.GetKernelAddressUnsafe(k, j),
+                                                                (MatrixPanel*)ansPanel);
+                            }
+                        }
+                    }
+                } else
+                {
+                    MatrixPanel<float>* leftPanel = MatrixPanel.Create<float>();
+                    MatrixPanel<float>* rightPanel = MatrixPanel.Create<float>();
+                    MatrixPanel<float>* ansPanel = MatrixPanel.Create<float>();
+                    for (int i = 0; i < ans.KernelRowLength; i += size)
+                    {
+                        for (int j = 0; j < ans.KernelColumnLength; j += size)
+                        {
+                            NativeIntrinsic.Context.mat[f32].clear_panel((MatrixPanel*)ansPanel);
+
+                            // Console.WriteLine($"{i}{j}");
+                            for (int k = 0; k < left.KernelColumnLength; k += size)
+                            {
+                                NativeIntrinsic.Context
+                                               .mat[f32].build_panel((MatrixPanel*)leftPanel,
+                                                                     (MatrixKernel*)left.Buffer,
+                                                                     left.KernelColumnLength,
+                                                                     left.KernelRowLength, i, k);
+                                NativeIntrinsic.Context
+                                               .mat[f32].build_panel((MatrixPanel*)rightPanel,
+                                                                     (MatrixKernel*)right.Buffer,
+                                                                     right.KernelColumnLength,
+                                                                     right.KernelRowLength, k, j);
+                                NativeIntrinsic.Context
+                                               .mat[f32].panel_fma((MatrixPanel*)leftPanel,
+                                                                (MatrixPanel*)rightPanel,
+                                                                (MatrixPanel*)ansPanel);
+                            }
+                            NativeIntrinsic.Context
+                                           .mat[f32].store_panel((MatrixPanel*)ansPanel,
+                                                                 (MatrixKernel*)ans.Buffer,
+                                                                 ans.KernelColumnLength,
+                                                                 ans.KernelRowLength, i, j);
+                        }
+                    }
+                    MatrixPanel.Destroy(leftPanel);
+                    MatrixPanel.Destroy(rightPanel);
+                    MatrixPanel.Destroy(ansPanel);
+                }
+                if (count > 256) {
+                    MatrixParallel.ReturnParallelResources(ref pool!);
+                }
+                return;
+            }
+            MatrixParallelTaskPackage* package = MatrixParallelFactory.CreateBaseTask<float>();
+            package->Left = (nint)left.Buffer;
+            package->Right = (nint)right.Buffer;
+            package->Answer = (nint)ans.Buffer;
+            package->AnsPrimOffset = ans.KernelRowLength;
+            package->AnsSecOffset = ans.KernelColumnLength;
+            package->LeftPrimOffset = left.KernelColumnLength;
+            package->PrimCount = ans.KernelColumnLength / size;
+            package->SecCount = ans.KernelRowLength / size;
+            package->ElementSize = size;
+            package->ComputeMode = new MatrixOpMode(MatrixIndexStyle.BUFFER_INDEX, MatrixOperationSpecial.SEQ_FMA);
+            MatrixParallelHandle taskGroup = MatrixParallel.ScheduleTask(package);
+
+            MatrixParallel.LaunchParallel(taskGroup, SleepMode.DeepSleep);
+            taskGroup.Dispose();
+            return;
+        }
+
+        public static unsafe void Mul(
+                                  Matrix<float> left,
+                                  float right,
+                                  Matrix<float> ans
+        )
+        {
+            int f32 = (int)MatrixElementType.F32;
+            if (left.ColumnLength != ans.ColumnLength || left.RowLength != ans.RowLength) {
+                throw new IndexOutOfRangeException("Matrix dimensions must agree.");
+            }
+            if (left.Layout != MatrixLayout.DenseRectangle ||
+                ans.Layout != MatrixLayout.DenseRectangle) {
+                throw new NotSupportedException("Only dense rectangle matrices are supported.");
+            }
+            long count = (long)left.KernelColumnLength * left.KernelRowLength;
+            ScalarPacket* scalar = MatrixParallelFactory.CreateScalarPacket();
+            scalar->Data<float>(0) = right;
+            if (count <= 256)
+            {
+                MatrixKernel<float>* leftPtr = left.Buffer;
+                MatrixKernel<float>* ansPtr = ans.Buffer;
+                NativeIntrinsic.Context.mat[f32].buffer_scalar_mul(leftPtr, ansPtr, scalar, count);
+
+                return;
+            } else if (count <= 1024)
+            {
+                MatrixParallelThread[] pool = MatrixParallel.LeadParallel(1);
+
+                MatrixKernel<float>* leftPtr = left.Buffer;
+                MatrixKernel<float>* ansPtr = ans.Buffer;
+                NativeIntrinsic.Context.mat[f32].buffer_scalar_mul(leftPtr, ansPtr, scalar, count);
+
+                MatrixParallel.ReturnParallelResources(ref pool);
+                return;
+            }
+            MatrixParallelTaskPackage* package = MatrixParallelFactory.CreateBaseTask<float>();
+            package->Right = (nint)left.Buffer;
+            package->Answer = (nint)ans.Buffer;
+            package->ElementSize = sizeof(float);
+            package->PrimCount = left.KernelColumnLength;
+            package->SecCount = left.KernelRowLength;
+            package->Scalar = scalar;
+            package->ComputeMode = new MatrixOpMode(MatrixIndexStyle.BUFFER_INDEX, MatrixOperationParam.RIGHT_ANS_SCALAR_PARAM);
+            package->ComputeHandle = (IntPtr)NativeIntrinsic.Context.mat[f32].buffer_scalar_mul;
+            MatrixParallelHandle taskGroup = MatrixParallel.ScheduleTask(package);
+
+            MatrixParallel.LaunchParallel(taskGroup, SleepMode.DeepSleep);
+            taskGroup.Dispose();
+            MatrixParallelFactory.Release(scalar);
+            return;
+        }
+
+        public static unsafe void Sub(
+                                  Matrix<float> left,
+                                  Matrix<float> right,
+                                  Matrix<float> ans
+        )
+        {
+            int f32 = (int)MatrixElementType.F32;
+            if (left.ColumnLength != right.ColumnLength ||
+                left.RowLength != right.RowLength ||
+                left.ColumnLength != ans.ColumnLength ||
+                left.RowLength != ans.RowLength) {
+                throw new IndexOutOfRangeException("Matrix dimensions must agree.");
+            }
+            if (left.Layout != MatrixLayout.DenseRectangle ||
+                right.Layout != MatrixLayout.DenseRectangle ||
+                ans.Layout != MatrixLayout.DenseRectangle) {
+                throw new NotSupportedException("Only dense rectangle matrices are supported.");
+            }
+            long count = (long)left.KernelColumnLength * left.KernelRowLength;
+            if (count <= 256)
+            {
+                MatrixKernel<float>* leftPtr = left.Buffer;
+                MatrixKernel<float>* rightPtr = right.Buffer;
+                MatrixKernel<float>* ansPtr = ans.Buffer;
+                NativeIntrinsic.Context.mat[f32].buffer_sub(leftPtr, rightPtr, ansPtr, count);
+
+                return;
+            } else if (count <= 1024)
+            {
+                MatrixParallelThread[] pool = MatrixParallel.LeadParallel(1);
+
+                MatrixKernel<float>* leftPtr = left.Buffer;
+                MatrixKernel<float>* rightPtr = right.Buffer;
+                MatrixKernel<float>* ansPtr = ans.Buffer;
+                NativeIntrinsic.Context.mat[f32].buffer_sub(leftPtr, rightPtr, ansPtr, count);
+
+                MatrixParallel.ReturnParallelResources(ref pool);
+                return;
+            }
+            MatrixParallelTaskPackage* package = MatrixParallelFactory.CreateBaseTask<float>();
+            package->Left = (nint)left.Buffer;
+            package->Right = (nint)right.Buffer;
+            package->Answer = (nint)ans.Buffer;
+            package->ElementSize = sizeof(float);
+            package->PrimCount = left.KernelColumnLength;
+            package->SecCount = left.KernelRowLength;
+            package->ComputeMode = new MatrixOpMode(MatrixIndexStyle.BUFFER_INDEX, MatrixOperationParam.LEFT_RIGHT_ANS_PARAM);
+            package->ComputeHandle = (IntPtr)NativeIntrinsic.Context.mat[f32].buffer_sub;
+            MatrixParallelHandle taskGroup = MatrixParallel.ScheduleTask(package);
+
+            MatrixParallel.LaunchParallel(taskGroup, SleepMode.DeepSleep);
+            taskGroup.Dispose();
+            return;
+        }
+
+    }
+}

StgSharp.Mathematics/Numeric/MatrixCompute.cs

@@ -25,266 +25,162 @@
 //     
 // -----------------------------------------------------------------------
 // -----------------------------------------------------------------------
-using StgSharp.Collections;
 using StgSharp.HighPerformance;
 using StgSharp.Internal;
 using System;
 using System.Collections.Generic;
-using System.ComponentModel.DataAnnotations.Schema;
 using System.Linq;
 using System.Numerics;
-using System.Security.AccessControl;
+using System.Runtime.CompilerServices;
 using System.Text;
 using System.Threading.Tasks;
 
 namespace StgSharp.Mathematics.Numeric
 {
-    public static partial class MatrixCompute
+    public partial class MatrixCompute
     {
 
-        public static unsafe void Add(Matrix<float> left, Matrix<float> right, Matrix<float> ans)
+        internal static unsafe void ComputeFmaPanelF32(
+                                    MatrixParallelTaskPackage* p
+        )
         {
-            if (left.ColumnLength != right.ColumnLength ||
-                left.RowLength != right.RowLength ||
-                left.ColumnLength != ans.ColumnLength ||
-                left.RowLength != ans.RowLength) {
-                throw new IndexOutOfRangeException("Matrix dimensions must agree.");
-            }
-            long count = (long)left.KernelColumnLength * left.KernelRowLength;
-            if (count <= 256)
-            {
-                MatrixKernel<float>* leftPtr = left.Buffer;
-                MatrixKernel<float>* rightPtr = right.Buffer;
-                MatrixKernel<float>* ansPtr = ans.Buffer;
-                NativeIntrinsic.Intrinsic.f32_buffer_add(leftPtr, rightPtr, ansPtr, count);
-                return;
-            } else if (count <= 1024)
-            {
-                MatrixParallelThread[] pool = MatrixParallel.LeadParallel(1);
-
-                MatrixKernel<float>* leftPtr = left.Buffer;
-                MatrixKernel<float>* rightPtr = right.Buffer;
-                MatrixKernel<float>* ansPtr = ans.Buffer;
-                NativeIntrinsic.Intrinsic.f32_buffer_add(leftPtr, rightPtr, ansPtr, count);
-
-                MatrixParallel.ReturnParallelResources(ref pool);
-                return;
-            }
-            MatrixParallelTaskPackage* package = MatrixParallelFactory.CreateBaseTask<float>();
-            package->Left = (nint)left.Buffer;
-            package->Right = (nint)right.Buffer;
-            package->Answer = (nint)ans.Buffer;
-            package->ElementSize = sizeof(float);
-            package->PrimCount = ans.KernelColumnLength;
-            package->SecCount = ans.KernelRowLength;
-            package->ComputeMode = new MatrixOpMode(MatrixIndexStyle.BUFFER_INDEX, MatrixOperationParam.LEFT_RIGHT_ANS_PARAM);
-            package->ComputeHandle = (IntPtr)NativeIntrinsic.Intrinsic.f32_buffer_add;
-            MatrixParallelHandle taskGroup = MatrixParallel.ScheduleTask(package);
-
-            MatrixParallel.LaunchParallel(taskGroup, SleepMode.DeepSleep);
-            taskGroup.Dispose();
-        }
-
-        public static unsafe void Fill(Matrix<float> ans, float value)
-        {
-            long count = (long)ans.KernelColumnLength * ans.KernelRowLength;
-            ScalarPacket* scalar = MatrixParallelFactory.CreateScalarPacket();
-            scalar->Data<float>(0) = value;
-            if (count <= 256)
-            {
-                NativeIntrinsic.Intrinsic.f32_buffer_fill(ans.Buffer, scalar, count);
-                return;
-            } else if (count <= 1024)
-            {
-                MatrixParallelThread[] pool = MatrixParallel.LeadParallel(1);
-                NativeIntrinsic.Intrinsic.f32_buffer_fill(ans.Buffer, scalar, count);
-                MatrixParallel.ReturnParallelResources(ref pool);
-                return;
-            }
-            MatrixParallelTaskPackage* package = MatrixParallelFactory.CreateBaseTask<float>();
-            package->Answer = (nint)ans.Buffer;
-            package->ElementSize = sizeof(float);
-            package->PrimCount = ans.KernelColumnLength;
-            package->SecCount = ans.KernelRowLength;
-            package->ComputeMode = new MatrixOpMode(MatrixIndexStyle.BUFFER_INDEX, MatrixOperationParam.ANS_SCALAR_PARAM);
-            package->ComputeHandle = (IntPtr)NativeIntrinsic.Intrinsic.f32_buffer_fill;
-            package->Scalar = scalar;
-            MatrixParallelHandle taskGroup = MatrixParallel.ScheduleTask(package);
-            MatrixParallel.LaunchParallel(taskGroup, SleepMode.DeepSleep);
-            MatrixParallelFactory.Release(scalar);
-            taskGroup.Dispose();
-        }
-
-        public static unsafe void Mul(Matrix<float> left, Matrix<float> right, Matrix<float> ans)
-        {
-            // For matrix multiplication (left: MxK) * (right: KxN) => ans: MxN
-            // ColumnLength = number of columns (N), RowLength = number of rows (M)
-            if (left.ColumnLength != right.RowLength ||
-                ans.ColumnLength != right.ColumnLength ||
-                ans.RowLength != left.RowLength)
-            {
-                throw new IndexOutOfRangeException("Matrix dimensions must agree.");
-            }
-            long count = (long)left.KernelColumnLength * left.KernelRowLength;
+            int f32 = (int)MatrixElementType.F32;
             int size = MatrixPanel.KernelSideCount<float>();
-            if (count <= 1024)
+            MatrixKernel* leftBuffer = (MatrixKernel*)p->Left;
+            MatrixKernel* rightBuffer = (MatrixKernel*)p->Right;
+            MatrixKernel* ansBuffer = (MatrixKernel*)p->Answer;
+            ref long offsetRef = ref Unsafe.As<int, long>(ref p->PrimTileOffset);
+            ref long lengthRef = ref Unsafe.As<int, long>(ref p->PrimCount);
+            int ansWidth = p->AnsPrimOffset;
+            int ansHeight = p->AnsSecOffset;
+            int commonK = p->LeftPrimOffset;
+            int blocksPerRow = ansWidth / size;
+            if (NativeIntrinsic.Context.mat[f32].build_panel == null)
             {
-                MatrixParallelThread[] pool = null;
-                if (count > 256) {
-                    pool = MatrixParallel.LeadParallel(1);
+                // in this occasion size must be 1
+                for (long c = offsetRef; c < offsetRef + lengthRef; c++)
+                {
+                    int i = (int)(c / blocksPerRow);
+                    int j = (int)(c % blocksPerRow);
+                    MatrixKernel<float>* ansPanel = GetKernelAddressUnsafe((MatrixKernel<float>*)ansBuffer,
+                                                                           ansHeight, i, j);
+                    NativeIntrinsic.Context.mat[f32].clear_panel((MatrixPanel*)ansPanel);
+                    for (int k = 0; k < commonK; k += size) {
+                        NativeIntrinsic.Context
+                                       .mat[f32].panel_fma(
+                                        (MatrixPanel*)GetKernelAddressUnsafe((MatrixKernel<float>*)leftBuffer,
+                                                                             ansHeight, k, j),
+                                        (MatrixPanel*)GetKernelAddressUnsafe((MatrixKernel<float>*)rightBuffer,
+                                                                             commonK, j, k),
+                                        (MatrixPanel*)ansPanel);
                     }
+                }
+            } else
+            {
                 MatrixPanel<float>* leftPanel = MatrixPanel.Create<float>();
                 MatrixPanel<float>* rightPanel = MatrixPanel.Create<float>();
                 MatrixPanel<float>* ansPanel = MatrixPanel.Create<float>();
-                for (int i = 0; i < ans.KernelRowLength; i += size)
+                for (long c = offsetRef; c < offsetRef + lengthRef; c++)
                 {
-                    for (int j = 0; j < ans.KernelColumnLength; j += size)
+                    int i = (int)(c / blocksPerRow) * size;
+                    int j = (int)(c % blocksPerRow) * size;
+                    NativeIntrinsic.Context.mat[f32].clear_panel((MatrixPanel*)ansPanel);
+                    for (int k = 0; k < commonK; k += size)
                     {
-                        NativeIntrinsic.Intrinsic.f32_clear_panel((MatrixPanel*)ansPanel);
-
-                        // Console.WriteLine($"{i}{j}");
-                        for (int k = 0; k < left.KernelColumnLength; k += size)
-                        {
-                            NativeIntrinsic.Intrinsic
-                                           .f32_build_panel((MatrixPanel*)leftPanel,
-                                                            (MatrixKernel*)left.Buffer,
-                                                            left.KernelColumnLength,
-                                                            left.KernelRowLength, i, k);
-                            NativeIntrinsic.Intrinsic
-                                           .f32_build_panel((MatrixPanel*)rightPanel,
-                                                            (MatrixKernel*)right.Buffer,
-                                                            right.KernelColumnLength,
-                                                            right.KernelRowLength, k, j);
-                            NativeIntrinsic.Intrinsic
-                                           .f32_panel_fma((MatrixPanel*)leftPanel,
-                                                            (MatrixPanel*)rightPanel,
-                                                            (MatrixPanel*)ansPanel);
-                        }
-                        NativeIntrinsic.Intrinsic
-                                       .f32_store_panel((MatrixPanel*)ansPanel,
-                                                        (MatrixKernel*)ans.Buffer,
-                                                        ans.KernelColumnLength, ans.KernelRowLength,
-                                                        i, j);
+                        NativeIntrinsic.Context
+                                       .mat[f32].build_panel((MatrixPanel*)leftPanel, leftBuffer,
+                                                             commonK, ansHeight, k, i);
+                        NativeIntrinsic.Context
+                                       .mat[f32].build_panel((MatrixPanel*)rightPanel, rightBuffer,
+                                                             ansWidth, commonK, j, k);
+                        NativeIntrinsic.Context
+                                       .mat[f32].panel_fma((MatrixPanel*)leftPanel, (MatrixPanel*)rightPanel, (MatrixPanel*)ansPanel);
                     }
+                    NativeIntrinsic.Context
+                                   .mat[f32].store_panel((MatrixPanel*)ansPanel, ansBuffer,
+                                                         ansWidth, ansHeight, j, i);
                 }
                 MatrixPanel.Destroy(leftPanel);
                 MatrixPanel.Destroy(rightPanel);
                 MatrixPanel.Destroy(ansPanel);
-                if (count > 256) {
-                    MatrixParallel.ReturnParallelResources(ref pool!);
             }
-                return;
-            }
-            MatrixParallelTaskPackage* package = MatrixParallelFactory.CreateBaseTask<float>();
-            package->Left = (nint)left.Buffer;
-            package->Right = (nint)right.Buffer;
-            package->Answer = (nint)ans.Buffer;
-            package->AnsPrimOffset = ans.KernelRowLength;
-            package->AnsSecOffset = ans.KernelColumnLength;
-            package->LeftPrimOffset = left.KernelColumnLength;
-            package->PrimCount = ans.KernelColumnLength / size;
-            package->SecCount = ans.KernelRowLength / size;
-            package->ElementSize = size;
-            package->ComputeMode = new MatrixOpMode(MatrixIndexStyle.BUFFER_INDEX, MatrixOperationSpecial.SEQ_FMA);
-            MatrixParallelHandle taskGroup = MatrixParallel.ScheduleTask(package);
-
-            MatrixParallel.LaunchParallel(taskGroup, SleepMode.DeepSleep);
-            taskGroup.Dispose();
-            return;
         }
 
-        public static unsafe void Mul(Matrix<float> left, float right, Matrix<float> ans)
+        internal static unsafe void ComputeFmaPanelF64(
+                                    MatrixParallelTaskPackage* p
+        )
         {
-            if (left.ColumnLength != ans.ColumnLength || left.RowLength != ans.RowLength) {
-                throw new IndexOutOfRangeException("Matrix dimensions must agree.");
-            }
-            if (left.Layout != MatrixLayout.DenseRectangle ||
-                ans.Layout != MatrixLayout.DenseRectangle) {
-                throw new NotSupportedException("Only dense rectangle matrices are supported.");
-            }
-            long count = (long)left.KernelColumnLength * left.KernelRowLength;
-            ScalarPacket* scalar = MatrixParallelFactory.CreateScalarPacket();
-            scalar->Data<float>(0) = right;
-            if (count <= 256)
+            int f64 = (int)MatrixElementType.F64;
+            int size = MatrixPanel.KernelSideCount<double>();
+            MatrixKernel* leftBuffer = (MatrixKernel*)p->Left;
+            MatrixKernel* rightBuffer = (MatrixKernel*)p->Right;
+            MatrixKernel* ansBuffer = (MatrixKernel*)p->Answer;
+            ref long offsetRef = ref Unsafe.As<int, long>(ref p->PrimTileOffset);
+            ref long lengthRef = ref Unsafe.As<int, long>(ref p->PrimCount);
+            int ansWidth = p->AnsPrimOffset;
+            int ansHeight = p->AnsSecOffset;
+            int commonK = p->LeftPrimOffset;
+            int blocksPerRow = ansWidth / size;
+            if (NativeIntrinsic.Context.mat[f64].build_panel == null)
             {
-                MatrixKernel<float>* leftPtr = left.Buffer;
-                MatrixKernel<float>* ansPtr = ans.Buffer;
-                NativeIntrinsic.Intrinsic.f32_buffer_scalar_mul(leftPtr, ansPtr, scalar, count);
-                return;
-            } else if (count <= 1024)
+                // in this occasion size must be 1
+                for (long c = offsetRef; c < offsetRef + lengthRef; c++)
                 {
-                MatrixParallelThread[] pool = MatrixParallel.LeadParallel(1);
-
-                MatrixKernel<float>* leftPtr = left.Buffer;
-                MatrixKernel<float>* ansPtr = ans.Buffer;
-                NativeIntrinsic.Intrinsic.f32_buffer_scalar_mul(leftPtr, ansPtr, scalar, count);
-
-                MatrixParallel.ReturnParallelResources(ref pool);
-                return;
+                    int i = (int)(c / blocksPerRow);
+                    int j = (int)(c % blocksPerRow);
+                    MatrixKernel<double>* ansPanel = GetKernelAddressUnsafe((MatrixKernel<double>*)ansBuffer,
+                                                                            ansHeight, i, j);
+                    NativeIntrinsic.Context.mat[f64].clear_panel((MatrixPanel*)ansPanel);
+                    for (int k = 0; k < commonK; k += size) {
+                        NativeIntrinsic.Context
+                                       .mat[f64].panel_fma(
+                                        (MatrixPanel*)GetKernelAddressUnsafe((MatrixKernel<double>*)leftBuffer,
+                                                                             ansHeight, k, j),
+                                        (MatrixPanel*)GetKernelAddressUnsafe((MatrixKernel<double>*)rightBuffer,
+                                                                             commonK, j, k),
+                                        (MatrixPanel*)ansPanel);
                     }
-            MatrixParallelTaskPackage* package = MatrixParallelFactory.CreateBaseTask<float>();
-            package->Right = (nint)left.Buffer;
-            package->Answer = (nint)ans.Buffer;
-            package->ElementSize = sizeof(float);
-            package->PrimCount = left.KernelColumnLength;
-            package->SecCount = left.KernelRowLength;
-            package->Scalar = scalar;
-            package->ComputeMode = new MatrixOpMode(MatrixIndexStyle.BUFFER_INDEX, MatrixOperationParam.RIGHT_ANS_SCALAR_PARAM);
-            package->ComputeHandle = (IntPtr)NativeIntrinsic.Intrinsic.f32_buffer_scalar_mul;
-            MatrixParallelHandle taskGroup = MatrixParallel.ScheduleTask(package);
-
-            MatrixParallel.LaunchParallel(taskGroup, SleepMode.DeepSleep);
-            taskGroup.Dispose();
-            MatrixParallelFactory.Release(scalar);
-            return;
                 }
-
-        public static unsafe void Sub(Matrix<float> left, Matrix<float> right, Matrix<float> ans)
+            } else
             {
-            if (left.ColumnLength != right.ColumnLength ||
-                left.RowLength != right.RowLength ||
-                left.ColumnLength != ans.ColumnLength ||
-                left.RowLength != ans.RowLength) {
-                throw new IndexOutOfRangeException("Matrix dimensions must agree.");
-            }
-            if (left.Layout != MatrixLayout.DenseRectangle ||
-                right.Layout != MatrixLayout.DenseRectangle ||
-                ans.Layout != MatrixLayout.DenseRectangle) {
-                throw new NotSupportedException("Only dense rectangle matrices are supported.");
-            }
-            long count = (long)left.KernelColumnLength * left.KernelRowLength;
-            if (count <= 256)
+                MatrixPanel<double>* leftPanel = MatrixPanel.Create<double>();
+                MatrixPanel<double>* rightPanel = MatrixPanel.Create<double>();
+                MatrixPanel<double>* ansPanel = MatrixPanel.Create<double>();
+                for (long c = offsetRef; c < offsetRef + lengthRef; c++)
                 {
-                MatrixKernel<float>* leftPtr = left.Buffer;
-                MatrixKernel<float>* rightPtr = right.Buffer;
-                MatrixKernel<float>* ansPtr = ans.Buffer;
-                NativeIntrinsic.Intrinsic.f32_buffer_sub(leftPtr, rightPtr, ansPtr, count);
-                return;
-            } else if (count <= 1024)
+                    int i = (int)(c / blocksPerRow) * size;
+                    int j = (int)(c % blocksPerRow) * size;
+                    NativeIntrinsic.Context.mat[f64].clear_panel((MatrixPanel*)ansPanel);
+                    for (int k = 0; k < commonK; k += size)
                     {
-                MatrixParallelThread[] pool = MatrixParallel.LeadParallel(1);
-
-                MatrixKernel<float>* leftPtr = left.Buffer;
-                MatrixKernel<float>* rightPtr = right.Buffer;
-                MatrixKernel<float>* ansPtr = ans.Buffer;
-                NativeIntrinsic.Intrinsic.f32_buffer_sub(leftPtr, rightPtr, ansPtr, count);
-
-                MatrixParallel.ReturnParallelResources(ref pool);
-                return;
+                        NativeIntrinsic.Context
+                                       .mat[f64].build_panel((MatrixPanel*)leftPanel, leftBuffer,
+                                                             commonK, ansHeight, k, i);
+                        NativeIntrinsic.Context
+                                       .mat[f64].build_panel((MatrixPanel*)rightPanel, rightBuffer,
+                                                             ansWidth, commonK, j, k);
+                        NativeIntrinsic.Context
+                                       .mat[f64].panel_fma((MatrixPanel*)leftPanel, (MatrixPanel*)rightPanel, (MatrixPanel*)ansPanel);
+                    }
+                    NativeIntrinsic.Context
+                                   .mat[f64].store_panel((MatrixPanel*)ansPanel, ansBuffer,
+                                                         ansWidth, ansHeight, j, i);
+                }
+                MatrixPanel.Destroy(leftPanel);
+                MatrixPanel.Destroy(rightPanel);
+                MatrixPanel.Destroy(ansPanel);
+            }
         }
-            MatrixParallelTaskPackage* package = MatrixParallelFactory.CreateBaseTask<float>();
-            package->Left = (nint)left.Buffer;
-            package->Right = (nint)right.Buffer;
-            package->Answer = (nint)ans.Buffer;
-            package->ElementSize = sizeof(float);
-            package->PrimCount = left.KernelColumnLength;
-            package->SecCount = left.KernelRowLength;
-            package->ComputeMode = new MatrixOpMode(MatrixIndexStyle.BUFFER_INDEX, MatrixOperationParam.LEFT_RIGHT_ANS_PARAM);
-            package->ComputeHandle = (IntPtr)NativeIntrinsic.Intrinsic.f32_buffer_sub;
-            MatrixParallelHandle taskGroup = MatrixParallel.ScheduleTask(package);
 
-            MatrixParallel.LaunchParallel(taskGroup, SleepMode.DeepSleep);
-            taskGroup.Dispose();
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static unsafe MatrixKernel<T>* GetKernelAddressUnsafe<T>(
+                                                MatrixKernel<T>* buffer,
+                                                int colLength,
+                                                int x,
+                                                int y
+        ) where T : unmanaged, INumber<T>
+        {
+            return buffer + (colLength * x + y);
         }
 
     }

StgSharp.Mathematics/Numeric/MatrixCompute.double.cs

@@ -0,0 +1,339 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="MatrixCompute.double"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. All rights reserved.
+//     
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//     
+// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+using StgSharp.HighPerformance;
+using StgSharp.Internal;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Mathematics.Numeric
+{
+    public partial class MatrixCompute
+    {
+
+        public static unsafe void Add(
+                                  Matrix<double> left,
+                                  Matrix<double> right,
+                                  Matrix<double> ans
+        )
+        {
+            int f64 = (int)MatrixElementType.F64;
+            if (left.ColumnLength != right.ColumnLength ||
+                left.RowLength != right.RowLength ||
+                left.ColumnLength != ans.ColumnLength ||
+                left.RowLength != ans.RowLength) {
+                throw new IndexOutOfRangeException("Matrix dimensions must agree.");
+            }
+            long count = (long)left.KernelColumnLength * left.KernelRowLength;
+            if (count <= 256)
+            {
+                MatrixKernel<double>* leftPtr = left.Buffer;
+                MatrixKernel<double>* rightPtr = right.Buffer;
+                MatrixKernel<double>* ansPtr = ans.Buffer;
+                NativeIntrinsic.Context.mat[f64].buffer_add(leftPtr, rightPtr, ansPtr, count);
+
+                return;
+            } else if (count <= 1024)
+            {
+                MatrixParallelThread[] pool = MatrixParallel.LeadParallel(1);
+
+                MatrixKernel<double>* leftPtr = left.Buffer;
+                MatrixKernel<double>* rightPtr = right.Buffer;
+                MatrixKernel<double>* ansPtr = ans.Buffer;
+                NativeIntrinsic.Context.mat[f64].buffer_add(leftPtr, rightPtr, ansPtr, count);
+
+                MatrixParallel.ReturnParallelResources(ref pool);
+                return;
+            }
+            MatrixParallelTaskPackage* package = MatrixParallelFactory.CreateBaseTask<double>();
+            package->Left = (nint)left.Buffer;
+            package->Right = (nint)right.Buffer;
+            package->Answer = (nint)ans.Buffer;
+            package->ElementSize = sizeof(double);
+            package->PrimCount = ans.KernelColumnLength;
+            package->SecCount = ans.KernelRowLength;
+            package->ComputeMode = new MatrixOpMode(MatrixIndexStyle.BUFFER_INDEX, MatrixOperationParam.LEFT_RIGHT_ANS_PARAM);
+            package->ComputeHandle = (IntPtr)NativeIntrinsic.Context.mat[f64].buffer_add;
+            MatrixParallelHandle taskGroup = MatrixParallel.ScheduleTask(package);
+
+            MatrixParallel.LaunchParallel(taskGroup, SleepMode.DeepSleep);
+            taskGroup.Dispose();
+            return;
+        }
+
+        public static unsafe void Fill(
+                                  Matrix<double> ans,
+                                  double value
+        )
+        {
+            int f64 = (int)MatrixElementType.F64;
+            long count = (long)ans.KernelColumnLength * ans.KernelRowLength;
+            ScalarPacket* scalar = MatrixParallelFactory.CreateScalarPacket();
+            scalar->Data<double>(0) = value;
+            if (count <= 256)
+            {
+                NativeIntrinsic.Context.mat[f64].buffer_fill(ans.Buffer, scalar, count);
+                return;
+            } else if (count <= 1024)
+            {
+                MatrixParallelThread[] pool = MatrixParallel.LeadParallel(1);
+                NativeIntrinsic.Context.mat[f64].buffer_fill(ans.Buffer, scalar, count);
+                MatrixParallel.ReturnParallelResources(ref pool);
+                return;
+            }
+            MatrixParallelTaskPackage* package = MatrixParallelFactory.CreateBaseTask<double>();
+            package->Answer = (nint)ans.Buffer;
+            package->ElementSize = sizeof(double);
+            package->PrimCount = ans.KernelColumnLength;
+            package->SecCount = ans.KernelRowLength;
+            package->ComputeMode = new MatrixOpMode(MatrixIndexStyle.BUFFER_INDEX, MatrixOperationParam.ANS_SCALAR_PARAM);
+            package->ComputeHandle = (IntPtr)NativeIntrinsic.Context.mat[f64].buffer_fill;
+            package->Scalar = scalar;
+            MatrixParallelHandle taskGroup = MatrixParallel.ScheduleTask(package);
+            MatrixParallel.LaunchParallel(taskGroup, SleepMode.DeepSleep);
+            MatrixParallelFactory.Release(scalar);
+            taskGroup.Dispose();
+        }
+
+        public static unsafe void Mul(
+                                  Matrix<double> left,
+                                  Matrix<double> right,
+                                  Matrix<double> ans
+        )
+        {
+            int f64 = (int)MatrixElementType.F64;
+
+            // For matrix multiplication (left: MxK) * (right: KxN) => ans: MxN
+            // ColumnLength = number of columns (N), RowLength = number of rows (M)
+            if (left.ColumnLength != right.RowLength ||
+                ans.ColumnLength != right.ColumnLength ||
+                ans.RowLength != left.RowLength)
+            {
+                throw new IndexOutOfRangeException("Matrix dimensions must agree.");
+            }
+            long count = (long)left.KernelColumnLength * left.KernelRowLength;
+            int size = MatrixPanel.KernelSideCount<double>();
+            if (count <= 1024)
+            {
+                MatrixParallelThread[] pool = null;
+                if (count > 256) {
+                    pool = MatrixParallel.LeadParallel(1);
+                }
+                if (NativeIntrinsic.Context.mat[f64].build_panel == null)
+                {
+                    for (int i = 0; i < ans.KernelRowLength; i += size)
+                    {
+                        for (int j = 0; j < ans.KernelColumnLength; j += size)
+                        {
+                            MatrixKernel<double>* ansPanel = ans.GetKernelAddressUnsafe(i, j);
+                            NativeIntrinsic.Context.mat[f64].clear_panel((MatrixPanel*)ansPanel);
+
+                            // Console.WriteLine($"{i}{j}");
+                            for (int k = 0; k < left.KernelColumnLength; k += size)
+                            {
+                                NativeIntrinsic.Context
+                                               .mat[f64].panel_fma((MatrixPanel*)left.GetKernelAddressUnsafe(i, k),
+                                                                (MatrixPanel*)right.GetKernelAddressUnsafe(k, j),
+                                                                (MatrixPanel*)ansPanel);
+                            }
+                        }
+                    }
+                } else
+                {
+                    MatrixPanel<double>* leftPanel = MatrixPanel.Create<double>();
+                    MatrixPanel<double>* rightPanel = MatrixPanel.Create<double>();
+                    MatrixPanel<double>* ansPanel = MatrixPanel.Create<double>();
+                    for (int i = 0; i < ans.KernelRowLength; i += size)
+                    {
+                        for (int j = 0; j < ans.KernelColumnLength; j += size)
+                        {
+                            NativeIntrinsic.Context.mat[f64].clear_panel((MatrixPanel*)ansPanel);
+
+                            // Console.WriteLine($"{i}{j}");
+                            for (int k = 0; k < left.KernelColumnLength; k += size)
+                            {
+                                NativeIntrinsic.Context
+                                               .mat[f64].build_panel((MatrixPanel*)leftPanel,
+                                                                     (MatrixKernel*)left.Buffer,
+                                                                     left.KernelColumnLength,
+                                                                     left.KernelRowLength, i, k);
+                                NativeIntrinsic.Context
+                                               .mat[f64].build_panel((MatrixPanel*)rightPanel,
+                                                                     (MatrixKernel*)right.Buffer,
+                                                                     right.KernelColumnLength,
+                                                                     right.KernelRowLength, k, j);
+                                NativeIntrinsic.Context
+                                               .mat[f64].panel_fma((MatrixPanel*)leftPanel,
+                                                                (MatrixPanel*)rightPanel,
+                                                                (MatrixPanel*)ansPanel);
+                            }
+                            NativeIntrinsic.Context
+                                           .mat[f64].store_panel((MatrixPanel*)ansPanel,
+                                                                 (MatrixKernel*)ans.Buffer,
+                                                                 ans.KernelColumnLength,
+                                                                 ans.KernelRowLength, i, j);
+                        }
+                    }
+                    MatrixPanel.Destroy(leftPanel);
+                    MatrixPanel.Destroy(rightPanel);
+                    MatrixPanel.Destroy(ansPanel);
+                }
+                if (count > 256) {
+                    MatrixParallel.ReturnParallelResources(ref pool!);
+                }
+                return;
+            }
+            MatrixParallelTaskPackage* package = MatrixParallelFactory.CreateBaseTask<double>();
+            package->Left = (nint)left.Buffer;
+            package->Right = (nint)right.Buffer;
+            package->Answer = (nint)ans.Buffer;
+            package->AnsPrimOffset = ans.KernelRowLength;
+            package->AnsSecOffset = ans.KernelColumnLength;
+            package->LeftPrimOffset = left.KernelColumnLength;
+            package->PrimCount = ans.KernelColumnLength / size;
+            package->SecCount = ans.KernelRowLength / size;
+            package->ElementSize = (int)MatrixElementType.F64;
+            package->ComputeMode = new MatrixOpMode(MatrixIndexStyle.BUFFER_INDEX, MatrixOperationSpecial.SEQ_FMA);
+            MatrixParallelHandle taskGroup = MatrixParallel.ScheduleTask(package);
+
+            MatrixParallel.LaunchParallel(taskGroup, SleepMode.DeepSleep);
+            taskGroup.Dispose();
+            return;
+        }
+
+        public static unsafe void Mul(
+                                  Matrix<double> left,
+                                  double right,
+                                  Matrix<double> ans
+        )
+        {
+            int f64 = (int)MatrixElementType.F64;
+            if (left.ColumnLength != ans.ColumnLength || left.RowLength != ans.RowLength) {
+                throw new IndexOutOfRangeException("Matrix dimensions must agree.");
+            }
+            if (left.Layout != MatrixLayout.DenseRectangle ||
+                ans.Layout != MatrixLayout.DenseRectangle) {
+                throw new NotSupportedException("Only dense rectangle matrices are supported.");
+            }
+            long count = (long)left.KernelColumnLength * left.KernelRowLength;
+            ScalarPacket* scalar = MatrixParallelFactory.CreateScalarPacket();
+            scalar->Data<double>(0) = right;
+            if (count <= 256)
+            {
+                MatrixKernel<double>* leftPtr = left.Buffer;
+                MatrixKernel<double>* ansPtr = ans.Buffer;
+                NativeIntrinsic.Context.mat[f64].buffer_scalar_mul(leftPtr, ansPtr, scalar, count);
+
+                return;
+            } else if (count <= 1024)
+            {
+                MatrixParallelThread[] pool = MatrixParallel.LeadParallel(1);
+
+                MatrixKernel<double>* leftPtr = left.Buffer;
+                MatrixKernel<double>* ansPtr = ans.Buffer;
+                NativeIntrinsic.Context.mat[f64].buffer_scalar_mul(leftPtr, ansPtr, scalar, count);
+
+                MatrixParallel.ReturnParallelResources(ref pool);
+                return;
+            }
+            MatrixParallelTaskPackage* package = MatrixParallelFactory.CreateBaseTask<double>();
+            package->Right = (nint)left.Buffer;
+            package->Answer = (nint)ans.Buffer;
+            package->ElementSize = sizeof(double);
+            package->PrimCount = left.KernelColumnLength;
+            package->SecCount = left.KernelRowLength;
+            package->Scalar = scalar;
+            package->ComputeMode = new MatrixOpMode(MatrixIndexStyle.BUFFER_INDEX, MatrixOperationParam.RIGHT_ANS_SCALAR_PARAM);
+            package->ComputeHandle = (IntPtr)NativeIntrinsic.Context.mat[f64].buffer_scalar_mul;
+            MatrixParallelHandle taskGroup = MatrixParallel.ScheduleTask(package);
+
+            MatrixParallel.LaunchParallel(taskGroup, SleepMode.DeepSleep);
+            taskGroup.Dispose();
+            MatrixParallelFactory.Release(scalar);
+            return;
+        }
+
+        public static unsafe void Sub(
+                                  Matrix<double> left,
+                                  Matrix<double> right,
+                                  Matrix<double> ans
+        )
+        {
+            int f64 = (int)MatrixElementType.F64;
+            if (left.ColumnLength != right.ColumnLength ||
+                left.RowLength != right.RowLength ||
+                left.ColumnLength != ans.ColumnLength ||
+                left.RowLength != ans.RowLength) {
+                throw new IndexOutOfRangeException("Matrix dimensions must agree.");
+            }
+            if (left.Layout != MatrixLayout.DenseRectangle ||
+                right.Layout != MatrixLayout.DenseRectangle ||
+                ans.Layout != MatrixLayout.DenseRectangle) {
+                throw new NotSupportedException("Only dense rectangle matrices are supported.");
+            }
+            long count = (long)left.KernelColumnLength * left.KernelRowLength;
+            if (count <= 256)
+            {
+                MatrixKernel<double>* leftPtr = left.Buffer;
+                MatrixKernel<double>* rightPtr = right.Buffer;
+                MatrixKernel<double>* ansPtr = ans.Buffer;
+                NativeIntrinsic.Context.mat[f64].buffer_sub(leftPtr, rightPtr, ansPtr, count);
+
+                return;
+            } else if (count <= 1024)
+            {
+                MatrixParallelThread[] pool = MatrixParallel.LeadParallel(1);
+
+                MatrixKernel<double>* leftPtr = left.Buffer;
+                MatrixKernel<double>* rightPtr = right.Buffer;
+                MatrixKernel<double>* ansPtr = ans.Buffer;
+                NativeIntrinsic.Context.mat[f64].buffer_sub(leftPtr, rightPtr, ansPtr, count);
+
+                MatrixParallel.ReturnParallelResources(ref pool);
+                return;
+            }
+            MatrixParallelTaskPackage* package = MatrixParallelFactory.CreateBaseTask<double>();
+            package->Left = (nint)left.Buffer;
+            package->Right = (nint)right.Buffer;
+            package->Answer = (nint)ans.Buffer;
+            package->ElementSize = sizeof(double);
+            package->PrimCount = left.KernelColumnLength;
+            package->SecCount = left.KernelRowLength;
+            package->ComputeMode = new MatrixOpMode(MatrixIndexStyle.BUFFER_INDEX, MatrixOperationParam.LEFT_RIGHT_ANS_PARAM);
+            package->ComputeHandle = (IntPtr)NativeIntrinsic.Context.mat[f64].buffer_sub;
+            MatrixParallelHandle taskGroup = MatrixParallel.ScheduleTask(package);
+
+            MatrixParallel.LaunchParallel(taskGroup, SleepMode.DeepSleep);
+            taskGroup.Dispose();
+            return;
+        }
+
+    }
+}

StgSharp.Mathematics/Numeric/MatrixComputeModel.cs

@@ -34,7 +34,9 @@ namespace StgSharp.Mathematics.Numeric
     internal static class MatrixComputeModel
     {
 
-        internal static unsafe void BufferComputeBinary(MatrixParallelTaskPackage* p)
+        internal static unsafe void BufferComputeBinary(
+                                    MatrixParallelTaskPackage* p
+        )
         {
             int size = p->ElementSize * 16;
             long count = Unsafe.As<int, long>(ref p->PrimCount);
@@ -47,7 +49,9 @@ namespace StgSharp.Mathematics.Numeric
             MatrixParallelFactory.Release(p);
         }
 
-        internal static unsafe void BufferComputeBinaryScalar(MatrixParallelTaskPackage* p)
+        internal static unsafe void BufferComputeBinaryScalar(
+                                    MatrixParallelTaskPackage* p
+        )
         {
             int size = p->ElementSize * 16;
             long count = Unsafe.As<int, long>(ref p->PrimCount);
@@ -61,7 +65,9 @@ namespace StgSharp.Mathematics.Numeric
             MatrixParallelFactory.Release(p);
         }
 
-        internal static unsafe void BufferComputeNoOperatorScalar(MatrixParallelTaskPackage* p)
+        internal static unsafe void BufferComputeNoOperatorScalar(
+                                    MatrixParallelTaskPackage* p
+        )
         {
             int size = p->ElementSize * 16;
             long count = Unsafe.As<int, long>(ref p->PrimCount);
@@ -71,7 +77,9 @@ namespace StgSharp.Mathematics.Numeric
             MatrixParallelFactory.Release(p);
         }
 
-        internal static unsafe void BufferComputeUnary(MatrixParallelTaskPackage* p)
+        internal static unsafe void BufferComputeUnary(
+                                    MatrixParallelTaskPackage* p
+        )
         {
             int size = p->ElementSize * 16;
             long count = Unsafe.As<int, long>(ref p->PrimCount);
@@ -83,7 +91,9 @@ namespace StgSharp.Mathematics.Numeric
             MatrixParallelFactory.Release(p);
         }
 
-        internal static unsafe void BufferComputeUnaryScalar(MatrixParallelTaskPackage* p)
+        internal static unsafe void BufferComputeUnaryScalar(
+                                    MatrixParallelTaskPackage* p
+        )
         {
             int size = p->ElementSize * 16;
             long count = Unsafe.As<int, long>(ref p->PrimCount);
@@ -95,16 +105,28 @@ namespace StgSharp.Mathematics.Numeric
             MatrixParallelFactory.Release(p);
         }
 
-        internal static unsafe void SpecialBufferCompute(MatrixParallelTaskPackage* p)
+        internal static unsafe void SpecialBufferCompute(
+                                    MatrixParallelTaskPackage* p
+        )
         {
             switch ((MatrixOperationSpecial)p->ComputeMode.ParameterStyle)
             {
                 case MatrixOperationSpecial.SEQ_FMA:
+                    switch ((MatrixElementType)p->ElementSize)
+                    {
+                        case MatrixElementType.F64:
+                            MatrixCompute.ComputeFmaPanelF64(p);
+                            return;
+                        case MatrixElementType.F32:
                             MatrixCompute.ComputeFmaPanelF32(p);
                             break;
                         default:
                             break;
                     }
+                    break;
+                default:
+                    break;
+            }
             MatrixParallelFactory.Release(p);
         }
 

StgSharp.Mathematics/Numeric/MatrixParallelTaskPackage.cs

@@ -78,18 +78,34 @@ namespace StgSharp.Mathematics.Numeric
     }
 
     [StructLayout(LayoutKind.Sequential)]
-    public struct MatrixOpMode(MatrixIndexStyle style, MatrixOperationParam paramLayout)
+    public struct MatrixOpMode(
+                  MatrixIndexStyle style,
+                  MatrixOperationParam paramLayout
+    )
     {
 
         public MatrixIndexStyle OperationStyle = style;
 
         public MatrixOperationParam ParameterStyle = paramLayout;
 
-        public MatrixOpMode(MatrixIndexStyle style, MatrixOperationSpecial paramLayout)
+        public MatrixOpMode(
+               MatrixIndexStyle style,
+               MatrixOperationSpecial paramLayout
+        )
             : this(style, (MatrixOperationParam)paramLayout) { }
 
     }
 
+    public enum MatrixElementType : int
+    {
+
+        F32 = 0,
+        F64 = 1,
+        I32 = 2,
+        I64 = 3,
+
+    }
+
     [StructLayout(LayoutKind.Explicit, Size = 128)]
     public unsafe struct MatrixParallelTaskPackage
     {
@@ -97,7 +113,8 @@ namespace StgSharp.Mathematics.Numeric
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static unsafe void Copy(
                                   MatrixParallelTaskPackage* source,
-                                  MatrixParallelTaskPackage* target)
+                                  MatrixParallelTaskPackage* target
+        )
         {
             Buffer.MemoryCopy(source, target, sizeof(MatrixParallelTaskPackage),
                               sizeof(MatrixParallelTaskPackage));

StgSharp.Native/sn-head/sn_intrinsic.h

@@ -186,15 +186,10 @@ typedef void(SN_DECL *KER_PROC_LAS)(mat_kernel *matrix, mat_kernel *ans, scalar_
 
 #pragma region special matrix kernel operation
 
-typedef void(SN_DECL *POVITPROC)(mat_kernel const *source, mat_kernel *ans);
-#define MAT_POVIT_PROC(T_type, T_arch) povit_##T_type##_##T_arch
-#define DECLARE_MAT_POVIT_PROC(T_type, T_arch)                                                    \
-        INTERNAL void SN_DECL MAT_POVIT_PROC(T_type, T_arch)(MAT_KERNEL(T_type) const *source,    \
-                                                             size_t col_begin, size_t col_length, \
-                                                             size_t *restrict ans)
-DECLARE_MAT_POVIT_PROC(float, sse);
-DECLARE_MAT_POVIT_PROC(float, avx);
-DECLARE_MAT_POVIT_PROC(float, 512);
+typedef void(SN_DECL *PIVOTPROC)(mat_kernel const *source, size_t col_begin, size_t col_length,
+                                 size_t *restrict ans);
+INTERNAL void SN_DECL pivot_float(MAT_KERNEL(float) const *source, size_t col_begin,
+                                  size_t col_length, size_t *restrict ans);
 
 #pragma endregion
 
@@ -210,10 +205,18 @@ DECLARE_BUF_PROC_LEFT_RIGHT_ANS(float, sse, add);
 DECLARE_BUF_PROC_LEFT_RIGHT_ANS(float, avx, add);
 DECLARE_BUF_PROC_LEFT_RIGHT_ANS(float, 512, add);
 
+DECLARE_BUF_PROC_LEFT_RIGHT_ANS(double, sse, add);
+DECLARE_BUF_PROC_LEFT_RIGHT_ANS(double, avx, add);
+DECLARE_BUF_PROC_LEFT_RIGHT_ANS(double, 512, add);
+
 DECLARE_BUF_PROC_LEFT_RIGHT_ANS(float, sse, sub);
 DECLARE_BUF_PROC_LEFT_RIGHT_ANS(float, avx, sub);
 DECLARE_BUF_PROC_LEFT_RIGHT_ANS(float, 512, sub);
 
+DECLARE_BUF_PROC_LEFT_RIGHT_ANS(double, sse, sub);
+DECLARE_BUF_PROC_LEFT_RIGHT_ANS(double, avx, sub);
+DECLARE_BUF_PROC_LEFT_RIGHT_ANS(double, 512, sub);
+
 DECLARE_KER_PROC_RIGHT_ANS(float, sse, transpose);
 DECLARE_KER_PROC_RIGHT_ANS(float, avx, transpose);
 DECLARE_KER_PROC_RIGHT_ANS(float, 512, transpose);
@@ -222,10 +225,18 @@ DECLARE_BUF_PROC_RIGHT_ANS_SCALAR(float, sse, scalar_mul);
 DECLARE_BUF_PROC_RIGHT_ANS_SCALAR(float, avx, scalar_mul);
 DECLARE_BUF_PROC_RIGHT_ANS_SCALAR(float, 512, scalar_mul);
 
+DECLARE_BUF_PROC_RIGHT_ANS_SCALAR(double, sse, scalar_mul);
+DECLARE_BUF_PROC_RIGHT_ANS_SCALAR(double, avx, scalar_mul);
+DECLARE_BUF_PROC_RIGHT_ANS_SCALAR(double, 512, scalar_mul);
+
 DECLARE_BUF_PROC_ANS_SCALAR(float, sse, fill);
 DECLARE_BUF_PROC_ANS_SCALAR(float, avx, fill);
 DECLARE_BUF_PROC_ANS_SCALAR(float, 512, fill);
 
+DECLARE_BUF_PROC_ANS_SCALAR(double, sse, fill);
+DECLARE_BUF_PROC_ANS_SCALAR(double, avx, fill);
+DECLARE_BUF_PROC_ANS_SCALAR(double, 512, fill);
+
 #pragma endregion
 
 #pragma region fma
@@ -233,6 +244,10 @@ DECLARE_PNL_PROC_ANS(float, sse, clear);
 DECLARE_PNL_PROC_ANS(float, avx, clear);
 DECLARE_PNL_PROC_ANS(float, 512, clear);
 
+DECLARE_PNL_PROC_ANS(double, sse, clear);
+DECLARE_PNL_PROC_ANS(double, avx, clear);
+DECLARE_PNL_PROC_ANS(double, 512, clear);
+
 DECLARE_PNL_PROC_LEFT_RIGHT_ANS(float, sse, fma);
 DECLARE_PNL_PROC_LEFT_RIGHT_ANS(float, avx, fma);
 DECLARE_PNL_PROC_LEFT_RIGHT_ANS(float, avx_fma, fma);
@@ -269,24 +284,31 @@ INTERNAL int SN_DECL index_pair_sse(short const *str, uint32_t target, int lengt
 
 #pragma endregion
 
+typedef struct mat_intrinsic {
+        BUF_PROC_LRA buffer_add;
+        BUF_PROC_AS buffer_fill;
+        BUF_PROC_RAS buffer_scalar_mul;
+        BUF_PROC_LRA buffer_sub;
+        KER_PROC_RA buffer_transpose;
+        PANEL_PROC build_panel;
+        PANEL_PROC clear_panel;
+        PNL_PROC_LRA panel_fma;
+        PIVOTPROC pivot;
+        PANEL_PROC store_panel;
+
+} mat_intrinsic;
+
 // Mirrors C# IntrinsicContext field order so managed/unmanaged layouts stay in sync.
 typedef struct sn_intrinsic {
         HASH city_hash_simplify;
-        BUF_PROC_LRA f32_buffer_add;
-        BUF_PROC_AS f32_buffer_fill;
-        BUF_PROC_RAS f32_buffer_scalar_mul;
-        BUF_PROC_LRA f32_buffer_sub;
-        KER_PROC_RA f32_buffer_transpose;
-        PANEL_PROC f32_build_panel;
-        PANEL_PROC f32_clear_panel;
-        VECTORNORMALIZEPROC f32_normalize_3;
-        PNL_PROC_LRA f32_panel_fma;
-        PANEL_PROC f32_store_panel;
         FACTORIALROC factorial_simd;
         INDEX_PAIR index_pair;
-        BUF_PROC_RAS variant;
+        VECTORNORMALIZEPROC vec_f32_normalize_3;
+        mat_intrinsic mat[4];
 } sn_intrinsic;
 
+typedef enum elment_type { F32 = 0, F64 = 1, I32 = 2, I64 = 3 } element_type;
+
 typedef enum most_advanced_instruction {
 #ifdef _MSC_VER
         SSE = __IA_SUPPORT_SSE42,

StgSharp.Native/sn-head/sn_matkernel.h

@@ -13,18 +13,26 @@
 #define ZMMCOUNT(T) (sizeof(T) / 4)
 
 #define MAT_KERNEL(T)                       \
-        union {                              \
-                __m128 xmm[XMMCOUNT(T) / 4]; \
-                __m256 ymm[YMMCOUNT(T) / 4]; \
-                __m512 zmm[ZMMCOUNT(T) / 4]; \
+        union /* MAT_KERNEL_##T## /**/ {    \
+                __m128 f32_x[XMMCOUNT(T)];  \
+                __m256 f32_y[YMMCOUNT(T)];  \
+                __m512 f32_z[ZMMCOUNT(T)];  \
+                                            \
+                __m128d f64_x[XMMCOUNT(T)]; \
+                __m256d f64_y[YMMCOUNT(T)]; \
+                __m512d f64_z[ZMMCOUNT(T)]; \
                 T m[4][4];                  \
         }
 
 #define VEC(T)                                  \
         union {                                 \
-                __m128 xmm[XMMCOUNT(T) / 4]; \
-                __m256 ymm[YMMCOUNT(T) / 4]; \
-                __m512 zmm[ZMMCOUNT(T) / 4]; \
+                __m128 f32_x[XMMCOUNT(T) / 4];  \
+                __m256 f32_y[YMMCOUNT(T) / 4];  \
+                __m512 f32_z[ZMMCOUNT(T) / 4];  \
+                                                \
+                __m128d f64_x[XMMCOUNT(T) / 4]; \
+                __m256d f64_y[YMMCOUNT(T) / 4]; \
+                __m512d f64_z[ZMMCOUNT(T) / 4]; \
                 T v[4];                         \
         }
 
@@ -35,6 +43,8 @@ typedef MAT_KERNEL(uint64_t) sn_zero_kernel_u64;
 #define SN_LANES(T_VEC, T) (sizeof(T_VEC) / sizeof(T))
 #define SN_MAX(a, b) (((a)) > ((b)) ? (a) : (b))
 #define SN_CEIL_DIV(a, b) (((a) + (b) - 1) / (b))
+#define SN_BITS(x) ((int)(sizeof(x) * 8))
+#define PANEL_MINQ(T_VEC, T) SN_MAX(4, SN_MAX(SN_BITS(T_VEC) / 64, SN_BITS(T_VEC) / SN_BITS(T)))
 
 /* Panel geometry helpers (all compile-time): */
 #define PANEL_Q(T, T_VEC, MINQ) SN_MAX(SN_LANES(T_VEC, T), (MINQ))
@@ -60,26 +70,25 @@ typedef MAT_KERNEL(uint64_t) sn_zero_kernel_u64;
 
 /* ISA presets with minimum square side:
         - SSE  : MINQ=4   (avoid 2x2 for double)
-        - AVX2 : MINQ=8
-        - AVX-512: MINQ=8 (16 for float/i32 naturally, so this is a no-op there)
+        - AVX2 : MINQ computed as max(4, vector_bits/64, vector_bits/element_bits)
+        - AVX-512: same rule (float/i32 naturally expand to 16)
 */
 
 /* SSE panel layout: column-major buffer holding 4 logical columns with MINQ=4.
         Columns: each column packs up to four scalars so ALIGN equals sizeof(__m128).
         Alignment: every column boundary lands on a 16-byte multiple for XMM loads. */
-#define MAT_PANEL_sse(T) SN_ALIGNAS(16) MAT_PANEL_SQ_MIN_NOALIGN(T, __m128, 4)
-/* AVX2 panel layout: column-major buffer holding 8 logical columns with MINQ=8.
-        Columns: each column stores eight elements via two 256-bit chunks when T is 32-bit.
+#define MAT_PANEL_sse(T) SN_ALIGNAS(16) MAT_PANEL_SQ_MIN_NOALIGN(T, __m128, PANEL_MINQ(__m128, T))
+/* AVX2 panel layout: column-major buffer holding 8 logical columns with MINQ per PANEL_MINQ.
+        Columns: each column stores up to lanes elements via contiguous chunks.
         Alignment: column starts are 32-byte aligned so AVX2 loads/stores remain contiguous. */
-#define MAT_PANEL_avx(T) SN_ALIGNAS(32) MAT_PANEL_SQ_MIN_NOALIGN(T, __m256, 8)
-/* AVX2 panel layout: column-major buffer holding 8 logical columns with MINQ=8.
-        Columns: each column stores eight elements via two 256-bit chunks when T is 32-bit.
-        Alignment: column starts are 32-byte aligned so AVX2 loads/stores remain contiguous. */
-#define MAT_PANEL_avx_fma(T) SN_ALIGNAS(32) MAT_PANEL_SQ_MIN_NOALIGN(T, __m256, 8)
+#define MAT_PANEL_avx(T) SN_ALIGNAS(32) MAT_PANEL_SQ_MIN_NOALIGN(T, __m256, PANEL_MINQ(__m256, T))
+/* AVX2/FMA panel layout shares the same geometry as AVX2. */
+#define MAT_PANEL_avx_fma(T) \
+        SN_ALIGNAS(32) MAT_PANEL_SQ_MIN_NOALIGN(T, __m256, PANEL_MINQ(__m256, T))
 /* AVX-512 panel layout: column-major buffer holding 8 or more columns depending on T.
-        Columns: each column expands to ceil(Q/lanes) ZMM chunks; default MINQ=8 keeps doublse-wide tiles.
+        Columns: each column expands to ceil(Q/lanes) ZMM chunks.
         Alignment: column starts sit on 64-byte boundaries to match AVX-512 streaming access. */
-#define MAT_PANEL_512(T) SN_ALIGNAS(64) MAT_PANEL_SQ_MIN_NOALIGN(T, __m512, 8)
+#define MAT_PANEL_512(T) SN_ALIGNAS(64) MAT_PANEL_SQ_MIN_NOALIGN(T, __m512, PANEL_MINQ(__m512, T))
 
 /* Global zero kernel declaration (defined in dllmain.c), aligned to 64 bytes */
 #ifdef __cplusplus
@@ -117,12 +126,15 @@ extern __declspec(align(64)) sn_zero_kernel_u64 SN_ZERO_KERNEL;
                                                          int col_index, int row_index)
 
 /* Declarations for AVX float variant */
-DECLARE_BUILD_PANEL(sse, float);
 DECLARE_BUILD_PANEL(avx, float);
 DECLARE_BUILD_PANEL(512, float);
-DECLARE_STORE_PANEL(sse, float);
+
 DECLARE_STORE_PANEL(avx, float);
 DECLARE_STORE_PANEL(512, float);
 DECLARE_STORE_PANEL(512, float);
 
+DECLARE_BUILD_PANEL(512, double);
+
+DECLARE_STORE_PANEL(512, double);
+
 #endif /* SN_MATKERNEL */

StgSharp.Native/sn-src/k_basicop.c

@@ -24,28 +24,53 @@ DECLARE_PNL_PROC_ANS(float, 512, clear)
         }
 }
 
+DECLARE_PNL_PROC_ANS(double, sse, clear)
+{
+        register __m128 zero = _mm_setzero_ps();
+        PANEL_COL_VEC((*ans), 0, 0) = zero;
+        PANEL_COL_VEC((*ans), 1, 0) = zero;
+        PANEL_COL_VEC((*ans), 2, 0) = zero;
+        PANEL_COL_VEC((*ans), 3, 0) = zero;
+}
+
+DECLARE_PNL_PROC_ANS(double, avx, clear)
+{
+        register __m256 zero = _mm256_setzero_ps();
+        for (size_t i = 0; i < 8; i++) {
+                PANEL_COL_VEC((*ans), i, 0) = zero;
+        }
+}
+
+DECLARE_PNL_PROC_ANS(double, 512, clear)
+{
+        register __m512 zero = _mm512_setzero_ps();
+        for (size_t i = 0; i < 16; i++) {
+                PANEL_COL_VEC((*ans), i, 0) = zero;
+        }
+}
+
 // Matrix transpose implementations
 DECLARE_KER_PROC_RIGHT_ANS(float, sse, transpose)
 {
-        register __m128 col0 = right->xmm[0];
-        register __m128 col1 = right->xmm[1];
-        register __m128 col2 = right->xmm[2];
-        register __m128 col3 = right->xmm[3];
+        register __m128 col0 = right->f32_x[0];
+        register __m128 col1 = right->f32_x[1];
+        register __m128 col2 = right->f32_x[2];
+        register __m128 col3 = right->f32_x[3];
         register __m128 tmp0 = _mm_unpacklo_ps(col0, col1);
         register __m128 tmp1 = _mm_unpackhi_ps(col0, col1);
         register __m128 tmp2 = _mm_unpacklo_ps(col2, col3);
         register __m128 tmp3 = _mm_unpackhi_ps(col2, col3);
 
-        ans->xmm[0] = _mm_movelh_ps(tmp0, tmp2);
-        ans->xmm[1] = _mm_movehl_ps(tmp2, tmp0);
-        ans->xmm[2] = _mm_movelh_ps(tmp1, tmp3);
-        ans->xmm[3] = _mm_movehl_ps(tmp3, tmp1);
+        ans->f32_x[0] = _mm_movelh_ps(tmp0, tmp2);
+        ans->f32_x[1] = _mm_movehl_ps(tmp2, tmp0);
+        ans->f32_x[2] = _mm_movelh_ps(tmp1, tmp3);
+        ans->f32_x[3] = _mm_movehl_ps(tmp3, tmp1);
 }
 
 DECLARE_KER_PROC_RIGHT_ANS(float, avx, transpose)
 {
-        register __m256 col_low = right->ymm[0];
-        register __m256 col_high = right->ymm[1];
+        register __m256 col_low = right->f32_y[0];
+        register __m256 col_high = right->f32_y[1];
 
         register __m256 unpack_low = _mm256_unpacklo_ps(col_low, col_high);
         register __m256 unpack_high = _mm256_unpackhi_ps(col_low, col_high);
@@ -53,16 +78,16 @@ DECLARE_KER_PROC_RIGHT_ANS(float, avx, transpose)
         col_low = _mm256_permute2f128_ps(unpack_low, unpack_high, 0x20);
         col_high = _mm256_permute2f128_ps(unpack_low, unpack_high, 0x31);
 
-        ans->ymm[0] = _mm256_shuffle_ps(col_high, col_low, _MM_SHUFFLE(2, 0, 2, 0));
-        ans->ymm[1] = _mm256_shuffle_ps(col_high, col_low, _MM_SHUFFLE(3, 1, 3, 1));
+        ans->f32_y[0] = _mm256_shuffle_ps(col_high, col_low, _MM_SHUFFLE(2, 0, 2, 0));
+        ans->f32_y[1] = _mm256_shuffle_ps(col_high, col_low, _MM_SHUFFLE(3, 1, 3, 1));
 }
 
 DECLARE_KER_PROC_RIGHT_ANS(float, 512, transpose)
 {
-        register __m512 matrix = right->zmm[0];
+        register __m512 matrix = right->f32_z[0];
 
         const __m512i transpose_indices =
                 _mm512_setr_epi32(0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15);
 
-        ans->zmm[0] = _mm512_permutexvar_ps(transpose_indices, matrix);
+        ans->f32_z[0] = _mm512_permutexvar_ps(transpose_indices, matrix);
 }

StgSharp.Native/sn-src/k_bufop.c

@@ -4,10 +4,10 @@ DECLARE_BUF_PROC_ANS_SCALAR(float, sse, fill)
 {
         register __m128 vec = _mm_set_ps1(((float *)(scalar->data))[0]);
         for (size_t i = 0; i < count; i++) {
-                ans[i].xmm[0] = vec;
-                ans[i].xmm[1] = vec;
-                ans[i].xmm[2] = vec;
-                ans[i].xmm[3] = vec;
+                ans[i].f32_x[0] = vec;
+                ans[i].f32_x[1] = vec;
+                ans[i].f32_x[2] = vec;
+                ans[i].f32_x[3] = vec;
         }
 }
 
@@ -15,8 +15,8 @@ DECLARE_BUF_PROC_ANS_SCALAR(float, avx, fill)
 {
         register __m256 vec = _mm256_broadcast_ss(((float *)(scalar->data)));
         for (size_t i = 0; i < count; i++) {
-                ans[i].ymm[0] = vec;
-                ans[i].ymm[1] = vec;
+                ans[i].f32_y[0] = vec;
+                ans[i].f32_y[1] = vec;
         }
 }
 
@@ -24,22 +24,57 @@ DECLARE_BUF_PROC_ANS_SCALAR(float, 512, fill)
 {
         register __m512 vec = _mm512_broadcastss_ps(((__m128 *)(scalar->data))[0]);
         for (size_t i = 0; i < count; i++) {
-                ans[i].zmm[0] = vec;
+                ans[i].f32_z[0] = vec;
+        }
+}
+
+DECLARE_BUF_PROC_ANS_SCALAR(double, sse, fill)
+{
+        register __m128d vec = _mm_set1_pd(((double *)(scalar->data))[0]);
+        for (size_t i = 0; i < count; i++) {
+                ans[i].f64_x[0] = vec;
+                ans[i].f64_x[1] = vec;
+                ans[i].f64_x[2] = vec;
+                ans[i].f64_x[3] = vec;
+                ans[i].f64_x[4] = vec;
+                ans[i].f64_x[5] = vec;
+                ans[i].f64_x[6] = vec;
+                ans[i].f64_x[7] = vec;
+        }
+}
+
+DECLARE_BUF_PROC_ANS_SCALAR(double, avx, fill)
+{
+        register __m256d vec = _mm256_broadcast_sd(((double *)(scalar->data)));
+        for (size_t i = 0; i < count; i++) {
+                ans[i].f64_y[0] = vec;
+                ans[i].f64_y[1] = vec;
+                ans[i].f64_y[2] = vec;
+                ans[i].f64_y[3] = vec;
+        }
+}
+
+DECLARE_BUF_PROC_ANS_SCALAR(double, 512, fill)
+{
+        register __m512d vec = _mm512_broadcastsd_pd(_mm_loadu_pd(scalar));
+        for (size_t i = 0; i < count; i++) {
+                ans[i].f64_z[0] = vec;
+                ans[i].f64_z[1] = vec;
         }
 }
 
 DECLARE_BUF_PROC_LEFT_RIGHT_ANS(float, sse, add)
 {
         for (size_t i = 0; i < count; i++) {
-                register __m128 c0 = _mm_add_ps(left[i].xmm[0], right[i].xmm[0]);
-                register __m128 c1 = _mm_add_ps(left[i].xmm[1], right[i].xmm[1]);
-                register __m128 c2 = _mm_add_ps(left[i].xmm[2], right[i].xmm[2]);
-                register __m128 c3 = _mm_add_ps(left[i].xmm[3], right[i].xmm[3]);
+                register __m128 c0 = _mm_add_ps(left[i].f32_x[0], right[i].f32_x[0]);
+                register __m128 c1 = _mm_add_ps(left[i].f32_x[1], right[i].f32_x[1]);
+                register __m128 c2 = _mm_add_ps(left[i].f32_x[2], right[i].f32_x[2]);
+                register __m128 c3 = _mm_add_ps(left[i].f32_x[3], right[i].f32_x[3]);
 
-                ans[i].xmm[0] = c0;
-                ans[i].xmm[1] = c1;
-                ans[i].xmm[2] = c2;
-                ans[i].xmm[3] = c3;
+                ans[i].f32_x[0] = c0;
+                ans[i].f32_x[1] = c1;
+                ans[i].f32_x[2] = c2;
+                ans[i].f32_x[3] = c3;
         }
 }
 
@@ -47,51 +82,147 @@ DECLARE_BUF_PROC_LEFT_RIGHT_ANS(float, avx, add)
 {
         for (size_t i = 0; i < count; i++) {
                 size_t s = sizeof(MAT_KERNEL(float));
-                register __m256 c0 = _mm256_add_ps(left[i].ymm[0], right[i].ymm[0]);
-                register __m256 c1 = _mm256_add_ps(left[i].ymm[1], right[i].ymm[1]);
-                ans[i].ymm[0] = c0;
-                ans[i].ymm[1] = c1;
+                register __m256 c0 = _mm256_add_ps(left[i].f32_y[0], right[i].f32_y[0]);
+                register __m256 c1 = _mm256_add_ps(left[i].f32_y[1], right[i].f32_y[1]);
+                ans[i].f32_y[0] = c0;
+                ans[i].f32_y[1] = c1;
         }
 }
 
 DECLARE_BUF_PROC_LEFT_RIGHT_ANS(float, 512, add)
 {
         for (size_t i = 0; i < count; i++) {
-                register __m512 c0 = _mm512_add_ps(left[i].zmm[0], right[i].zmm[0]);
-                ans[i].zmm[0] = c0;
+                register __m512 c0 = _mm512_add_ps(left[i].f32_z[0], right[i].f32_z[0]);
+                ans[i].f32_z[0] = c0;
+        }
+}
+DECLARE_BUF_PROC_LEFT_RIGHT_ANS(double, sse, add)
+{
+        for (size_t i = 0; i < count; i++) {
+                register __m128d c0 = _mm_add_pd(_mm_castps_pd(left[i].f32_x[0]),
+                                                 _mm_castps_pd(right[i].f32_x[0]));
+                register __m128d c1 = _mm_add_pd(_mm_castps_pd(left[i].f32_x[1]),
+                                                 _mm_castps_pd(right[i].f32_x[1]));
+                register __m128d c2 = _mm_add_pd(_mm_castps_pd(left[i].f32_x[2]),
+                                                 _mm_castps_pd(right[i].f32_x[2]));
+                register __m128d c3 = _mm_add_pd(_mm_castps_pd(left[i].f32_x[3]),
+                                                 _mm_castps_pd(right[i].f32_x[3]));
+                register __m128d c4 = _mm_add_pd(_mm_castps_pd(left[i].f32_x[4]),
+                                                 _mm_castps_pd(right[i].f32_x[4]));
+                register __m128d c5 = _mm_add_pd(_mm_castps_pd(left[i].f32_x[5]),
+                                                 _mm_castps_pd(right[i].f32_x[5]));
+                register __m128d c6 = _mm_add_pd(_mm_castps_pd(left[i].f32_x[6]),
+                                                 _mm_castps_pd(right[i].f32_x[6]));
+                register __m128d c7 = _mm_add_pd(_mm_castps_pd(left[i].f32_x[7]),
+                                                 _mm_castps_pd(right[i].f32_x[7]));
+
+                ans[i].f32_x[0] = _mm_castpd_ps(c0);
+                ans[i].f32_x[1] = _mm_castpd_ps(c1);
+                ans[i].f32_x[2] = _mm_castpd_ps(c2);
+                ans[i].f32_x[3] = _mm_castpd_ps(c3);
+                ans[i].f32_x[4] = _mm_castpd_ps(c4);
+                ans[i].f32_x[5] = _mm_castpd_ps(c5);
+                ans[i].f32_x[6] = _mm_castpd_ps(c6);
+                ans[i].f32_x[7] = _mm_castpd_ps(c7);
+        }
+}
+
+DECLARE_BUF_PROC_LEFT_RIGHT_ANS(double, avx, add)
+{
+        for (size_t i = 0; i < count; i++) {
+                size_t s = sizeof(MAT_KERNEL(float));
+                register __m256d c0 = _mm256_add_pd(left[i].f64_y[0], right[i].f64_y[0]);
+                register __m256d c1 = _mm256_add_pd(left[i].f64_y[1], right[i].f64_y[1]);
+                register __m256d c2 = _mm256_add_pd(left[i].f64_y[0], right[i].f64_y[0]);
+                register __m256d c3 = _mm256_add_pd(left[i].f64_y[1], right[i].f64_y[1]);
+                ans[i].f64_y[0] = c0;
+                ans[i].f64_y[1] = c1;
+                ans[i].f64_y[2] = c2;
+                ans[i].f64_y[3] = c3;
+        }
+}
+
+DECLARE_BUF_PROC_LEFT_RIGHT_ANS(double, 512, add)
+{
+        for (size_t i = 0; i < count; i++) {
+                register __m512d c0 = _mm512_add_pd(left[i].f64_z[0], right[i].f64_z[0]);
+                register __m512d c1 = _mm512_add_pd(left[i].f64_z[1], right[i].f64_z[1]);
+                ans[i].f64_z[0] = c0;
+                ans[i].f64_z[1] = c1;
         }
 }
 
 DECLARE_BUF_PROC_LEFT_RIGHT_ANS(float, sse, sub)
 {
         for (size_t i = 0; i < count; i++) {
-                register __m128 c0 = _mm_sub_ps(left[i].xmm[0], right[i].xmm[0]);
-                register __m128 c1 = _mm_sub_ps(left[i].xmm[1], right[i].xmm[1]);
-                register __m128 c2 = _mm_sub_ps(left[i].xmm[2], right[i].xmm[2]);
-                register __m128 c3 = _mm_sub_ps(left[i].xmm[3], right[i].xmm[3]);
+                register __m128 c0 = _mm_sub_ps(left[i].f32_x[0], right[i].f32_x[0]);
+                register __m128 c1 = _mm_sub_ps(left[i].f32_x[1], right[i].f32_x[1]);
+                register __m128 c2 = _mm_sub_ps(left[i].f32_x[2], right[i].f32_x[2]);
+                register __m128 c3 = _mm_sub_ps(left[i].f32_x[3], right[i].f32_x[3]);
 
-                ans[i].xmm[0] = c0;
-                ans[i].xmm[1] = c1;
-                ans[i].xmm[2] = c2;
-                ans[i].xmm[3] = c3;
+                ans[i].f32_x[0] = c0;
+                ans[i].f32_x[1] = c1;
+                ans[i].f32_x[2] = c2;
+                ans[i].f32_x[3] = c3;
         }
 }
 
 DECLARE_BUF_PROC_LEFT_RIGHT_ANS(float, avx, sub)
 {
         for (size_t i = 0; i < count; i++) {
-                register __m256 c0 = _mm256_sub_ps(left[i].ymm[0], right[i].ymm[0]);
-                register __m256 c1 = _mm256_sub_ps(left[i].ymm[1], right[i].ymm[1]);
-                ans[i].ymm[0] = c0;
-                ans[i].ymm[1] = c1;
+                register __m256 c0 = _mm256_sub_ps(left[i].f32_y[0], right[i].f32_y[0]);
+                register __m256 c1 = _mm256_sub_ps(left[i].f32_y[1], right[i].f32_y[1]);
+                ans[i].f32_y[0] = c0;
+                ans[i].f32_y[1] = c1;
         }
 }
 
 DECLARE_BUF_PROC_LEFT_RIGHT_ANS(float, 512, sub)
 {
         for (size_t i = 0; i < count; i++) {
-                register __m512 c0 = _mm512_sub_ps(left[i].zmm[0], right[i].zmm[0]);
-                ans[i].zmm[0] = c0;
+                register __m512 c0 = _mm512_sub_ps(left[i].f32_z[0], right[i].f32_z[0]);
+                ans[i].f32_z[0] = c0;
+        }
+}
+
+DECLARE_BUF_PROC_LEFT_RIGHT_ANS(double, sse, sub)
+{
+        for (size_t i = 0; i < count; i++) {
+                register __m128d c0 = _mm_sub_pd(left[i].f64_x[0], right[i].f64_x[0]);
+                register __m128d c1 = _mm_sub_pd(left[i].f64_x[1], right[i].f64_x[1]);
+                register __m128d c2 = _mm_sub_pd(left[i].f64_x[2], right[i].f64_x[2]);
+                register __m128d c3 = _mm_sub_pd(left[i].f64_x[3], right[i].f64_x[3]);
+                register __m128d c4 = _mm_sub_pd(left[i].f64_x[4], right[i].f64_x[4]);
+                register __m128d c5 = _mm_sub_pd(left[i].f64_x[5], right[i].f64_x[5]);
+                register __m128d c6 = _mm_sub_pd(left[i].f64_x[6], right[i].f64_x[6]);
+                register __m128d c7 = _mm_sub_pd(left[i].f64_x[7], right[i].f64_x[7]);
+
+                ans[i].f64_x[0] = c0;
+                ans[i].f64_x[1] = c1;
+                ans[i].f64_x[2] = c2;
+                ans[i].f64_x[3] = c3;
+                ans[i].f64_x[4] = c4;
+                ans[i].f64_x[5] = c5;
+                ans[i].f64_x[6] = c6;
+                ans[i].f64_x[7] = c7;
+        }
+}
+
+DECLARE_BUF_PROC_LEFT_RIGHT_ANS(double, avx, sub)
+{
+        for (size_t i = 0; i < count; i++) {
+                register __m256 c0 = _mm256_sub_ps(left[i].f32_y[0], right[i].f32_y[0]);
+                register __m256 c1 = _mm256_sub_ps(left[i].f32_y[1], right[i].f32_y[1]);
+                ans[i].f32_y[0] = c0;
+                ans[i].f32_y[1] = c1;
+        }
+}
+
+DECLARE_BUF_PROC_LEFT_RIGHT_ANS(double, 512, sub)
+{
+        for (size_t i = 0; i < count; i++) {
+                register __m512 c0 = _mm512_sub_ps(left[i].f32_z[0], right[i].f32_z[0]);
+                ans[i].f32_z[0] = c0;
         }
 }
 
@@ -99,15 +230,15 @@ DECLARE_BUF_PROC_RIGHT_ANS_SCALAR(float, sse, scalar_mul)
 {
         register __m128 vec = _mm_set_ps1(((float *)(scalar->data))[0]);
         for (size_t i = 0; i < count; i++) {
-                register __m128 c0 = _mm_mul_ps(right[i].xmm[0], vec);
-                register __m128 c1 = _mm_mul_ps(right[i].xmm[1], vec);
-                register __m128 c2 = _mm_mul_ps(right[i].xmm[2], vec);
-                register __m128 c3 = _mm_mul_ps(right[i].xmm[3], vec);
+                register __m128 c0 = _mm_mul_ps(right[i].f32_x[0], vec);
+                register __m128 c1 = _mm_mul_ps(right[i].f32_x[1], vec);
+                register __m128 c2 = _mm_mul_ps(right[i].f32_x[2], vec);
+                register __m128 c3 = _mm_mul_ps(right[i].f32_x[3], vec);
 
-                ans[i].xmm[0] = c0;
-                ans[i].xmm[1] = c1;
-                ans[i].xmm[2] = c2;
-                ans[i].xmm[3] = c3;
+                ans[i].f32_x[0] = c0;
+                ans[i].f32_x[1] = c1;
+                ans[i].f32_x[2] = c2;
+                ans[i].f32_x[3] = c3;
         }
 }
 
@@ -115,11 +246,11 @@ DECLARE_BUF_PROC_RIGHT_ANS_SCALAR(float, avx, scalar_mul)
 {
         register __m256 vec = _mm256_broadcast_ss(((float *)(scalar->data)));
         for (size_t i = 0; i < count; i++) {
-                register __m256 c0 = _mm256_mul_ps(right[i].ymm[0], vec);
-                register __m256 c1 = _mm256_mul_ps(right[i].ymm[1], vec);
+                register __m256 c0 = _mm256_mul_ps(right[i].f32_y[0], vec);
+                register __m256 c1 = _mm256_mul_ps(right[i].f32_y[1], vec);
 
-                ans[i].ymm[0] = c0;
-                ans[i].ymm[1] = c1;
+                ans[i].f32_y[0] = c0;
+                ans[i].f32_y[1] = c1;
         }
 }
 
@@ -127,8 +258,60 @@ DECLARE_BUF_PROC_RIGHT_ANS_SCALAR(float, 512, scalar_mul)
 {
         register __m512 vec = _mm512_broadcastss_ps(((__m128 *)(scalar->data))[0]);
         for (size_t i = 0; i < count; i++) {
-                register __m512 c0 = _mm512_mul_ps(right[i].zmm[0], vec);
+                register __m512 c0 = _mm512_mul_ps(right[i].f32_z[0], vec);
 
-                ans[i].zmm[0] = c0;
+                ans[i].f32_z[0] = c0;
+        }
+}
+
+DECLARE_BUF_PROC_RIGHT_ANS_SCALAR(double, sse, scalar_mul)
+{
+        register __m128d vec = _mm_set1_pd(((double *)(scalar->data))[0]);
+        for (size_t i = 0; i < count; i++) {
+                register __m128d c0 = _mm_mul_pd(right[i].f64_x[0], vec);
+                register __m128d c1 = _mm_mul_pd(right[i].f64_x[1], vec);
+                register __m128d c2 = _mm_mul_pd(right[i].f64_x[2], vec);
+                register __m128d c3 = _mm_mul_pd(right[i].f64_x[3], vec);
+                register __m128d c4 = _mm_mul_pd(right[i].f64_x[4], vec);
+                register __m128d c5 = _mm_mul_pd(right[i].f64_x[5], vec);
+                register __m128d c6 = _mm_mul_pd(right[i].f64_x[6], vec);
+                register __m128d c7 = _mm_mul_pd(right[i].f64_x[7], vec);
+
+                ans[i].f64_x[0] = c0;
+                ans[i].f64_x[1] = c1;
+                ans[i].f64_x[2] = c2;
+                ans[i].f64_x[3] = c3;
+                ans[i].f64_x[4] = c4;
+                ans[i].f64_x[5] = c5;
+                ans[i].f64_x[6] = c6;
+                ans[i].f64_x[7] = c7;
+        }
+}
+
+DECLARE_BUF_PROC_RIGHT_ANS_SCALAR(double, avx, scalar_mul)
+{
+        register __m256d vec = _mm256_broadcast_sd(((double *)(scalar->data)));
+        for (size_t i = 0; i < count; i++) {
+                register __m256d c0 = _mm256_mul_pd(right[i].f64_y[0], vec);
+                register __m256d c1 = _mm256_mul_pd(right[i].f64_y[1], vec);
+                register __m256d c2 = _mm256_mul_pd(right[i].f64_y[2], vec);
+                register __m256d c3 = _mm256_mul_pd(right[i].f64_y[3], vec);
+
+                ans[i].f64_y[0] = c0;
+                ans[i].f64_y[1] = c1;
+                ans[i].f64_y[2] = c2;
+                ans[i].f64_y[3] = c3;
+        }
+}
+
+DECLARE_BUF_PROC_RIGHT_ANS_SCALAR(double, 512, scalar_mul)
+{
+        register __m512d vec = _mm512_broadcastsd_pd(_mm_load_pd(scalar));
+        for (size_t i = 0; i < count; i++) {
+                register __m512d c0 = _mm512_mul_pd(right[i].f64_z[0], vec);
+                register __m512d c1 = _mm512_mul_pd(right[i].f64_z[1], vec);
+
+                ans[i].f64_z[0] = c0;
+                ans[i].f64_z[1] = c1;
         }
 }

StgSharp.Native/sn-src/k_panel.c

@@ -31,8 +31,8 @@ DECLARE_BUILD_PANEL(avx, float)
                 const MAT_KERNEL(float) *src_bot = is_right_half ? k_rb : k_lb;
 
                 /* Vector loads: each kernel column is a compact __m128 */
-                top128 = src_top->xmm[kc_col];
-                bot128 = src_bot->xmm[kc_col];
+                top128 = src_top->f32_x[kc_col];
+                bot128 = src_bot->f32_x[kc_col];
 
                 /* Combine into an AVX column: low 128 = top, high 128 = bottom */
                 col256 = _mm256_set_m128(bot128, top128);
@@ -41,15 +41,6 @@ DECLARE_BUILD_PANEL(avx, float)
         }
 }
 
-DECLARE_BUILD_PANEL(sse, float)
-{
-        /* Single kernel -> 4 columns, each is one __m128 column vector. */
-        const MAT_KERNEL(float) *src = matrix + (row_index * col_length + col_index);
-
-        for (int pc = 0; pc < 4; ++pc) {
-                PANEL_COL_VEC((*panel), pc, 0) = src->xmm[pc];
-        }
-}
 
 DECLARE_BUILD_PANEL(512, float)
 {
@@ -71,10 +62,10 @@ DECLARE_BUILD_PANEL(512, float)
                 const int blk_col = pc >> 2; /* which kernel column block (0..3) */
                 const int kc_col = pc & 3; /* column inside a 4x4 kernel */
 
-                const __m128 r0 = k[blk_col][0]->xmm[kc_col];
-                const __m128 r1 = k[blk_col][1]->xmm[kc_col];
-                const __m128 r2 = k[blk_col][2]->xmm[kc_col];
-                const __m128 r3 = k[blk_col][3]->xmm[kc_col];
+                const __m128 r0 = k[blk_col][0]->f32_x[kc_col];
+                const __m128 r1 = k[blk_col][1]->f32_x[kc_col];
+                const __m128 r2 = k[blk_col][2]->f32_x[kc_col];
+                const __m128 r3 = k[blk_col][3]->f32_x[kc_col];
 
                 const __m256 top = _mm256_set_m128(r1, r0);
                 const __m256 bot = _mm256_set_m128(r3, r2);
@@ -86,6 +77,43 @@ DECLARE_BUILD_PANEL(512, float)
         }
 }
 
+
+DECLARE_BUILD_PANEL(512, double)
+{
+        const int Q = 8; /* max(4, lanes) for double with ZMM -> 8 columns */
+
+        const int has_right = (col_index + 1) < col_length;
+        const int has_bottom = (row_index + 1) < row_length;
+
+        const MAT_KERNEL(double) *const k_lt = matrix + (row_index * col_length + col_index);
+        const MAT_KERNEL(double) *const k_rt =
+                has_right ? (matrix + (row_index * col_length + (col_index + 1))) :
+                            (const MAT_KERNEL(double) *)&SN_ZERO_KERNEL;
+        const MAT_KERNEL(double) *const k_lb =
+                has_bottom ? (matrix + ((row_index + 1) * col_length + col_index)) :
+                             (const MAT_KERNEL(double) *)&SN_ZERO_KERNEL;
+        const MAT_KERNEL(double) *const k_rb =
+                (has_right && has_bottom) ?
+                        (matrix + ((row_index + 1) * col_length + (col_index + 1))) :
+                        (const MAT_KERNEL(double) *)&SN_ZERO_KERNEL;
+
+        for (int pc = 0; pc < Q; ++pc) {
+                const int is_right_half = (pc >= 4);
+                const int kc_col = pc & 3; /* column index inside 4x4 kernel */
+
+                const MAT_KERNEL(double) *src_top = is_right_half ? k_rt : k_lt;
+                const MAT_KERNEL(double) *src_bot = is_right_half ? k_rb : k_lb;
+
+                const __m256d top256 = src_top->f64_y[kc_col];
+                const __m256d bot256 = src_bot->f64_y[kc_col];
+
+                __m512d col = _mm512_castpd256_pd512(top256);
+                col = _mm512_insertf64x4(col, bot256, 1);
+
+                PANEL_COL_VEC((*panel), pc, 0) = _mm512_castpd_ps(col);
+        }
+}
+
 DECLARE_STORE_PANEL(avx, float)
 {
         const int Q = 8; /* fixed for AVX float panel */
@@ -124,8 +152,8 @@ DECLARE_STORE_PANEL(avx, float)
                 bot128 = _mm256_extractf128_ps(col256, 1); /* high 128 */
 
                 /* Store back into kernels directly (out-of-bounds writes go to dummy) */
-                k_rt->xmm[kc_col] = top128;
-                k_rb->xmm[kc_col] = bot128;
+                k_rt->f32_x[kc_col] = top128;
+                k_rb->f32_x[kc_col] = bot128;
         }
         for (; i < Q; i++) {
                 const int kc_col = i - 4; /* column index inside 4x4 kernel */
@@ -137,18 +165,8 @@ DECLARE_STORE_PANEL(avx, float)
                 bot128 = _mm256_extractf128_ps(col256, 1); /* high 128 */
 
                 /* Store back into kernels directly (out-of-bounds writes go to dummy) */
-                k_lt->xmm[kc_col] = top128;
-                k_lb->xmm[kc_col] = bot128;
-        }
-}
- 
-DECLARE_STORE_PANEL(sse, float)
-{
-        MAT_KERNEL(float) *dst = matrix + (row_index * col_length + col_index);
-
-        for (int pc = 0; pc < 4; ++pc) {
-                const __m128 col = PANEL_COL_VEC((*panel), pc, 0);
-                dst->xmm[pc] = col;
+                k_lt->f32_x[kc_col] = top128;
+                k_lb->f32_x[kc_col] = bot128;
         }
 }
 
@@ -181,9 +199,99 @@ DECLARE_STORE_PANEL(512, float)
                 const __m128 r2 = _mm256_castps256_ps128(bot);
                 const __m128 r3 = _mm256_extractf128_ps(bot, 1);
 
-                k[blk_col][0]->xmm[kc_col] = r0;
-                k[blk_col][1]->xmm[kc_col] = r1;
-                k[blk_col][2]->xmm[kc_col] = r2;
-                k[blk_col][3]->xmm[kc_col] = r3;
+                k[blk_col][0]->f32_x[kc_col] = r0;
+                k[blk_col][1]->f32_x[kc_col] = r1;
+                k[blk_col][2]->f32_x[kc_col] = r2;
+                k[blk_col][3]->f32_x[kc_col] = r3;
+        }
+}
+
+DECLARE_STORE_PANEL(sse, double)
+{
+        MAT_KERNEL(double) *dst = matrix + (row_index * col_length + col_index);
+
+        for (int pc = 0; pc < 4; ++pc) {
+                const int base = pc * 2;
+                dst->f64_x[base] = _mm_castps_pd(PANEL_COL_VEC((*panel), pc, 0));
+                dst->f64_x[base + 1] = _mm_castps_pd(PANEL_COL_VEC((*panel), pc, 1));
+        }
+}
+
+DECLARE_STORE_PANEL(avx, double)
+{
+        const int Q = 8; /* fixed for AVX double panel */
+
+        MAT_KERNEL(double) zero;
+
+        const int has_right = (col_index + 1) < col_length;
+        const int has_bottom = (row_index + 1) < row_length;
+
+        MAT_KERNEL(double) *const k_lt = (col_index < col_length && row_index < row_length) ?
+                                                 (matrix + (row_index * col_length + col_index)) :
+                                                 &zero;
+        MAT_KERNEL(double) *const k_rt =
+                has_right && (row_index < row_length) ?
+                        (matrix + (row_index * col_length + (col_index + 1))) :
+                        &zero;
+        MAT_KERNEL(double) *const k_lb =
+                has_bottom && (col_index < col_length) ?
+                        (matrix + ((row_index + 1) * col_length + col_index)) :
+                        &zero;
+        MAT_KERNEL(double) *const k_rb =
+                (has_right && has_bottom) ?
+                        (matrix + ((row_index + 1) * col_length + (col_index + 1))) :
+                        &zero;
+
+        for (int i = 0; i < Q; ++i) {
+                const int kc_col = (i < 4) ? i : (i - 4);
+                const __m256 top_chunk = PANEL_COL_VEC((*panel), i, 0);
+                const __m256 bot_chunk = PANEL_COL_VEC((*panel), i, 1);
+
+                MAT_KERNEL(double) *const top_dst = (i < 4) ? k_rt : k_lt;
+                MAT_KERNEL(double) *const bot_dst = (i < 4) ? k_rb : k_lb;
+
+                top_dst->f64_y[kc_col] = _mm256_castps_pd(top_chunk);
+                bot_dst->f64_y[kc_col] = _mm256_castps_pd(bot_chunk);
+        }
+}
+
+DECLARE_STORE_PANEL(512, double)
+{
+        const int Q = 8; /* max(4, lanes) -> 8 columns, one ZMM per column */
+
+        MAT_KERNEL(double) zero;
+
+        const int has_right = (col_index + 1) < col_length;
+        const int has_bottom = (row_index + 1) < row_length;
+
+        MAT_KERNEL(double) *const k_lt = (col_index < col_length && row_index < row_length) ?
+                                                 (matrix + (row_index * col_length + col_index)) :
+                                                 &zero;
+        MAT_KERNEL(double) *const k_rt =
+                has_right && (row_index < row_length) ?
+                        (matrix + (row_index * col_length + (col_index + 1))) :
+                        &zero;
+        MAT_KERNEL(double) *const k_lb =
+                has_bottom && (col_index < col_length) ?
+                        (matrix + ((row_index + 1) * col_length + col_index)) :
+                        &zero;
+        MAT_KERNEL(double) *const k_rb =
+                (has_right && has_bottom) ?
+                        (matrix + ((row_index + 1) * col_length + (col_index + 1))) :
+                        &zero;
+
+        for (int i = 0; i < Q; ++i) {
+                const int kc_col = (i < 4) ? i : (i - 4);
+                const __m512 col = PANEL_COL_VEC((*panel), i, 0);
+                const __m512d col_pd = _mm512_castps_pd(col);
+
+                const __m256d top256 = _mm512_castpd512_pd256(col_pd);
+                const __m256d bot256 = _mm512_extractf64x4_pd(col_pd, 1);
+
+                MAT_KERNEL(double) *const top_dst = (i < 4) ? k_rt : k_lt;
+                MAT_KERNEL(double) *const bot_dst = (i < 4) ? k_rb : k_lb;
+
+                top_dst->f64_y[kc_col] = top256;
+                bot_dst->f64_y[kc_col] = bot256;
         }
 }

StgSharp.Native/sn-src/k_pivot.c

@@ -2,7 +2,7 @@
 
 // Hybrid implementation: SIMD for Abs, Scalar for Max
 // Assumes Column-Major layout for both MAT_KERNEL content and Kernel sequence
-static void povit_float(MAT_KERNEL(float) const *source, size_t col_begin,
+INTERNAL void SN_DECL pivot_float(MAT_KERNEL(float) const *source, size_t col_begin,
                                   size_t col_length, size_t *restrict ans)
 {
         float max_v[4] = { -1.0f, -1.0f, -1.0f, -1.0f };

StgSharp.Native/sn-src/load_intrinsic.c

@@ -65,17 +65,30 @@ void load_intrinsic_sse(sn_intrinsic *context)
         context->city_hash_simplify = city_hash_simplify_sse;
         context->factorial_simd = factorial_simd_sse;
         context->index_pair = index_pair_sse;
-        context->f32_store_panel = STORE_PANEL(sse, float);
-        context->f32_clear_panel = PNL_PROC(float, sse, clear);
-        context->f32_build_panel = BUILD_PANEL(sse, float);
-        context->f32_buffer_add = BUF_PROC(float, sse, add);
-        context->f32_panel_fma = PNL_PROC(float, sse, fma);
-        context->f32_buffer_fill = BUF_PROC(float, sse, fill);
-        context->variant = BUF_PROC(float, sse, scalar_mul);
-        context->f32_buffer_sub = BUF_PROC(float, sse, sub);
-        context->f32_buffer_transpose = KER_PROC(float, sse, transpose);
-        context->f32_buffer_scalar_mul = BUF_PROC(float, sse, scalar_mul);
-        context->f32_normalize_3 = f32_normalize;
+
+        context->mat[F32].buffer_add = BUF_PROC(float, sse, add);
+        context->mat[F32].buffer_fill = BUF_PROC(float, sse, fill);
+        context->mat[F32].buffer_scalar_mul = BUF_PROC(float, sse, scalar_mul);
+        context->mat[F32].buffer_sub = BUF_PROC(float, sse, sub);
+        context->mat[F32].buffer_transpose = KER_PROC(float, sse, transpose);
+        context->mat[F32].build_panel = NULL;
+        context->mat[F32].clear_panel = PNL_PROC(float, sse, clear);
+        context->mat[F32].panel_fma = PNL_PROC(float, sse, fma);
+        context->mat[F32].pivot = pivot_float;
+        context->mat[F32].store_panel = NULL;
+
+        context->mat[F64].buffer_add = BUF_PROC(double, sse, add);
+        context->mat[F64].buffer_fill = BUF_PROC(double, sse, fill);
+        context->mat[F64].buffer_scalar_mul = BUF_PROC(double, sse, scalar_mul);
+        context->mat[F64].buffer_sub = BUF_PROC(double, sse, sub);
+        context->mat[F64].buffer_transpose = NULL;
+        context->mat[F64].build_panel = NULL;
+        context->mat[F64].clear_panel = PNL_PROC(double, sse, clear);
+        context->mat[F64].panel_fma = NULL;
+        context->mat[F64].pivot = NULL;
+        context->mat[F64].store_panel = NULL;
+
+        context->vec_f32_normalize_3 = f32_normalize;
 }
 
 void load_intrinsic_avx(sn_intrinsic *context)
@@ -83,17 +96,30 @@ void load_intrinsic_avx(sn_intrinsic *context)
         context->city_hash_simplify = city_hash_simplify_sse;
         context->factorial_simd = factorial_simd_sse;
         context->index_pair = index_pair_sse;
-        context->f32_store_panel = STORE_PANEL(avx, float);
-        context->f32_clear_panel = PNL_PROC(float, avx, clear);
-        context->f32_build_panel = BUILD_PANEL(avx, float);
-        context->f32_buffer_add = BUF_PROC(float, avx, add);
-        context->f32_panel_fma = PNL_PROC(float, avx, fma);
-        context->f32_buffer_fill = BUF_PROC(float, avx, fill);
-        context->variant = BUF_PROC(float, avx, scalar_mul);
-        context->f32_buffer_sub = BUF_PROC(float, avx, sub);
-        context->f32_buffer_transpose = KER_PROC(float, avx, transpose);
-        context->f32_buffer_scalar_mul = BUF_PROC(float, avx, scalar_mul);
-        context->f32_normalize_3 = f32_normalize;
+
+        context->mat[F32].buffer_add = BUF_PROC(float, avx, add);
+        context->mat[F32].buffer_fill = BUF_PROC(float, avx, fill);
+        context->mat[F32].buffer_scalar_mul = BUF_PROC(float, avx, scalar_mul);
+        context->mat[F32].buffer_sub = BUF_PROC(float, avx, sub);
+        context->mat[F32].buffer_transpose = KER_PROC(float, avx, transpose);
+        context->mat[F32].build_panel = BUILD_PANEL(avx, float);
+        context->mat[F32].clear_panel = PNL_PROC(float, avx, clear);
+        context->mat[F32].panel_fma = PNL_PROC(float, avx, fma);
+        context->mat[F32].pivot = pivot_float;
+        context->mat[F32].store_panel = STORE_PANEL(avx, float);
+
+        context->mat[F64].buffer_add = BUF_PROC(double, avx, add);
+        context->mat[F64].buffer_fill = BUF_PROC(double, avx, fill);
+        context->mat[F64].buffer_scalar_mul = BUF_PROC(double, avx, scalar_mul);
+        context->mat[F64].buffer_sub = BUF_PROC(double, avx, sub);
+        context->mat[F64].buffer_transpose = NULL;
+        context->mat[F64].build_panel = NULL;
+        context->mat[F64].clear_panel = PNL_PROC(double, avx, clear);
+        context->mat[F64].panel_fma = NULL;
+        context->mat[F64].pivot = NULL;
+        context->mat[F64].store_panel = NULL;
+
+        context->vec_f32_normalize_3 = f32_normalize;
 }
 
 void load_intrinsic_512(sn_intrinsic *context)
@@ -101,15 +127,28 @@ void load_intrinsic_512(sn_intrinsic *context)
         context->city_hash_simplify = city_hash_simplify_sse;
         context->factorial_simd = factorial_simd_sse;
         context->index_pair = index_pair_sse;
-        context->f32_store_panel = STORE_PANEL(512, float);
-        context->f32_clear_panel = PNL_PROC(float, 512, clear);
-        context->f32_build_panel = BUILD_PANEL(512, float);
-        context->f32_buffer_add = BUF_PROC(float, 512, add);
-        context->f32_panel_fma = PNL_PROC(float, 512, fma);
-        context->f32_buffer_fill = BUF_PROC(float, 512, fill);
-        context->variant = BUF_PROC(float, 512, scalar_mul);
-        context->f32_buffer_sub = BUF_PROC(float, 512, sub);
-        context->f32_buffer_transpose = KER_PROC(float, 512, transpose);
-        context->f32_buffer_scalar_mul = BUF_PROC(float, 512, scalar_mul);
-        context->f32_normalize_3 = f32_normalize;
+
+        context->mat[F32].buffer_add = BUF_PROC(float, 512, add);
+        context->mat[F32].buffer_fill = BUF_PROC(float, 512, fill);
+        context->mat[F32].buffer_scalar_mul = BUF_PROC(float, 512, scalar_mul);
+        context->mat[F32].buffer_sub = BUF_PROC(float, 512, sub);
+        context->mat[F32].buffer_transpose = KER_PROC(float, 512, transpose);
+        context->mat[F32].build_panel = BUILD_PANEL(512, float);
+        context->mat[F32].clear_panel = PNL_PROC(float, 512, clear);
+        context->mat[F32].panel_fma = PNL_PROC(float, 512, fma);
+        context->mat[F32].pivot = pivot_float;
+        context->mat[F32].store_panel = STORE_PANEL(512, float);
+
+        context->mat[F64].buffer_add = BUF_PROC(double, 512, add);
+        context->mat[F64].buffer_fill = BUF_PROC(double, 512, fill);
+        context->mat[F64].buffer_scalar_mul = BUF_PROC(double, 512, scalar_mul);
+        context->mat[F64].buffer_sub = BUF_PROC(double, 512, sub);
+        context->mat[F64].buffer_transpose = NULL;
+        context->mat[F64].build_panel = BUILD_PANEL(512, double);
+        context->mat[F64].clear_panel = PNL_PROC(double, 512, clear);
+        context->mat[F64].panel_fma = NULL;
+        context->mat[F64].pivot = NULL;
+        context->mat[F64].store_panel = STORE_PANEL(512, double);
+
+        context->vec_f32_normalize_3 = f32_normalize;
 }

StgSharp.Native/sn-src/vector.c

@@ -3,7 +3,7 @@
 
 INTERNAL void SN_DECL f32_normalize(VEC(float) *restrict source, VEC(float) *restrict target)
 {
-        register __m128 s = _mm_load_ps(&source->xmm);
+        register __m128 s = _mm_load_ps(&source->f32_x);
         register __m128 a_length_sq = _mm_mul_ps(s, s);
         a_length_sq = _mm_add_ps(a_length_sq,
                                  _mm_shuffle_ps(a_length_sq, a_length_sq, _MM_SHUFFLE(2, 3, 0, 1)));
@@ -13,13 +13,13 @@ INTERNAL void SN_DECL f32_normalize(VEC(float) *restrict source, VEC(float) *res
         __m128 a_inv_length = _mm_rsqrt_ps(a_length_sq);
         s = _mm_mul_ps(s, a_inv_length);
 
-        __m128 dot_product = _mm_mul_ps(target->xmm[0], s);
+        __m128 dot_product = _mm_mul_ps(target->f32_x[0], s);
         dot_product = _mm_add_ps(dot_product,
                                  _mm_shuffle_ps(dot_product, dot_product, _MM_SHUFFLE(2, 3, 0, 1)));
         dot_product = _mm_add_ss(dot_product,
                                  _mm_shuffle_ps(dot_product, dot_product, _MM_SHUFFLE(0, 0, 3, 2)));
 
-        __m128 b_orthogonal = _mm_sub_ps(target->xmm[0], _mm_mul_ps(s, dot_product));
+        __m128 b_orthogonal = _mm_sub_ps(target->f32_x[0], _mm_mul_ps(s, dot_product));
 
         __m128 b_length_sq = _mm_mul_ps(b_orthogonal, b_orthogonal);
         b_length_sq = _mm_add_ps(b_length_sq,
@@ -28,5 +28,5 @@ INTERNAL void SN_DECL f32_normalize(VEC(float) *restrict source, VEC(float) *res
                                  _mm_shuffle_ps(b_length_sq, b_length_sq, _MM_SHUFFLE(0, 0, 3, 2)));
 
         __m128 b_inv_length = _mm_rsqrt_ps(b_length_sq);
-        target->xmm[0] = _mm_mul_ps(b_orthogonal, b_inv_length);
+        target->f32_x[0] = _mm_mul_ps(b_orthogonal, b_inv_length);
 }

StgSharp.Native/sn-src/vector_dot.c

@@ -6,12 +6,12 @@ static const int avxdot_indices[] = { 0, 4, 1, 5, 2, 3, 6, 7 };
 INTERNAL void FORCEINLINE SN_DECL dot_41_sse(MAT_KERNEL(float) const *transpose,
                                              __m128 const *vector, __m128 *ans)
 {
-        *ans = _mm_dp_ps(transpose->xmm[0], *vector, 0B11110001);
-        *ans = _mm_insert_ps(*ans, _mm_dp_ps(transpose->xmm[1], *vector, 0B11110001),
+        *ans = _mm_dp_ps(transpose->f32_x[0], *vector, 0B11110001);
+        *ans = _mm_insert_ps(*ans, _mm_dp_ps(transpose->f32_x[1], *vector, 0B11110001),
                              SSE_INSERT_SIMPLE(1, 1));
-        *ans = _mm_insert_ps(*ans, _mm_dp_ps(transpose->xmm[2], *vector, 0B11110001),
+        *ans = _mm_insert_ps(*ans, _mm_dp_ps(transpose->f32_x[2], *vector, 0B11110001),
                              SSE_INSERT_SIMPLE(1, 3));
-        *ans = _mm_insert_ps(*ans, _mm_dp_ps(transpose->xmm[3], *vector, 0B11110001),
+        *ans = _mm_insert_ps(*ans, _mm_dp_ps(transpose->f32_x[3], *vector, 0B11110001),
                              SSE_INSERT_SIMPLE(1, 4));
 }
 
@@ -19,8 +19,8 @@ INTERNAL void SN_DECL dot_41_avx(MAT_KERNEL(float) const *transpose, __m128 cons
                                  __m128 *ans)
 {
         __m256 _double = _mm256_set_m128(vector[0], vector[0]);
-        __m256 tmp = _mm256_dp_ps(transpose->ymm[0], _double, 0B11110001);
-        tmp = _mm256_blend_ps(tmp, _mm256_dp_ps(transpose->ymm[0], _double, 0B11110010),
+        __m256 tmp = _mm256_dp_ps(transpose->f32_y[0], _double, 0B11110001);
+        tmp = _mm256_blend_ps(tmp, _mm256_dp_ps(transpose->f32_y[0], _double, 0B11110010),
                               0B00100010);
         *ans = _mm256_castps256_ps128(
                 _mm256_permutevar8x32_ps(tmp, _mm256_loadu_epi32(avxdot_indices)));
@@ -29,34 +29,34 @@ INTERNAL void SN_DECL dot_41_avx(MAT_KERNEL(float) const *transpose, __m128 cons
 INTERNAL void SN_DECL dot_42_sse(MAT_KERNEL(float) const *transpose, __m128 const *vector,
                                  __m128 *ans)
 {
-        ans[0] = _mm_dp_ps(transpose->xmm[0], vector[0], 0B11110001);
-        ans[0] = _mm_insert_ps(*ans, _mm_dp_ps(transpose->xmm[1], vector[0], 0B11110001),
+        ans[0] = _mm_dp_ps(transpose->f32_x[0], vector[0], 0B11110001);
+        ans[0] = _mm_insert_ps(*ans, _mm_dp_ps(transpose->f32_x[1], vector[0], 0B11110001),
                                SSE_INSERT_SIMPLE(1, 2));
-        ans[0] = _mm_insert_ps(*ans, _mm_dp_ps(transpose->xmm[2], vector[0], 0B11110001),
+        ans[0] = _mm_insert_ps(*ans, _mm_dp_ps(transpose->f32_x[2], vector[0], 0B11110001),
                                SSE_INSERT_SIMPLE(1, 3));
-        ans[0] = _mm_insert_ps(*ans, _mm_dp_ps(transpose->xmm[3], vector[0], 0B11110001),
+        ans[0] = _mm_insert_ps(*ans, _mm_dp_ps(transpose->f32_x[3], vector[0], 0B11110001),
                                SSE_INSERT_SIMPLE(1, 4));
 
-        ans[1] = _mm_dp_ps(transpose->xmm[0], vector[1], 0B11110001);
-        ans[1] = _mm_insert_ps(*ans, _mm_dp_ps(transpose->xmm[1], vector[1], 0B11110001),
+        ans[1] = _mm_dp_ps(transpose->f32_x[0], vector[1], 0B11110001);
+        ans[1] = _mm_insert_ps(*ans, _mm_dp_ps(transpose->f32_x[1], vector[1], 0B11110001),
                                SSE_INSERT_SIMPLE(1, 2));
-        ans[1] = _mm_insert_ps(*ans, _mm_dp_ps(transpose->xmm[2], vector[1], 0B11110001),
+        ans[1] = _mm_insert_ps(*ans, _mm_dp_ps(transpose->f32_x[2], vector[1], 0B11110001),
                                SSE_INSERT_SIMPLE(1, 3));
-        ans[1] = _mm_insert_ps(*ans, _mm_dp_ps(transpose->xmm[3], vector[1], 0B11110001),
+        ans[1] = _mm_insert_ps(*ans, _mm_dp_ps(transpose->f32_x[3], vector[1], 0B11110001),
                                SSE_INSERT_SIMPLE(1, 4));
 }
 
 INTERNAL void SN_DECL dot_42_avx(MAT_KERNEL(float) const *transpose, __m128 const *vector,
                                  __m128 *ans)
 {
-        __m256 temp = transpose->ymm[0];
+        __m256 temp = transpose->f32_y[0];
         __m256 vector_stream = _mm256_set_m128(vector[1], vector[0]);
 
         __m256 result = _mm256_dp_ps(temp, vector_stream, 0B11110001);
         temp = _mm256_permute2f128_ps(temp, temp, 0B00000001);
         result = _mm256_blend_ps(result, _mm256_dp_ps(temp, vector_stream, 0B11110010), 0B00100010);
 
-        temp = transpose->ymm[1];
+        temp = transpose->f32_y[1];
         result = _mm256_blend_ps(result, _mm256_dp_ps(temp, vector_stream, 0B11110100), 0B01000100);
         temp = _mm256_permute2f128_ps(temp, temp, 0B00000001);
         result = _mm256_blend_ps(result, _mm256_dp_ps(temp, vector_stream, 0B11111000), 0B10001000);

StgSharp.Tools/c.txt

@@ -0,0 +1,658 @@
+        PFNGLACTIVESHADERPROGRAMPROC ActiveShaderProgram;
+        PFNGLACTIVETEXTUREPROC ActiveTexture;
+        PFNGLATTACHSHADERPROC AttachShader;
+        PFNGLBEGINCONDITIONALRENDERPROC BeginConditionalRender;
+        PFNGLBEGINQUERYPROC BeginQuery;
+        PFNGLBEGINQUERYINDEXEDPROC BeginQueryIndexed;
+        PFNGLBEGINTRANSFORMFEEDBACKPROC BeginTransformFeedback;
+        PFNGLBINDATTRIBLOCATIONPROC BindAttribLocation;
+        PFNGLBINDBUFFERPROC BindBuffer;
+        PFNGLBINDBUFFERBASEPROC BindBufferBase;
+        PFNGLBINDBUFFERRANGEPROC BindBufferRange;
+        PFNGLBINDBUFFERSBASEPROC BindBuffersBase;
+        PFNGLBINDBUFFERSRANGEPROC BindBuffersRange;
+        PFNGLBINDFRAGDATALOCATIONPROC BindFragDataLocation;
+        PFNGLBINDFRAGDATALOCATIONINDEXEDPROC BindFragDataLocationIndexed;
+        PFNGLBINDFRAMEBUFFERPROC BindFramebuffer;
+        PFNGLBINDIMAGETEXTUREPROC BindImageTexture;
+        PFNGLBINDIMAGETEXTURESPROC BindImageTextures;
+        PFNGLBINDPROGRAMPIPELINEPROC BindProgramPipeline;
+        PFNGLBINDRENDERBUFFERPROC BindRenderbuffer;
+        PFNGLBINDSAMPLERPROC BindSampler;
+        PFNGLBINDSAMPLERSPROC BindSamplers;
+        PFNGLBINDTEXTUREPROC BindTexture;
+        PFNGLBINDTEXTUREUNITPROC BindTextureUnit;
+        PFNGLBINDTEXTURESPROC BindTextures;
+        PFNGLBINDTRANSFORMFEEDBACKPROC BindTransformFeedback;
+        PFNGLBINDVERTEXARRAYPROC BindVertexArray;
+        PFNGLBINDVERTEXBUFFERPROC BindVertexBuffer;
+        PFNGLBINDVERTEXBUFFERSPROC BindVertexBuffers;
+        PFNGLBLENDCOLORPROC BlendColor;
+        PFNGLBLENDEQUATIONPROC BlendEquation;
+        PFNGLBLENDEQUATIONSEPARATEPROC BlendEquationSeparate;
+        PFNGLBLENDEQUATIONSEPARATEIPROC BlendEquationSeparatei;
+        PFNGLBLENDEQUATIONIPROC BlendEquationi;
+        PFNGLBLENDFUNCPROC BlendFunc;
+        PFNGLBLENDFUNCSEPARATEPROC BlendFuncSeparate;
+        PFNGLBLENDFUNCSEPARATEIPROC BlendFuncSeparatei;
+        PFNGLBLENDFUNCIPROC BlendFunci;
+        PFNGLBLITFRAMEBUFFERPROC BlitFramebuffer;
+        PFNGLBLITNAMEDFRAMEBUFFERPROC BlitNamedFramebuffer;
+        PFNGLBUFFERDATAPROC BufferData;
+        PFNGLBUFFERSTORAGEPROC BufferStorage;
+        PFNGLBUFFERSUBDATAPROC BufferSubData;
+        PFNGLCHECKFRAMEBUFFERSTATUSPROC CheckFramebufferStatus;
+        PFNGLCHECKNAMEDFRAMEBUFFERSTATUSPROC CheckNamedFramebufferStatus;
+        PFNGLCLAMPCOLORPROC ClampColor;
+        PFNGLCLEARPROC Clear;
+        PFNGLCLEARBUFFERDATAPROC ClearBufferData;
+        PFNGLCLEARBUFFERSUBDATAPROC ClearBufferSubData;
+        PFNGLCLEARBUFFERFIPROC ClearBufferfi;
+        PFNGLCLEARBUFFERFVPROC ClearBufferfv;
+        PFNGLCLEARBUFFERIVPROC ClearBufferiv;
+        PFNGLCLEARBUFFERUIVPROC ClearBufferuiv;
+        PFNGLCLEARCOLORPROC ClearColor;
+        PFNGLCLEARDEPTHPROC ClearDepth;
+        PFNGLCLEARDEPTHFPROC ClearDepthf;
+        PFNGLCLEARNAMEDBUFFERDATAPROC ClearNamedBufferData;
+        PFNGLCLEARNAMEDBUFFERSUBDATAPROC ClearNamedBufferSubData;
+        PFNGLCLEARNAMEDFRAMEBUFFERFIPROC ClearNamedFramebufferfi;
+        PFNGLCLEARNAMEDFRAMEBUFFERFVPROC ClearNamedFramebufferfv;
+        PFNGLCLEARNAMEDFRAMEBUFFERIVPROC ClearNamedFramebufferiv;
+        PFNGLCLEARNAMEDFRAMEBUFFERUIVPROC ClearNamedFramebufferuiv;
+        PFNGLCLEARSTENCILPROC ClearStencil;
+        PFNGLCLEARTEXIMAGEPROC ClearTexImage;
+        PFNGLCLEARTEXSUBIMAGEPROC ClearTexSubImage;
+        PFNGLCLIENTWAITSYNCPROC ClientWaitSync;
+        PFNGLCLIPCONTROLPROC ClipControl;
+        PFNGLCOLORMASKPROC ColorMask;
+        PFNGLCOLORMASKIPROC ColorMaski;
+        PFNGLCOMPILESHADERPROC CompileShader;
+        PFNGLCOMPRESSEDTEXIMAGE1DPROC CompressedTexImage1D;
+        PFNGLCOMPRESSEDTEXIMAGE2DPROC CompressedTexImage2D;
+        PFNGLCOMPRESSEDTEXIMAGE3DPROC CompressedTexImage3D;
+        PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC CompressedTexSubImage1D;
+        PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC CompressedTexSubImage2D;
+        PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC CompressedTexSubImage3D;
+        PFNGLCOMPRESSEDTEXTURESUBIMAGE1DPROC CompressedTextureSubImage1D;
+        PFNGLCOMPRESSEDTEXTURESUBIMAGE2DPROC CompressedTextureSubImage2D;
+        PFNGLCOMPRESSEDTEXTURESUBIMAGE3DPROC CompressedTextureSubImage3D;
+        PFNGLCOPYBUFFERSUBDATAPROC CopyBufferSubData;
+        PFNGLCOPYIMAGESUBDATAPROC CopyImageSubData;
+        PFNGLCOPYNAMEDBUFFERSUBDATAPROC CopyNamedBufferSubData;
+        PFNGLCOPYTEXIMAGE1DPROC CopyTexImage1D;
+        PFNGLCOPYTEXIMAGE2DPROC CopyTexImage2D;
+        PFNGLCOPYTEXSUBIMAGE1DPROC CopyTexSubImage1D;
+        PFNGLCOPYTEXSUBIMAGE2DPROC CopyTexSubImage2D;
+        PFNGLCOPYTEXSUBIMAGE3DPROC CopyTexSubImage3D;
+        PFNGLCOPYTEXTURESUBIMAGE1DPROC CopyTextureSubImage1D;
+        PFNGLCOPYTEXTURESUBIMAGE2DPROC CopyTextureSubImage2D;
+        PFNGLCOPYTEXTURESUBIMAGE3DPROC CopyTextureSubImage3D;
+        PFNGLCREATEBUFFERSPROC CreateBuffers;
+        PFNGLCREATEFRAMEBUFFERSPROC CreateFramebuffers;
+        PFNGLCREATEPROGRAMPROC CreateProgram;
+        PFNGLCREATEPROGRAMPIPELINESPROC CreateProgramPipelines;
+        PFNGLCREATEQUERIESPROC CreateQueries;
+        PFNGLCREATERENDERBUFFERSPROC CreateRenderbuffers;
+        PFNGLCREATESAMPLERSPROC CreateSamplers;
+        PFNGLCREATESHADERPROC CreateShader;
+        PFNGLCREATESHADERPROGRAMVPROC CreateShaderProgramv;
+        PFNGLCREATETEXTURESPROC CreateTextures;
+        PFNGLCREATETRANSFORMFEEDBACKSPROC CreateTransformFeedbacks;
+        PFNGLCREATEVERTEXARRAYSPROC CreateVertexArrays;
+        PFNGLCULLFACEPROC CullFace;
+        PFNGLDEBUGMESSAGECALLBACKPROC DebugMessageCallback;
+        PFNGLDEBUGMESSAGECONTROLPROC DebugMessageControl;
+        PFNGLDEBUGMESSAGEINSERTPROC DebugMessageInsert;
+        PFNGLDELETEBUFFERSPROC DeleteBuffers;
+        PFNGLDELETEFRAMEBUFFERSPROC DeleteFramebuffers;
+        PFNGLDELETEPROGRAMPROC DeleteProgram;
+        PFNGLDELETEPROGRAMPIPELINESPROC DeleteProgramPipelines;
+        PFNGLDELETEQUERIESPROC DeleteQueries;
+        PFNGLDELETERENDERBUFFERSPROC DeleteRenderbuffers;
+        PFNGLDELETESAMPLERSPROC DeleteSamplers;
+        PFNGLDELETESHADERPROC DeleteShader;
+        PFNGLDELETESYNCPROC DeleteSync;
+        PFNGLDELETETEXTURESPROC DeleteTextures;
+        PFNGLDELETETRANSFORMFEEDBACKSPROC DeleteTransformFeedbacks;
+        PFNGLDELETEVERTEXARRAYSPROC DeleteVertexArrays;
+        PFNGLDEPTHFUNCPROC DepthFunc;
+        PFNGLDEPTHMASKPROC DepthMask;
+        PFNGLDEPTHRANGEPROC DepthRange;
+        PFNGLDEPTHRANGEARRAYVPROC DepthRangeArrayv;
+        PFNGLDEPTHRANGEINDEXEDPROC DepthRangeIndexed;
+        PFNGLDEPTHRANGEFPROC DepthRangef;
+        PFNGLDETACHSHADERPROC DetachShader;
+        PFNGLDISABLEPROC Disable;
+        PFNGLDISABLEVERTEXARRAYATTRIBPROC DisableVertexArrayAttrib;
+        PFNGLDISABLEVERTEXATTRIBARRAYPROC DisableVertexAttribArray;
+        PFNGLDISABLEIPROC Disablei;
+        PFNGLDISPATCHCOMPUTEPROC DispatchCompute;
+        PFNGLDISPATCHCOMPUTEINDIRECTPROC DispatchComputeIndirect;
+        PFNGLDRAWARRAYSPROC DrawArrays;
+        PFNGLDRAWARRAYSINDIRECTPROC DrawArraysIndirect;
+        PFNGLDRAWARRAYSINSTANCEDPROC DrawArraysInstanced;
+        PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC DrawArraysInstancedBaseInstance;
+        PFNGLDRAWBUFFERPROC DrawBuffer;
+        PFNGLDRAWBUFFERSPROC DrawBuffers;
+        PFNGLDRAWELEMENTSPROC DrawElements;
+        PFNGLDRAWELEMENTSBASEVERTEXPROC DrawElementsBaseVertex;
+        PFNGLDRAWELEMENTSINDIRECTPROC DrawElementsIndirect;
+        PFNGLDRAWELEMENTSINSTANCEDPROC DrawElementsInstanced;
+        PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC DrawElementsInstancedBaseInstance;
+        PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC DrawElementsInstancedBaseVertex;
+        PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC
+        DrawElementsInstancedBaseVertexBaseInstance;
+        PFNGLDRAWRANGEELEMENTSPROC DrawRangeElements;
+        PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC DrawRangeElementsBaseVertex;
+        PFNGLDRAWTRANSFORMFEEDBACKPROC DrawTransformFeedback;
+        PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC DrawTransformFeedbackInstanced;
+        PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC DrawTransformFeedbackStream;
+        PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC DrawTransformFeedbackStreamInstanced;
+        PFNGLENABLEPROC Enable;
+        PFNGLENABLEVERTEXARRAYATTRIBPROC EnableVertexArrayAttrib;
+        PFNGLENABLEVERTEXATTRIBARRAYPROC EnableVertexAttribArray;
+        PFNGLENABLEIPROC Enablei;
+        PFNGLENDCONDITIONALRENDERPROC EndConditionalRender;
+        PFNGLENDQUERYPROC EndQuery;
+        PFNGLENDQUERYINDEXEDPROC EndQueryIndexed;
+        PFNGLENDTRANSFORMFEEDBACKPROC EndTransformFeedback;
+        PFNGLFENCESYNCPROC FenceSync;
+        PFNGLFINISHPROC Finish;
+        PFNGLFLUSHPROC Flush;
+        PFNGLFLUSHMAPPEDBUFFERRANGEPROC FlushMappedBufferRange;
+        PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEPROC FlushMappedNamedBufferRange;
+        PFNGLFRAMEBUFFERPARAMETERIPROC FramebufferParameteri;
+        PFNGLFRAMEBUFFERRENDERBUFFERPROC FramebufferRenderbuffer;
+        PFNGLFRAMEBUFFERTEXTUREPROC FramebufferTexture;
+        PFNGLFRAMEBUFFERTEXTURE1DPROC FramebufferTexture1D;
+        PFNGLFRAMEBUFFERTEXTURE2DPROC FramebufferTexture2D;
+        PFNGLFRAMEBUFFERTEXTURE3DPROC FramebufferTexture3D;
+        PFNGLFRAMEBUFFERTEXTURELAYERPROC FramebufferTextureLayer;
+        PFNGLFRONTFACEPROC FrontFace;
+        PFNGLGENBUFFERSPROC GenBuffers;
+        PFNGLGENFRAMEBUFFERSPROC GenFramebuffers;
+        PFNGLGENPROGRAMPIPELINESPROC GenProgramPipelines;
+        PFNGLGENQUERIESPROC GenQueries;
+        PFNGLGENRENDERBUFFERSPROC GenRenderbuffers;
+        PFNGLGENSAMPLERSPROC GenSamplers;
+        PFNGLGENTEXTURESPROC GenTextures;
+        PFNGLGENTRANSFORMFEEDBACKSPROC GenTransformFeedbacks;
+        PFNGLGENVERTEXARRAYSPROC GenVertexArrays;
+        PFNGLGENERATEMIPMAPPROC GenerateMipmap;
+        PFNGLGENERATETEXTUREMIPMAPPROC GenerateTextureMipmap;
+        PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC GetActiveAtomicCounterBufferiv;
+        PFNGLGETACTIVEATTRIBPROC GetActiveAttrib;
+        PFNGLGETACTIVESUBROUTINENAMEPROC GetActiveSubroutineName;
+        PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC GetActiveSubroutineUniformName;
+        PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC GetActiveSubroutineUniformiv;
+        PFNGLGETACTIVEUNIFORMPROC GetActiveUniform;
+        PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC GetActiveUniformBlockName;
+        PFNGLGETACTIVEUNIFORMBLOCKIVPROC GetActiveUniformBlockiv;
+        PFNGLGETACTIVEUNIFORMNAMEPROC GetActiveUniformName;
+        PFNGLGETACTIVEUNIFORMSIVPROC GetActiveUniformsiv;
+        PFNGLGETATTACHEDSHADERSPROC GetAttachedShaders;
+        PFNGLGETATTRIBLOCATIONPROC GetAttribLocation;
+        PFNGLGETBOOLEANI_VPROC GetBooleani_v;
+        PFNGLGETBOOLEANVPROC GetBooleanv;
+        PFNGLGETBUFFERPARAMETERI64VPROC GetBufferParameteri64v;
+        PFNGLGETBUFFERPARAMETERIVPROC GetBufferParameteriv;
+        PFNGLGETBUFFERPOINTERVPROC GetBufferPointerv;
+        PFNGLGETBUFFERSUBDATAPROC GetBufferSubData;
+        PFNGLGETCOMPRESSEDTEXIMAGEPROC GetCompressedTexImage;
+        PFNGLGETCOMPRESSEDTEXTUREIMAGEPROC GetCompressedTextureImage;
+        PFNGLGETCOMPRESSEDTEXTURESUBIMAGEPROC GetCompressedTextureSubImage;
+        PFNGLGETDEBUGMESSAGELOGPROC GetDebugMessageLog;
+        PFNGLGETDOUBLEI_VPROC GetDoublei_v;
+        PFNGLGETDOUBLEVPROC GetDoublev;
+        PFNGLGETERRORPROC GetError;
+        PFNGLGETFLOATI_VPROC GetFloati_v;
+        PFNGLGETFLOATVPROC GetFloatv;
+        PFNGLGETFRAGDATAINDEXPROC GetFragDataIndex;
+        PFNGLGETFRAGDATALOCATIONPROC GetFragDataLocation;
+        PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC GetFramebufferAttachmentParameteriv;
+        PFNGLGETFRAMEBUFFERPARAMETERIVPROC GetFramebufferParameteriv;
+        PFNGLGETGRAPHICSRESETSTATUSPROC GetGraphicsResetStatus;
+        PFNGLGETINTEGER64I_VPROC GetInteger64i_v;
+        PFNGLGETINTEGER64VPROC GetInteger64v;
+        PFNGLGETINTEGERI_VPROC GetIntegeri_v;
+        PFNGLGETINTEGERVPROC GetIntegerv;
+        PFNGLGETINTERNALFORMATI64VPROC GetInternalformati64v;
+        PFNGLGETINTERNALFORMATIVPROC GetInternalformativ;
+        PFNGLGETMULTISAMPLEFVPROC GetMultisamplefv;
+        PFNGLGETNAMEDBUFFERPARAMETERI64VPROC GetNamedBufferParameteri64v;
+        PFNGLGETNAMEDBUFFERPARAMETERIVPROC GetNamedBufferParameteriv;
+        PFNGLGETNAMEDBUFFERPOINTERVPROC GetNamedBufferPointerv;
+        PFNGLGETNAMEDBUFFERSUBDATAPROC GetNamedBufferSubData;
+        PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVPROC GetNamedFramebufferAttachmentParameteriv;
+        PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVPROC GetNamedFramebufferParameteriv;
+        PFNGLGETNAMEDRENDERBUFFERPARAMETERIVPROC GetNamedRenderbufferParameteriv;
+        PFNGLGETOBJECTLABELPROC GetObjectLabel;
+        PFNGLGETOBJECTPTRLABELPROC GetObjectPtrLabel;
+        PFNGLGETPOINTERVPROC GetPointerv;
+        PFNGLGETPROGRAMBINARYPROC GetProgramBinary;
+        PFNGLGETPROGRAMINFOLOGPROC GetProgramInfoLog;
+        PFNGLGETPROGRAMINTERFACEIVPROC GetProgramInterfaceiv;
+        PFNGLGETPROGRAMPIPELINEINFOLOGPROC GetProgramPipelineInfoLog;
+        PFNGLGETPROGRAMPIPELINEIVPROC GetProgramPipelineiv;
+        PFNGLGETPROGRAMRESOURCEINDEXPROC GetProgramResourceIndex;
+        PFNGLGETPROGRAMRESOURCELOCATIONPROC GetProgramResourceLocation;
+        PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC GetProgramResourceLocationIndex;
+        PFNGLGETPROGRAMRESOURCENAMEPROC GetProgramResourceName;
+        PFNGLGETPROGRAMRESOURCEIVPROC GetProgramResourceiv;
+        PFNGLGETPROGRAMSTAGEIVPROC GetProgramStageiv;
+        PFNGLGETPROGRAMIVPROC GetProgramiv;
+        PFNGLGETQUERYBUFFEROBJECTI64VPROC GetQueryBufferObjecti64v;
+        PFNGLGETQUERYBUFFEROBJECTIVPROC GetQueryBufferObjectiv;
+        PFNGLGETQUERYBUFFEROBJECTUI64VPROC GetQueryBufferObjectui64v;
+        PFNGLGETQUERYBUFFEROBJECTUIVPROC GetQueryBufferObjectuiv;
+        PFNGLGETQUERYINDEXEDIVPROC GetQueryIndexediv;
+        PFNGLGETQUERYOBJECTI64VPROC GetQueryObjecti64v;
+        PFNGLGETQUERYOBJECTIVPROC GetQueryObjectiv;
+        PFNGLGETQUERYOBJECTUI64VPROC GetQueryObjectui64v;
+        PFNGLGETQUERYOBJECTUIVPROC GetQueryObjectuiv;
+        PFNGLGETQUERYIVPROC GetQueryiv;
+        PFNGLGETRENDERBUFFERPARAMETERIVPROC GetRenderbufferParameteriv;
+        PFNGLGETSAMPLERPARAMETERIIVPROC GetSamplerParameterIiv;
+        PFNGLGETSAMPLERPARAMETERIUIVPROC GetSamplerParameterIuiv;
+        PFNGLGETSAMPLERPARAMETERFVPROC GetSamplerParameterfv;
+        PFNGLGETSAMPLERPARAMETERIVPROC GetSamplerParameteriv;
+        PFNGLGETSHADERINFOLOGPROC GetShaderInfoLog;
+        PFNGLGETSHADERPRECISIONFORMATPROC GetShaderPrecisionFormat;
+        PFNGLGETSHADERSOURCEPROC GetShaderSource;
+        PFNGLGETSHADERIVPROC GetShaderiv;
+        PFNGLGETSTRINGPROC GetString;
+        PFNGLGETSTRINGIPROC GetStringi;
+        PFNGLGETSUBROUTINEINDEXPROC GetSubroutineIndex;
+        PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC GetSubroutineUniformLocation;
+        PFNGLGETSYNCIVPROC GetSynciv;
+        PFNGLGETTEXIMAGEPROC GetTexImage;
+        PFNGLGETTEXLEVELPARAMETERFVPROC GetTexLevelParameterfv;
+        PFNGLGETTEXLEVELPARAMETERIVPROC GetTexLevelParameteriv;
+        PFNGLGETTEXPARAMETERIIVPROC GetTexParameterIiv;
+        PFNGLGETTEXPARAMETERIUIVPROC GetTexParameterIuiv;
+        PFNGLGETTEXPARAMETERFVPROC GetTexParameterfv;
+        PFNGLGETTEXPARAMETERIVPROC GetTexParameteriv;
+        PFNGLGETTEXTUREIMAGEPROC GetTextureImage;
+        PFNGLGETTEXTURELEVELPARAMETERFVPROC GetTextureLevelParameterfv;
+        PFNGLGETTEXTURELEVELPARAMETERIVPROC GetTextureLevelParameteriv;
+        PFNGLGETTEXTUREPARAMETERIIVPROC GetTextureParameterIiv;
+        PFNGLGETTEXTUREPARAMETERIUIVPROC GetTextureParameterIuiv;
+        PFNGLGETTEXTUREPARAMETERFVPROC GetTextureParameterfv;
+        PFNGLGETTEXTUREPARAMETERIVPROC GetTextureParameteriv;
+        PFNGLGETTEXTURESUBIMAGEPROC GetTextureSubImage;
+        PFNGLGETTRANSFORMFEEDBACKVARYINGPROC GetTransformFeedbackVarying;
+        PFNGLGETTRANSFORMFEEDBACKI64_VPROC GetTransformFeedbacki64_v;
+        PFNGLGETTRANSFORMFEEDBACKI_VPROC GetTransformFeedbacki_v;
+        PFNGLGETTRANSFORMFEEDBACKIVPROC GetTransformFeedbackiv;
+        PFNGLGETUNIFORMBLOCKINDEXPROC GetUniformBlockIndex;
+        PFNGLGETUNIFORMINDICESPROC GetUniformIndices;
+        PFNGLGETUNIFORMLOCATIONPROC GetUniformLocation;
+        PFNGLGETUNIFORMSUBROUTINEUIVPROC GetUniformSubroutineuiv;
+        PFNGLGETUNIFORMDVPROC GetUniformdv;
+        PFNGLGETUNIFORMFVPROC GetUniformfv;
+        PFNGLGETUNIFORMIVPROC GetUniformiv;
+        PFNGLGETUNIFORMUIVPROC GetUniformuiv;
+        PFNGLGETVERTEXARRAYINDEXED64IVPROC GetVertexArrayIndexed64iv;
+        PFNGLGETVERTEXARRAYINDEXEDIVPROC GetVertexArrayIndexediv;
+        PFNGLGETVERTEXARRAYIVPROC GetVertexArrayiv;
+        PFNGLGETVERTEXATTRIBIIVPROC GetVertexAttribIiv;
+        PFNGLGETVERTEXATTRIBIUIVPROC GetVertexAttribIuiv;
+        PFNGLGETVERTEXATTRIBLDVPROC GetVertexAttribLdv;
+        PFNGLGETVERTEXATTRIBPOINTERVPROC GetVertexAttribPointerv;
+        PFNGLGETVERTEXATTRIBDVPROC GetVertexAttribdv;
+        PFNGLGETVERTEXATTRIBFVPROC GetVertexAttribfv;
+        PFNGLGETVERTEXATTRIBIVPROC GetVertexAttribiv;
+        PFNGLGETNCOMPRESSEDTEXIMAGEPROC GetnCompressedTexImage;
+        PFNGLGETNTEXIMAGEPROC GetnTexImage;
+        PFNGLGETNUNIFORMDVPROC GetnUniformdv;
+        PFNGLGETNUNIFORMFVPROC GetnUniformfv;
+        PFNGLGETNUNIFORMIVPROC GetnUniformiv;
+        PFNGLGETNUNIFORMUIVPROC GetnUniformuiv;
+        PFNGLHINTPROC Hint;
+        PFNGLINVALIDATEBUFFERDATAPROC InvalidateBufferData;
+        PFNGLINVALIDATEBUFFERSUBDATAPROC InvalidateBufferSubData;
+        PFNGLINVALIDATEFRAMEBUFFERPROC InvalidateFramebuffer;
+        PFNGLINVALIDATENAMEDFRAMEBUFFERDATAPROC InvalidateNamedFramebufferData;
+        PFNGLINVALIDATENAMEDFRAMEBUFFERSUBDATAPROC InvalidateNamedFramebufferSubData;
+        PFNGLINVALIDATESUBFRAMEBUFFERPROC InvalidateSubFramebuffer;
+        PFNGLINVALIDATETEXIMAGEPROC InvalidateTexImage;
+        PFNGLINVALIDATETEXSUBIMAGEPROC InvalidateTexSubImage;
+        PFNGLISBUFFERPROC IsBuffer;
+        PFNGLISENABLEDPROC IsEnabled;
+        PFNGLISENABLEDIPROC IsEnabledi;
+        PFNGLISFRAMEBUFFERPROC IsFramebuffer;
+        PFNGLISPROGRAMPROC IsProgram;
+        PFNGLISPROGRAMPIPELINEPROC IsProgramPipeline;
+        PFNGLISQUERYPROC IsQuery;
+        PFNGLISRENDERBUFFERPROC IsRenderbuffer;
+        PFNGLISSAMPLERPROC IsSampler;
+        PFNGLISSHADERPROC IsShader;
+        PFNGLISSYNCPROC IsSync;
+        PFNGLISTEXTUREPROC IsTexture;
+        PFNGLISTRANSFORMFEEDBACKPROC IsTransformFeedback;
+        PFNGLISVERTEXARRAYPROC IsVertexArray;
+        PFNGLLINEWIDTHPROC LineWidth;
+        PFNGLLINKPROGRAMPROC LinkProgram;
+        PFNGLLOGICOPPROC LogicOp;
+        PFNGLMAPBUFFERPROC MapBuffer;
+        PFNGLMAPBUFFERRANGEPROC MapBufferRange;
+        PFNGLMAPNAMEDBUFFERPROC MapNamedBuffer;
+        PFNGLMAPNAMEDBUFFERRANGEPROC MapNamedBufferRange;
+        PFNGLMEMORYBARRIERPROC MemoryBarrier;
+        PFNGLMEMORYBARRIERBYREGIONPROC MemoryBarrierByRegion;
+        PFNGLMINSAMPLESHADINGPROC MinSampleShading;
+        PFNGLMULTIDRAWARRAYSPROC MultiDrawArrays;
+        PFNGLMULTIDRAWARRAYSINDIRECTPROC MultiDrawArraysIndirect;
+        PFNGLMULTIDRAWARRAYSINDIRECTCOUNTPROC MultiDrawArraysIndirectCount;
+        PFNGLMULTIDRAWELEMENTSPROC MultiDrawElements;
+        PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC MultiDrawElementsBaseVertex;
+        PFNGLMULTIDRAWELEMENTSINDIRECTPROC MultiDrawElementsIndirect;
+        PFNGLMULTIDRAWELEMENTSINDIRECTCOUNTPROC MultiDrawElementsIndirectCount;
+        PFNGLNAMEDBUFFERDATAPROC NamedBufferData;
+        PFNGLNAMEDBUFFERSTORAGEPROC NamedBufferStorage;
+        PFNGLNAMEDBUFFERSUBDATAPROC NamedBufferSubData;
+        PFNGLNAMEDFRAMEBUFFERDRAWBUFFERPROC NamedFramebufferDrawBuffer;
+        PFNGLNAMEDFRAMEBUFFERDRAWBUFFERSPROC NamedFramebufferDrawBuffers;
+        PFNGLNAMEDFRAMEBUFFERPARAMETERIPROC NamedFramebufferParameteri;
+        PFNGLNAMEDFRAMEBUFFERREADBUFFERPROC NamedFramebufferReadBuffer;
+        PFNGLNAMEDFRAMEBUFFERRENDERBUFFERPROC NamedFramebufferRenderbuffer;
+        PFNGLNAMEDFRAMEBUFFERTEXTUREPROC NamedFramebufferTexture;
+        PFNGLNAMEDFRAMEBUFFERTEXTURELAYERPROC NamedFramebufferTextureLayer;
+        PFNGLNAMEDRENDERBUFFERSTORAGEPROC NamedRenderbufferStorage;
+        PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEPROC NamedRenderbufferStorageMultisample;
+        PFNGLOBJECTLABELPROC ObjectLabel;
+        PFNGLOBJECTPTRLABELPROC ObjectPtrLabel;
+        PFNGLPATCHPARAMETERFVPROC PatchParameterfv;
+        PFNGLPATCHPARAMETERIPROC PatchParameteri;
+        PFNGLPAUSETRANSFORMFEEDBACKPROC PauseTransformFeedback;
+        PFNGLPIXELSTOREFPROC PixelStoref;
+        PFNGLPIXELSTOREIPROC PixelStorei;
+        PFNGLPOINTPARAMETERFPROC PointParameterf;
+        PFNGLPOINTPARAMETERFVPROC PointParameterfv;
+        PFNGLPOINTPARAMETERIPROC PointParameteri;
+        PFNGLPOINTPARAMETERIVPROC PointParameteriv;
+        PFNGLPOINTSIZEPROC PointSize;
+        PFNGLPOLYGONMODEPROC PolygonMode;
+        PFNGLPOLYGONOFFSETPROC PolygonOffset;
+        PFNGLPOLYGONOFFSETCLAMPPROC PolygonOffsetClamp;
+        PFNGLPOPDEBUGGROUPPROC PopDebugGroup;
+        PFNGLPRIMITIVERESTARTINDEXPROC PrimitiveRestartIndex;
+        PFNGLPROGRAMBINARYPROC ProgramBinary;
+        PFNGLPROGRAMPARAMETERIPROC ProgramParameteri;
+        PFNGLPROGRAMUNIFORM1DPROC ProgramUniform1d;
+        PFNGLPROGRAMUNIFORM1DVPROC ProgramUniform1dv;
+        PFNGLPROGRAMUNIFORM1FPROC ProgramUniform1f;
+        PFNGLPROGRAMUNIFORM1FVPROC ProgramUniform1fv;
+        PFNGLPROGRAMUNIFORM1IPROC ProgramUniform1i;
+        PFNGLPROGRAMUNIFORM1IVPROC ProgramUniform1iv;
+        PFNGLPROGRAMUNIFORM1UIPROC ProgramUniform1ui;
+        PFNGLPROGRAMUNIFORM1UIVPROC ProgramUniform1uiv;
+        PFNGLPROGRAMUNIFORM2DPROC ProgramUniform2d;
+        PFNGLPROGRAMUNIFORM2DVPROC ProgramUniform2dv;
+        PFNGLPROGRAMUNIFORM2FPROC ProgramUniform2f;
+        PFNGLPROGRAMUNIFORM2FVPROC ProgramUniform2fv;
+        PFNGLPROGRAMUNIFORM2IPROC ProgramUniform2i;
+        PFNGLPROGRAMUNIFORM2IVPROC ProgramUniform2iv;
+        PFNGLPROGRAMUNIFORM2UIPROC ProgramUniform2ui;
+        PFNGLPROGRAMUNIFORM2UIVPROC ProgramUniform2uiv;
+        PFNGLPROGRAMUNIFORM3DPROC ProgramUniform3d;
+        PFNGLPROGRAMUNIFORM3DVPROC ProgramUniform3dv;
+        PFNGLPROGRAMUNIFORM3FPROC ProgramUniform3f;
+        PFNGLPROGRAMUNIFORM3FVPROC ProgramUniform3fv;
+        PFNGLPROGRAMUNIFORM3IPROC ProgramUniform3i;
+        PFNGLPROGRAMUNIFORM3IVPROC ProgramUniform3iv;
+        PFNGLPROGRAMUNIFORM3UIPROC ProgramUniform3ui;
+        PFNGLPROGRAMUNIFORM3UIVPROC ProgramUniform3uiv;
+        PFNGLPROGRAMUNIFORM4DPROC ProgramUniform4d;
+        PFNGLPROGRAMUNIFORM4DVPROC ProgramUniform4dv;
+        PFNGLPROGRAMUNIFORM4FPROC ProgramUniform4f;
+        PFNGLPROGRAMUNIFORM4FVPROC ProgramUniform4fv;
+        PFNGLPROGRAMUNIFORM4IPROC ProgramUniform4i;
+        PFNGLPROGRAMUNIFORM4IVPROC ProgramUniform4iv;
+        PFNGLPROGRAMUNIFORM4UIPROC ProgramUniform4ui;
+        PFNGLPROGRAMUNIFORM4UIVPROC ProgramUniform4uiv;
+        PFNGLPROGRAMUNIFORMMATRIX2DVPROC ProgramUniformMatrix2dv;
+        PFNGLPROGRAMUNIFORMMATRIX2FVPROC ProgramUniformMatrix2fv;
+        PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC ProgramUniformMatrix2x3dv;
+        PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC ProgramUniformMatrix2x3fv;
+        PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC ProgramUniformMatrix2x4dv;
+        PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC ProgramUniformMatrix2x4fv;
+        PFNGLPROGRAMUNIFORMMATRIX3DVPROC ProgramUniformMatrix3dv;
+        PFNGLPROGRAMUNIFORMMATRIX3FVPROC ProgramUniformMatrix3fv;
+        PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC ProgramUniformMatrix3x2dv;
+        PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC ProgramUniformMatrix3x2fv;
+        PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC ProgramUniformMatrix3x4dv;
+        PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC ProgramUniformMatrix3x4fv;
+        PFNGLPROGRAMUNIFORMMATRIX4DVPROC ProgramUniformMatrix4dv;
+        PFNGLPROGRAMUNIFORMMATRIX4FVPROC ProgramUniformMatrix4fv;
+        PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC ProgramUniformMatrix4x2dv;
+        PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC ProgramUniformMatrix4x2fv;
+        PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC ProgramUniformMatrix4x3dv;
+        PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC ProgramUniformMatrix4x3fv;
+        PFNGLPROVOKINGVERTEXPROC ProvokingVertex;
+        PFNGLPUSHDEBUGGROUPPROC PushDebugGroup;
+        PFNGLQUERYCOUNTERPROC QueryCounter;
+        PFNGLREADBUFFERPROC ReadBuffer;
+        PFNGLREADPIXELSPROC ReadPixels;
+        PFNGLREADNPIXELSPROC ReadnPixels;
+        PFNGLRELEASESHADERCOMPILERPROC ReleaseShaderCompiler;
+        PFNGLRENDERBUFFERSTORAGEPROC RenderbufferStorage;
+        PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC RenderbufferStorageMultisample;
+        PFNGLRESUMETRANSFORMFEEDBACKPROC ResumeTransformFeedback;
+        PFNGLSAMPLECOVERAGEPROC SampleCoverage;
+        PFNGLSAMPLEMASKIPROC SampleMaski;
+        PFNGLSAMPLERPARAMETERIIVPROC SamplerParameterIiv;
+        PFNGLSAMPLERPARAMETERIUIVPROC SamplerParameterIuiv;
+        PFNGLSAMPLERPARAMETERFPROC SamplerParameterf;
+        PFNGLSAMPLERPARAMETERFVPROC SamplerParameterfv;
+        PFNGLSAMPLERPARAMETERIPROC SamplerParameteri;
+        PFNGLSAMPLERPARAMETERIVPROC SamplerParameteriv;
+        PFNGLSCISSORPROC Scissor;
+        PFNGLSCISSORARRAYVPROC ScissorArrayv;
+        PFNGLSCISSORINDEXEDPROC ScissorIndexed;
+        PFNGLSCISSORINDEXEDVPROC ScissorIndexedv;
+        PFNGLSHADERBINARYPROC ShaderBinary;
+        PFNGLSHADERSOURCEPROC ShaderSource;
+        PFNGLSHADERSTORAGEBLOCKBINDINGPROC ShaderStorageBlockBinding;
+        PFNGLSPECIALIZESHADERPROC SpecializeShader;
+        PFNGLSTENCILFUNCPROC StencilFunc;
+        PFNGLSTENCILFUNCSEPARATEPROC StencilFuncSeparate;
+        PFNGLSTENCILMASKPROC StencilMask;
+        PFNGLSTENCILMASKSEPARATEPROC StencilMaskSeparate;
+        PFNGLSTENCILOPPROC StencilOp;
+        PFNGLSTENCILOPSEPARATEPROC StencilOpSeparate;
+        PFNGLTEXBUFFERPROC TexBuffer;
+        PFNGLTEXBUFFERRANGEPROC TexBufferRange;
+        PFNGLTEXIMAGE1DPROC TexImage1D;
+        PFNGLTEXIMAGE2DPROC TexImage2D;
+        PFNGLTEXIMAGE2DMULTISAMPLEPROC TexImage2DMultisample;
+        PFNGLTEXIMAGE3DPROC TexImage3D;
+        PFNGLTEXIMAGE3DMULTISAMPLEPROC TexImage3DMultisample;
+        PFNGLTEXPARAMETERIIVPROC TexParameterIiv;
+        PFNGLTEXPARAMETERIUIVPROC TexParameterIuiv;
+        PFNGLTEXPARAMETERFPROC TexParameterf;
+        PFNGLTEXPARAMETERFVPROC TexParameterfv;
+        PFNGLTEXPARAMETERIPROC TexParameteri;
+        PFNGLTEXPARAMETERIVPROC TexParameteriv;
+        PFNGLTEXSTORAGE1DPROC TexStorage1D;
+        PFNGLTEXSTORAGE2DPROC TexStorage2D;
+        PFNGLTEXSTORAGE2DMULTISAMPLEPROC TexStorage2DMultisample;
+        PFNGLTEXSTORAGE3DPROC TexStorage3D;
+        PFNGLTEXSTORAGE3DMULTISAMPLEPROC TexStorage3DMultisample;
+        PFNGLTEXSUBIMAGE1DPROC TexSubImage1D;
+        PFNGLTEXSUBIMAGE2DPROC TexSubImage2D;
+        PFNGLTEXSUBIMAGE3DPROC TexSubImage3D;
+        PFNGLTEXTUREBARRIERPROC TextureBarrier;
+        PFNGLTEXTUREBUFFERPROC TextureBuffer;
+        PFNGLTEXTUREBUFFERRANGEPROC TextureBufferRange;
+        PFNGLTEXTUREPARAMETERIIVPROC TextureParameterIiv;
+        PFNGLTEXTUREPARAMETERIUIVPROC TextureParameterIuiv;
+        PFNGLTEXTUREPARAMETERFPROC TextureParameterf;
+        PFNGLTEXTUREPARAMETERFVPROC TextureParameterfv;
+        PFNGLTEXTUREPARAMETERIPROC TextureParameteri;
+        PFNGLTEXTUREPARAMETERIVPROC TextureParameteriv;
+        PFNGLTEXTURESTORAGE1DPROC TextureStorage1D;
+        PFNGLTEXTURESTORAGE2DPROC TextureStorage2D;
+        PFNGLTEXTURESTORAGE2DMULTISAMPLEPROC TextureStorage2DMultisample;
+        PFNGLTEXTURESTORAGE3DPROC TextureStorage3D;
+        PFNGLTEXTURESTORAGE3DMULTISAMPLEPROC TextureStorage3DMultisample;
+        PFNGLTEXTURESUBIMAGE1DPROC TextureSubImage1D;
+        PFNGLTEXTURESUBIMAGE2DPROC TextureSubImage2D;
+        PFNGLTEXTURESUBIMAGE3DPROC TextureSubImage3D;
+        PFNGLTEXTUREVIEWPROC TextureView;
+        PFNGLTRANSFORMFEEDBACKBUFFERBASEPROC TransformFeedbackBufferBase;
+        PFNGLTRANSFORMFEEDBACKBUFFERRANGEPROC TransformFeedbackBufferRange;
+        PFNGLTRANSFORMFEEDBACKVARYINGSPROC TransformFeedbackVaryings;
+        PFNGLUNIFORM1DPROC Uniform1d;
+        PFNGLUNIFORM1DVPROC Uniform1dv;
+        PFNGLUNIFORM1FPROC Uniform1f;
+        PFNGLUNIFORM1FVPROC Uniform1fv;
+        PFNGLUNIFORM1IPROC Uniform1i;
+        PFNGLUNIFORM1IVPROC Uniform1iv;
+        PFNGLUNIFORM1UIPROC Uniform1ui;
+        PFNGLUNIFORM1UIVPROC Uniform1uiv;
+        PFNGLUNIFORM2DPROC Uniform2d;
+        PFNGLUNIFORM2DVPROC Uniform2dv;
+        PFNGLUNIFORM2FPROC Uniform2f;
+        PFNGLUNIFORM2FVPROC Uniform2fv;
+        PFNGLUNIFORM2IPROC Uniform2i;
+        PFNGLUNIFORM2IVPROC Uniform2iv;
+        PFNGLUNIFORM2UIPROC Uniform2ui;
+        PFNGLUNIFORM2UIVPROC Uniform2uiv;
+        PFNGLUNIFORM3DPROC Uniform3d;
+        PFNGLUNIFORM3DVPROC Uniform3dv;
+        PFNGLUNIFORM3FPROC Uniform3f;
+        PFNGLUNIFORM3FVPROC Uniform3fv;
+        PFNGLUNIFORM3IPROC Uniform3i;
+        PFNGLUNIFORM3IVPROC Uniform3iv;
+        PFNGLUNIFORM3UIPROC Uniform3ui;
+        PFNGLUNIFORM3UIVPROC Uniform3uiv;
+        PFNGLUNIFORM4DPROC Uniform4d;
+        PFNGLUNIFORM4DVPROC Uniform4dv;
+        PFNGLUNIFORM4FPROC Uniform4f;
+        PFNGLUNIFORM4FVPROC Uniform4fv;
+        PFNGLUNIFORM4IPROC Uniform4i;
+        PFNGLUNIFORM4IVPROC Uniform4iv;
+        PFNGLUNIFORM4UIPROC Uniform4ui;
+        PFNGLUNIFORM4UIVPROC Uniform4uiv;
+        PFNGLUNIFORMBLOCKBINDINGPROC UniformBlockBinding;
+        PFNGLUNIFORMMATRIX2DVPROC UniformMatrix2dv;
+        PFNGLUNIFORMMATRIX2FVPROC UniformMatrix2fv;
+        PFNGLUNIFORMMATRIX2X3DVPROC UniformMatrix2x3dv;
+        PFNGLUNIFORMMATRIX2X3FVPROC UniformMatrix2x3fv;
+        PFNGLUNIFORMMATRIX2X4DVPROC UniformMatrix2x4dv;
+        PFNGLUNIFORMMATRIX2X4FVPROC UniformMatrix2x4fv;
+        PFNGLUNIFORMMATRIX3DVPROC UniformMatrix3dv;
+        PFNGLUNIFORMMATRIX3FVPROC UniformMatrix3fv;
+        PFNGLUNIFORMMATRIX3X2DVPROC UniformMatrix3x2dv;
+        PFNGLUNIFORMMATRIX3X2FVPROC UniformMatrix3x2fv;
+        PFNGLUNIFORMMATRIX3X4DVPROC UniformMatrix3x4dv;
+        PFNGLUNIFORMMATRIX3X4FVPROC UniformMatrix3x4fv;
+        PFNGLUNIFORMMATRIX4DVPROC UniformMatrix4dv;
+        PFNGLUNIFORMMATRIX4FVPROC UniformMatrix4fv;
+        PFNGLUNIFORMMATRIX4X2DVPROC UniformMatrix4x2dv;
+        PFNGLUNIFORMMATRIX4X2FVPROC UniformMatrix4x2fv;
+        PFNGLUNIFORMMATRIX4X3DVPROC UniformMatrix4x3dv;
+        PFNGLUNIFORMMATRIX4X3FVPROC UniformMatrix4x3fv;
+        PFNGLUNIFORMSUBROUTINESUIVPROC UniformSubroutinesuiv;
+        PFNGLUNMAPBUFFERPROC UnmapBuffer;
+        PFNGLUNMAPNAMEDBUFFERPROC UnmapNamedBuffer;
+        PFNGLUSEPROGRAMPROC UseProgram;
+        PFNGLUSEPROGRAMSTAGESPROC UseProgramStages;
+        PFNGLVALIDATEPROGRAMPROC ValidateProgram;
+        PFNGLVALIDATEPROGRAMPIPELINEPROC ValidateProgramPipeline;
+        PFNGLVERTEXARRAYATTRIBBINDINGPROC VertexArrayAttribBinding;
+        PFNGLVERTEXARRAYATTRIBFORMATPROC VertexArrayAttribFormat;
+        PFNGLVERTEXARRAYATTRIBIFORMATPROC VertexArrayAttribIFormat;
+        PFNGLVERTEXARRAYATTRIBLFORMATPROC VertexArrayAttribLFormat;
+        PFNGLVERTEXARRAYBINDINGDIVISORPROC VertexArrayBindingDivisor;
+        PFNGLVERTEXARRAYELEMENTBUFFERPROC VertexArrayElementBuffer;
+        PFNGLVERTEXARRAYVERTEXBUFFERPROC VertexArrayVertexBuffer;
+        PFNGLVERTEXARRAYVERTEXBUFFERSPROC VertexArrayVertexBuffers;
+        PFNGLVERTEXATTRIB1DPROC VertexAttrib1d;
+        PFNGLVERTEXATTRIB1DVPROC VertexAttrib1dv;
+        PFNGLVERTEXATTRIB1FPROC VertexAttrib1f;
+        PFNGLVERTEXATTRIB1FVPROC VertexAttrib1fv;
+        PFNGLVERTEXATTRIB1SPROC VertexAttrib1s;
+        PFNGLVERTEXATTRIB1SVPROC VertexAttrib1sv;
+        PFNGLVERTEXATTRIB2DPROC VertexAttrib2d;
+        PFNGLVERTEXATTRIB2DVPROC VertexAttrib2dv;
+        PFNGLVERTEXATTRIB2FPROC VertexAttrib2f;
+        PFNGLVERTEXATTRIB2FVPROC VertexAttrib2fv;
+        PFNGLVERTEXATTRIB2SPROC VertexAttrib2s;
+        PFNGLVERTEXATTRIB2SVPROC VertexAttrib2sv;
+        PFNGLVERTEXATTRIB3DPROC VertexAttrib3d;
+        PFNGLVERTEXATTRIB3DVPROC VertexAttrib3dv;
+        PFNGLVERTEXATTRIB3FPROC VertexAttrib3f;
+        PFNGLVERTEXATTRIB3FVPROC VertexAttrib3fv;
+        PFNGLVERTEXATTRIB3SPROC VertexAttrib3s;
+        PFNGLVERTEXATTRIB3SVPROC VertexAttrib3sv;
+        PFNGLVERTEXATTRIB4NBVPROC VertexAttrib4Nbv;
+        PFNGLVERTEXATTRIB4NIVPROC VertexAttrib4Niv;
+        PFNGLVERTEXATTRIB4NSVPROC VertexAttrib4Nsv;
+        PFNGLVERTEXATTRIB4NUBPROC VertexAttrib4Nub;
+        PFNGLVERTEXATTRIB4NUBVPROC VertexAttrib4Nubv;
+        PFNGLVERTEXATTRIB4NUIVPROC VertexAttrib4Nuiv;
+        PFNGLVERTEXATTRIB4NUSVPROC VertexAttrib4Nusv;
+        PFNGLVERTEXATTRIB4BVPROC VertexAttrib4bv;
+        PFNGLVERTEXATTRIB4DPROC VertexAttrib4d;
+        PFNGLVERTEXATTRIB4DVPROC VertexAttrib4dv;
+        PFNGLVERTEXATTRIB4FPROC VertexAttrib4f;
+        PFNGLVERTEXATTRIB4FVPROC VertexAttrib4fv;
+        PFNGLVERTEXATTRIB4IVPROC VertexAttrib4iv;
+        PFNGLVERTEXATTRIB4SPROC VertexAttrib4s;
+        PFNGLVERTEXATTRIB4SVPROC VertexAttrib4sv;
+        PFNGLVERTEXATTRIB4UBVPROC VertexAttrib4ubv;
+        PFNGLVERTEXATTRIB4UIVPROC VertexAttrib4uiv;
+        PFNGLVERTEXATTRIB4USVPROC VertexAttrib4usv;
+        PFNGLVERTEXATTRIBBINDINGPROC VertexAttribBinding;
+        PFNGLVERTEXATTRIBDIVISORPROC VertexAttribDivisor;
+        PFNGLVERTEXATTRIBFORMATPROC VertexAttribFormat;
+        PFNGLVERTEXATTRIBI1IPROC VertexAttribI1i;
+        PFNGLVERTEXATTRIBI1IVPROC VertexAttribI1iv;
+        PFNGLVERTEXATTRIBI1UIPROC VertexAttribI1ui;
+        PFNGLVERTEXATTRIBI1UIVPROC VertexAttribI1uiv;
+        PFNGLVERTEXATTRIBI2IPROC VertexAttribI2i;
+        PFNGLVERTEXATTRIBI2IVPROC VertexAttribI2iv;
+        PFNGLVERTEXATTRIBI2UIPROC VertexAttribI2ui;
+        PFNGLVERTEXATTRIBI2UIVPROC VertexAttribI2uiv;
+        PFNGLVERTEXATTRIBI3IPROC VertexAttribI3i;
+        PFNGLVERTEXATTRIBI3IVPROC VertexAttribI3iv;
+        PFNGLVERTEXATTRIBI3UIPROC VertexAttribI3ui;
+        PFNGLVERTEXATTRIBI3UIVPROC VertexAttribI3uiv;
+        PFNGLVERTEXATTRIBI4BVPROC VertexAttribI4bv;
+        PFNGLVERTEXATTRIBI4IPROC VertexAttribI4i;
+        PFNGLVERTEXATTRIBI4IVPROC VertexAttribI4iv;
+        PFNGLVERTEXATTRIBI4SVPROC VertexAttribI4sv;
+        PFNGLVERTEXATTRIBI4UBVPROC VertexAttribI4ubv;
+        PFNGLVERTEXATTRIBI4UIPROC VertexAttribI4ui;
+        PFNGLVERTEXATTRIBI4UIVPROC VertexAttribI4uiv;
+        PFNGLVERTEXATTRIBI4USVPROC VertexAttribI4usv;
+        PFNGLVERTEXATTRIBIFORMATPROC VertexAttribIFormat;
+        PFNGLVERTEXATTRIBIPOINTERPROC VertexAttribIPointer;
+        PFNGLVERTEXATTRIBL1DPROC VertexAttribL1d;
+        PFNGLVERTEXATTRIBL1DVPROC VertexAttribL1dv;
+        PFNGLVERTEXATTRIBL2DPROC VertexAttribL2d;
+        PFNGLVERTEXATTRIBL2DVPROC VertexAttribL2dv;
+        PFNGLVERTEXATTRIBL3DPROC VertexAttribL3d;
+        PFNGLVERTEXATTRIBL3DVPROC VertexAttribL3dv;
+        PFNGLVERTEXATTRIBL4DPROC VertexAttribL4d;
+        PFNGLVERTEXATTRIBL4DVPROC VertexAttribL4dv;
+        PFNGLVERTEXATTRIBLFORMATPROC VertexAttribLFormat;
+        PFNGLVERTEXATTRIBLPOINTERPROC VertexAttribLPointer;
+        PFNGLVERTEXATTRIBP1UIPROC VertexAttribP1ui;
+        PFNGLVERTEXATTRIBP1UIVPROC VertexAttribP1uiv;
+        PFNGLVERTEXATTRIBP2UIPROC VertexAttribP2ui;
+        PFNGLVERTEXATTRIBP2UIVPROC VertexAttribP2uiv;
+        PFNGLVERTEXATTRIBP3UIPROC VertexAttribP3ui;
+        PFNGLVERTEXATTRIBP3UIVPROC VertexAttribP3uiv;
+        PFNGLVERTEXATTRIBP4UIPROC VertexAttribP4ui;
+        PFNGLVERTEXATTRIBP4UIVPROC VertexAttribP4uiv;
+        PFNGLVERTEXATTRIBPOINTERPROC VertexAttribPointer;
+        PFNGLVERTEXBINDINGDIVISORPROC VertexBindingDivisor;
+        PFNGLVIEWPORTPROC Viewport;
+        PFNGLVIEWPORTARRAYVPROC ViewportArrayv;
+        PFNGLVIEWPORTINDEXEDFPROC ViewportIndexedf;
+        PFNGLVIEWPORTINDEXEDFVPROC ViewportIndexedfv;
+        PFNGLWAITSYNCPROC WaitSync;

StgSharp.Tools/cs.txt

@@ -0,0 +1,657 @@
+        internal unsafe delegate*<uint, uint, void> glActiveShaderProgram;
+        internal unsafe delegate*<uint, void> glActiveTexture;
+        internal unsafe delegate*<uint, uint, void> glAttachShader;
+        internal unsafe delegate*<uint, uint, void> glBeginConditionalRender;
+        internal unsafe delegate*<uint, uint, void> glBeginQuery;
+        internal unsafe delegate*<uint, uint, uint, void> glBeginQueryIndexed;
+        internal unsafe delegate*<uint, void> glBeginTransformFeedback;
+        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, int, uint*, void> glBindBuffersBase;
+        internal unsafe delegate*<uint, uint, int, uint*, nint*, nuint*, 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;
+        internal unsafe delegate*<uint, uint, int, byte, int, uint, uint, void> glBindImageTexture;
+        internal unsafe delegate*<uint, int, uint*, void> glBindImageTextures;
+        internal unsafe delegate*<uint, void> glBindProgramPipeline;
+        internal unsafe delegate*<uint, uint, void> glBindRenderbuffer;
+        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, 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> 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, 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, 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, nint, nuint, uint, uint, IntPtr*, 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, 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, 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, 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, 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, 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;
+        internal unsafe delegate*<uint, int, int, int, int, int, int, int, void> glCopyTexSubImage2D;
+        internal unsafe delegate*<uint, int, int, int, int, int, int, int, int, void> glCopyTexSubImage3D;
+        internal unsafe delegate*<uint, int, int, int, int, int, void> glCopyTextureSubImage1D;
+        internal unsafe delegate*<uint, int, int, int, int, int, int, int, void> glCopyTextureSubImage2D;
+        internal unsafe delegate*<uint, int, int, int, int, int, int, int, int, void> glCopyTextureSubImage3D;
+        internal unsafe delegate*<int, uint*, void> glCreateBuffers;
+        internal unsafe delegate*<int, uint*, void> glCreateFramebuffers;
+        internal unsafe delegate*<uint> glCreateProgram;
+        internal unsafe delegate*<int, uint*, void> glCreateProgramPipelines;
+        internal unsafe delegate*<uint, int, uint*, void> glCreateQueries;
+        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, 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*<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;
+        internal unsafe delegate*<int, uint*, void> glDeleteFramebuffers;
+        internal unsafe delegate*<uint, void> glDeleteProgram;
+        internal unsafe delegate*<int, uint*, void> glDeleteProgramPipelines;
+        internal unsafe delegate*<int, uint*, void> glDeleteQueries;
+        internal unsafe delegate*<int, uint*, void> glDeleteRenderbuffers;
+        internal unsafe delegate*<int, uint*, void> glDeleteSamplers;
+        internal unsafe delegate*<uint, void> glDeleteShader;
+        internal unsafe delegate*<GLsync, void> glDeleteSync;
+        internal unsafe delegate*<int, uint*, void> glDeleteTextures;
+        internal unsafe delegate*<int, uint*, void> glDeleteTransformFeedbacks;
+        internal unsafe delegate*<int, uint*, void> glDeleteVertexArrays;
+        internal unsafe delegate*<uint, void> glDepthFunc;
+        internal unsafe delegate*<byte, void> glDepthMask;
+        internal unsafe delegate*<double, double, void> glDepthRange;
+        internal unsafe delegate*<uint, int, double*, void> glDepthRangeArrayv;
+        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> 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, 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, 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> 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;
+        internal unsafe delegate*<void> glEndTransformFeedback;
+        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, uint, int, void> glFramebufferParameteri;
+        internal unsafe delegate*<uint, uint, uint, uint, void> glFramebufferRenderbuffer;
+        internal unsafe delegate*<uint, uint, uint, int, void> glFramebufferTexture;
+        internal unsafe delegate*<uint, uint, uint, uint, int, void> glFramebufferTexture1D;
+        internal unsafe delegate*<uint, uint, uint, uint, int, void> glFramebufferTexture2D;
+        internal unsafe delegate*<uint, uint, uint, uint, int, int, void> glFramebufferTexture3D;
+        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*<int, uint*, void> glGenFramebuffers;
+        internal unsafe delegate*<int, uint*, void> glGenProgramPipelines;
+        internal unsafe delegate*<int, uint*, void> glGenQueries;
+        internal unsafe delegate*<int, uint*, void> glGenRenderbuffers;
+        internal unsafe delegate*<int, uint*, void> glGenSamplers;
+        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, 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, 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, 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, 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;
+        internal unsafe delegate*<uint> glGetError;
+        internal unsafe delegate*<uint, uint, float*, void> glGetFloati_v;
+        internal unsafe delegate*<uint, float*, void> glGetFloatv;
+        internal unsafe delegate*<uint, byte*, int> glGetFragDataIndex;
+        internal unsafe delegate*<uint, byte*, int> glGetFragDataLocation;
+        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, 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, int*, void> glGetInternalformativ;
+        internal unsafe delegate*<uint, uint, float*, void> glGetMultisamplefv;
+        internal unsafe delegate*<uint, uint, IntPtr*, 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, uint, int*, void> glGetNamedFramebufferAttachmentParameteriv;
+        internal unsafe delegate*<uint, uint, int*, void> glGetNamedFramebufferParameteriv;
+        internal unsafe delegate*<uint, uint, int*, void> glGetNamedRenderbufferParameteriv;
+        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*<uint, int, int*, byte*, void> glGetProgramInfoLog;
+        internal unsafe delegate*<uint, uint, uint, int*, void> glGetProgramInterfaceiv;
+        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, 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, IntPtr*, void> glGetQueryObjecti64v;
+        internal unsafe delegate*<uint, uint, int*, void> glGetQueryObjectiv;
+        internal unsafe delegate*<uint, uint, IntPtr*, 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, 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*, 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, float*, void> glGetTexLevelParameterfv;
+        internal unsafe delegate*<uint, int, uint, int*, void> glGetTexLevelParameteriv;
+        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, float*, void> glGetTextureLevelParameterfv;
+        internal unsafe delegate*<uint, int, uint, int*, void> glGetTextureLevelParameteriv;
+        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, int, int*, int*, uint*, byte*, void> glGetTransformFeedbackVarying;
+        internal unsafe delegate*<uint, uint, uint, IntPtr*, 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, 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, int*, void> glGetVertexArrayIndexediv;
+        internal unsafe delegate*<uint, uint, int*, void> glGetVertexArrayiv;
+        internal unsafe delegate*<uint, uint, int*, void> glGetVertexAttribIiv;
+        internal unsafe delegate*<uint, uint, uint*, void> glGetVertexAttribIuiv;
+        internal unsafe delegate*<uint, uint, double*, void> glGetVertexAttribLdv;
+        internal unsafe delegate*<uint, uint, IntPtr**, 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, 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, void> glHint;
+        internal unsafe delegate*<uint, void> glInvalidateBufferData;
+        internal unsafe delegate*<uint, nint, nuint, 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;
+        internal unsafe delegate*<uint, int, uint*, int, int, int, int, void> glInvalidateSubFramebuffer;
+        internal unsafe delegate*<uint, int, void> glInvalidateTexImage;
+        internal unsafe delegate*<uint, int, int, int, int, int, int, int, void> glInvalidateTexSubImage;
+        internal unsafe delegate*<uint, byte> glIsBuffer;
+        internal unsafe delegate*<uint, byte> glIsEnabled;
+        internal unsafe delegate*<uint, uint, byte> glIsEnabledi;
+        internal unsafe delegate*<uint, byte> glIsFramebuffer;
+        internal unsafe delegate*<uint, byte> glIsProgram;
+        internal unsafe delegate*<uint, byte> glIsProgramPipeline;
+        internal unsafe delegate*<uint, byte> glIsQuery;
+        internal unsafe delegate*<uint, byte> glIsRenderbuffer;
+        internal unsafe delegate*<uint, byte> glIsSampler;
+        internal unsafe delegate*<uint, byte> glIsShader;
+        internal unsafe delegate*<GLsync, byte> glIsSync;
+        internal unsafe delegate*<uint, byte> glIsTexture;
+        internal unsafe delegate*<uint, byte> glIsTransformFeedback;
+        internal unsafe delegate*<uint, byte> glIsVertexArray;
+        internal unsafe delegate*<float, void> glLineWidth;
+        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, uint, void*> glMapNamedBuffer;
+        internal unsafe delegate*<uint, nint, nuint, 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, uint, void> glNamedFramebufferDrawBuffer;
+        internal unsafe delegate*<uint, int, uint*, void> glNamedFramebufferDrawBuffers;
+        internal unsafe delegate*<uint, uint, int, void> glNamedFramebufferParameteri;
+        internal unsafe delegate*<uint, uint, void> glNamedFramebufferReadBuffer;
+        internal unsafe delegate*<uint, uint, uint, uint, void> glNamedFramebufferRenderbuffer;
+        internal unsafe delegate*<uint, uint, uint, int, void> glNamedFramebufferTexture;
+        internal unsafe delegate*<uint, uint, uint, int, int, void> glNamedFramebufferTextureLayer;
+        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*<uint, float*, void> glPatchParameterfv;
+        internal unsafe delegate*<uint, int, void> glPatchParameteri;
+        internal unsafe delegate*<void> glPauseTransformFeedback;
+        internal unsafe delegate*<uint, float, void> glPixelStoref;
+        internal unsafe delegate*<uint, int, void> glPixelStorei;
+        internal unsafe delegate*<uint, float, void> glPointParameterf;
+        internal unsafe delegate*<uint, float*, void> glPointParameterfv;
+        internal unsafe delegate*<uint, int, void> glPointParameteri;
+        internal unsafe delegate*<uint, int*, void> glPointParameteriv;
+        internal unsafe delegate*<float, void> glPointSize;
+        internal unsafe delegate*<uint, uint, void> glPolygonMode;
+        internal unsafe delegate*<float, float, void> glPolygonOffset;
+        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, int, void> glProgramParameteri;
+        internal unsafe delegate*<uint, int, double, void> glProgramUniform1d;
+        internal unsafe delegate*<uint, int, int, double*, void> glProgramUniform1dv;
+        internal unsafe delegate*<uint, int, float, void> glProgramUniform1f;
+        internal unsafe delegate*<uint, int, int, float*, void> glProgramUniform1fv;
+        internal unsafe delegate*<uint, int, int, void> glProgramUniform1i;
+        internal unsafe delegate*<uint, int, int, int*, void> glProgramUniform1iv;
+        internal unsafe delegate*<uint, int, uint, void> glProgramUniform1ui;
+        internal unsafe delegate*<uint, int, int, uint*, void> glProgramUniform1uiv;
+        internal unsafe delegate*<uint, int, double, double, void> glProgramUniform2d;
+        internal unsafe delegate*<uint, int, int, double*, void> glProgramUniform2dv;
+        internal unsafe delegate*<uint, int, float, float, void> glProgramUniform2f;
+        internal unsafe delegate*<uint, int, int, float*, void> glProgramUniform2fv;
+        internal unsafe delegate*<uint, int, int, int, void> glProgramUniform2i;
+        internal unsafe delegate*<uint, int, int, int*, void> glProgramUniform2iv;
+        internal unsafe delegate*<uint, int, uint, uint, void> glProgramUniform2ui;
+        internal unsafe delegate*<uint, int, int, uint*, void> glProgramUniform2uiv;
+        internal unsafe delegate*<uint, int, double, double, double, void> glProgramUniform3d;
+        internal unsafe delegate*<uint, int, int, double*, void> glProgramUniform3dv;
+        internal unsafe delegate*<uint, int, float, float, float, void> glProgramUniform3f;
+        internal unsafe delegate*<uint, int, int, float*, void> glProgramUniform3fv;
+        internal unsafe delegate*<uint, int, int, int, int, void> glProgramUniform3i;
+        internal unsafe delegate*<uint, int, int, int*, void> glProgramUniform3iv;
+        internal unsafe delegate*<uint, int, uint, uint, uint, void> glProgramUniform3ui;
+        internal unsafe delegate*<uint, int, int, uint*, void> glProgramUniform3uiv;
+        internal unsafe delegate*<uint, int, double, double, double, double, void> glProgramUniform4d;
+        internal unsafe delegate*<uint, int, int, double*, void> glProgramUniform4dv;
+        internal unsafe delegate*<uint, int, float, float, float, float, void> glProgramUniform4f;
+        internal unsafe delegate*<uint, int, int, float*, void> glProgramUniform4fv;
+        internal unsafe delegate*<uint, int, int, int, int, int, void> glProgramUniform4i;
+        internal unsafe delegate*<uint, int, int, int*, void> glProgramUniform4iv;
+        internal unsafe delegate*<uint, int, uint, uint, uint, uint, void> glProgramUniform4ui;
+        internal unsafe delegate*<uint, int, int, uint*, void> glProgramUniform4uiv;
+        internal unsafe delegate*<uint, int, int, byte, double*, void> glProgramUniformMatrix2dv;
+        internal unsafe delegate*<uint, int, int, byte, float*, void> glProgramUniformMatrix2fv;
+        internal unsafe delegate*<uint, int, int, byte, double*, void> glProgramUniformMatrix2x3dv;
+        internal unsafe delegate*<uint, int, int, byte, float*, void> glProgramUniformMatrix2x3fv;
+        internal unsafe delegate*<uint, int, int, byte, double*, void> glProgramUniformMatrix2x4dv;
+        internal unsafe delegate*<uint, int, int, byte, float*, void> glProgramUniformMatrix2x4fv;
+        internal unsafe delegate*<uint, int, int, byte, double*, void> glProgramUniformMatrix3dv;
+        internal unsafe delegate*<uint, int, int, byte, float*, void> glProgramUniformMatrix3fv;
+        internal unsafe delegate*<uint, int, int, byte, double*, void> glProgramUniformMatrix3x2dv;
+        internal unsafe delegate*<uint, int, int, byte, float*, void> glProgramUniformMatrix3x2fv;
+        internal unsafe delegate*<uint, int, int, byte, double*, void> glProgramUniformMatrix3x4dv;
+        internal unsafe delegate*<uint, int, int, byte, float*, void> glProgramUniformMatrix3x4fv;
+        internal unsafe delegate*<uint, int, int, byte, double*, void> glProgramUniformMatrix4dv;
+        internal unsafe delegate*<uint, int, int, byte, float*, void> glProgramUniformMatrix4fv;
+        internal unsafe delegate*<uint, int, int, byte, double*, void> glProgramUniformMatrix4x2dv;
+        internal unsafe delegate*<uint, int, int, byte, float*, void> glProgramUniformMatrix4x2fv;
+        internal unsafe delegate*<uint, int, int, byte, double*, void> glProgramUniformMatrix4x3dv;
+        internal unsafe delegate*<uint, int, int, byte, float*, void> glProgramUniformMatrix4x3fv;
+        internal unsafe delegate*<uint, void> glProvokingVertex;
+        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, IntPtr*, void> glReadPixels;
+        internal unsafe delegate*<int, int, int, int, uint, uint, int, IntPtr*, 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> 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*<uint, int, byte**, int*, void> glShaderSource;
+        internal unsafe delegate*<uint, uint, uint, void> glShaderStorageBlockBinding;
+        internal unsafe delegate*<uint, byte*, uint, uint*, uint*, void> glSpecializeShader;
+        internal unsafe delegate*<uint, int, uint, void> glStencilFunc;
+        internal unsafe delegate*<uint, uint, int, uint, void> glStencilFuncSeparate;
+        internal unsafe delegate*<uint, void> glStencilMask;
+        internal unsafe delegate*<uint, uint, void> glStencilMaskSeparate;
+        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, 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, 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> 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*<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, 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> 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, 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*<int, double, void> glUniform1d;
+        internal unsafe delegate*<int, int, double*, void> glUniform1dv;
+        internal unsafe delegate*<int, float, void> glUniform1f;
+        internal unsafe delegate*<int, int, float*, void> glUniform1fv;
+        internal unsafe delegate*<int, int, void> glUniform1i;
+        internal unsafe delegate*<int, int, int*, void> glUniform1iv;
+        internal unsafe delegate*<int, uint, void> glUniform1ui;
+        internal unsafe delegate*<int, int, uint*, void> glUniform1uiv;
+        internal unsafe delegate*<int, double, double, void> glUniform2d;
+        internal unsafe delegate*<int, int, double*, void> glUniform2dv;
+        internal unsafe delegate*<int, float, float, void> glUniform2f;
+        internal unsafe delegate*<int, int, float*, void> glUniform2fv;
+        internal unsafe delegate*<int, int, int, void> glUniform2i;
+        internal unsafe delegate*<int, int, int*, void> glUniform2iv;
+        internal unsafe delegate*<int, uint, uint, void> glUniform2ui;
+        internal unsafe delegate*<int, int, uint*, void> glUniform2uiv;
+        internal unsafe delegate*<int, double, double, double, void> glUniform3d;
+        internal unsafe delegate*<int, int, double*, void> glUniform3dv;
+        internal unsafe delegate*<int, float, float, float, void> glUniform3f;
+        internal unsafe delegate*<int, int, float*, void> glUniform3fv;
+        internal unsafe delegate*<int, int, int, int, void> glUniform3i;
+        internal unsafe delegate*<int, int, int*, void> glUniform3iv;
+        internal unsafe delegate*<int, uint, uint, uint, void> glUniform3ui;
+        internal unsafe delegate*<int, int, uint*, void> glUniform3uiv;
+        internal unsafe delegate*<int, double, double, double, double, void> glUniform4d;
+        internal unsafe delegate*<int, int, double*, void> glUniform4dv;
+        internal unsafe delegate*<int, float, float, float, float, void> glUniform4f;
+        internal unsafe delegate*<int, int, float*, void> glUniform4fv;
+        internal unsafe delegate*<int, int, int, int, int, void> glUniform4i;
+        internal unsafe delegate*<int, int, int*, void> glUniform4iv;
+        internal unsafe delegate*<int, uint, uint, uint, uint, void> glUniform4ui;
+        internal unsafe delegate*<int, int, uint*, void> glUniform4uiv;
+        internal unsafe delegate*<uint, uint, uint, void> glUniformBlockBinding;
+        internal unsafe delegate*<int, int, byte, double*, void> glUniformMatrix2dv;
+        internal unsafe delegate*<int, int, byte, float*, void> glUniformMatrix2fv;
+        internal unsafe delegate*<int, int, byte, double*, void> glUniformMatrix2x3dv;
+        internal unsafe delegate*<int, int, byte, float*, void> glUniformMatrix2x3fv;
+        internal unsafe delegate*<int, int, byte, double*, void> glUniformMatrix2x4dv;
+        internal unsafe delegate*<int, int, byte, float*, void> glUniformMatrix2x4fv;
+        internal unsafe delegate*<int, int, byte, double*, void> glUniformMatrix3dv;
+        internal unsafe delegate*<int, int, byte, float*, void> glUniformMatrix3fv;
+        internal unsafe delegate*<int, int, byte, double*, void> glUniformMatrix3x2dv;
+        internal unsafe delegate*<int, int, byte, float*, void> glUniformMatrix3x2fv;
+        internal unsafe delegate*<int, int, byte, double*, void> glUniformMatrix3x4dv;
+        internal unsafe delegate*<int, int, byte, float*, void> glUniformMatrix3x4fv;
+        internal unsafe delegate*<int, int, byte, double*, void> glUniformMatrix4dv;
+        internal unsafe delegate*<int, int, byte, float*, void> glUniformMatrix4fv;
+        internal unsafe delegate*<int, int, byte, double*, void> glUniformMatrix4x2dv;
+        internal unsafe delegate*<int, int, byte, float*, void> glUniformMatrix4x2fv;
+        internal unsafe delegate*<int, int, byte, double*, void> glUniformMatrix4x3dv;
+        internal unsafe delegate*<int, int, byte, float*, void> glUniformMatrix4x3fv;
+        internal unsafe delegate*<uint, int, uint*, void> glUniformSubroutinesuiv;
+        internal unsafe delegate*<uint, byte> glUnmapBuffer;
+        internal unsafe delegate*<uint, byte> glUnmapNamedBuffer;
+        internal unsafe delegate*<uint, void> glUseProgram;
+        internal unsafe delegate*<uint, uint, uint, void> glUseProgramStages;
+        internal unsafe delegate*<uint, void> glValidateProgram;
+        internal unsafe delegate*<uint, void> glValidateProgramPipeline;
+        internal unsafe delegate*<uint, uint, uint, void> glVertexArrayAttribBinding;
+        internal unsafe delegate*<uint, uint, int, uint, byte, uint, void> glVertexArrayAttribFormat;
+        internal unsafe delegate*<uint, uint, int, uint, uint, void> glVertexArrayAttribIFormat;
+        internal unsafe delegate*<uint, uint, int, uint, uint, void> glVertexArrayAttribLFormat;
+        internal unsafe delegate*<uint, uint, uint, void> glVertexArrayBindingDivisor;
+        internal unsafe delegate*<uint, uint, void> glVertexArrayElementBuffer;
+        internal unsafe delegate*<uint, uint, uint, nint, int, void> glVertexArrayVertexBuffer;
+        internal unsafe delegate*<uint, uint, int, uint*, nint*, int*, void> glVertexArrayVertexBuffers;
+        internal unsafe delegate*<uint, double, void> glVertexAttrib1d;
+        internal unsafe delegate*<uint, double*, void> glVertexAttrib1dv;
+        internal unsafe delegate*<uint, float, void> glVertexAttrib1f;
+        internal unsafe delegate*<uint, float*, void> glVertexAttrib1fv;
+        internal unsafe delegate*<uint, short, void> glVertexAttrib1s;
+        internal unsafe delegate*<uint, short*, void> glVertexAttrib1sv;
+        internal unsafe delegate*<uint, double, double, void> glVertexAttrib2d;
+        internal unsafe delegate*<uint, double*, void> glVertexAttrib2dv;
+        internal unsafe delegate*<uint, float, float, void> glVertexAttrib2f;
+        internal unsafe delegate*<uint, float*, void> glVertexAttrib2fv;
+        internal unsafe delegate*<uint, short, short, void> glVertexAttrib2s;
+        internal unsafe delegate*<uint, short*, void> glVertexAttrib2sv;
+        internal unsafe delegate*<uint, double, double, double, void> glVertexAttrib3d;
+        internal unsafe delegate*<uint, double*, void> glVertexAttrib3dv;
+        internal unsafe delegate*<uint, float, float, float, void> glVertexAttrib3f;
+        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> glVertexAttrib4Nbv;
+        internal unsafe delegate*<uint, int*, void> glVertexAttrib4Niv;
+        internal unsafe delegate*<uint, short*, void> glVertexAttrib4Nsv;
+        internal unsafe delegate*<uint, byte, byte, byte, byte, void> glVertexAttrib4Nub;
+        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;
+        internal unsafe delegate*<uint, uint*, void> glVertexAttrib4uiv;
+        internal unsafe delegate*<uint, ushort*, void> glVertexAttrib4usv;
+        internal unsafe delegate*<uint, uint, void> glVertexAttribBinding;
+        internal unsafe delegate*<uint, uint, void> glVertexAttribDivisor;
+        internal unsafe delegate*<uint, int, uint, byte, uint, void> glVertexAttribFormat;
+        internal unsafe delegate*<uint, int, void> glVertexAttribI1i;
+        internal unsafe delegate*<uint, int*, void> glVertexAttribI1iv;
+        internal unsafe delegate*<uint, uint, void> glVertexAttribI1ui;
+        internal unsafe delegate*<uint, uint*, void> glVertexAttribI1uiv;
+        internal unsafe delegate*<uint, int, int, void> glVertexAttribI2i;
+        internal unsafe delegate*<uint, int*, void> glVertexAttribI2iv;
+        internal unsafe delegate*<uint, uint, uint, void> glVertexAttribI2ui;
+        internal unsafe delegate*<uint, uint*, void> glVertexAttribI2uiv;
+        internal unsafe delegate*<uint, int, int, int, void> glVertexAttribI3i;
+        internal unsafe delegate*<uint, int*, void> glVertexAttribI3iv;
+        internal unsafe delegate*<uint, uint, uint, uint, void> glVertexAttribI3ui;
+        internal unsafe delegate*<uint, uint*, void> glVertexAttribI3uiv;
+        internal unsafe delegate*<uint, sbyte*, void> glVertexAttribI4bv;
+        internal unsafe delegate*<uint, int, int, int, int, void> glVertexAttribI4i;
+        internal unsafe delegate*<uint, int*, void> glVertexAttribI4iv;
+        internal unsafe delegate*<uint, short*, void> glVertexAttribI4sv;
+        internal unsafe delegate*<uint, byte*, void> glVertexAttribI4ubv;
+        internal unsafe delegate*<uint, uint, uint, uint, uint, void> glVertexAttribI4ui;
+        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, double, void> glVertexAttribL1d;
+        internal unsafe delegate*<uint, double*, void> glVertexAttribL1dv;
+        internal unsafe delegate*<uint, double, double, void> glVertexAttribL2d;
+        internal unsafe delegate*<uint, double*, void> glVertexAttribL2dv;
+        internal unsafe delegate*<uint, double, double, double, void> glVertexAttribL3d;
+        internal unsafe delegate*<uint, double*, void> glVertexAttribL3dv;
+        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, uint, byte, uint, void> glVertexAttribP1ui;
+        internal unsafe delegate*<uint, uint, byte, uint*, void> glVertexAttribP1uiv;
+        internal unsafe delegate*<uint, uint, byte, uint, void> glVertexAttribP2ui;
+        internal unsafe delegate*<uint, uint, byte, uint*, void> glVertexAttribP2uiv;
+        internal unsafe delegate*<uint, uint, byte, uint, void> glVertexAttribP3ui;
+        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, 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;

StgSharp.Tools/gl_diff.cs

@@ -0,0 +1,74 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
+
+partial class Program
+{
+    private static readonly string csharpFieldsFile = @"d:\platform-dev\StgSharp.Tools\cs.txt";
+    private static readonly string cStructFieldsFile = @"d:\platform-dev\StgSharp.Tools\c.txt";
+
+    static void Main()
+    {
+        var csharpFields = ParseFieldNames(File.ReadAllText(csharpFieldsFile), stripGlPrefix: true);
+        var cStructFields = ParseFieldNames(File.ReadAllText(cStructFieldsFile), stripGlPrefix: false);
+
+        var missingInCStruct = new HashSet<string>(csharpFields).Except(cStructFields).ToList();
+        var missingInCSharp = new HashSet<string>(cStructFields).Except(csharpFields).ToList();
+
+
+        Console.WriteLine("Fields only in C# file:");
+        missingInCStruct.ForEach(f => Console.WriteLine($"  {f}"));
+
+        Console.WriteLine("Fields only in C struct file:");
+        missingInCSharp.ForEach(f => Console.WriteLine($"  {f}"));
+    }
+
+    private static HashSet<string> ParseFieldNames(string content, bool stripGlPrefix)
+    {
+        content = StripComments(content);
+
+        var matches = stripGlPrefix
+            ? CSharpFieldRegex().Matches(content)
+            : CStructFieldRegex().Matches(content);
+
+        var fields = new HashSet<string>();
+        foreach (Match match in matches)
+        {
+            var nameGroup = match.Groups["name"];
+            if (nameGroup.Success)
+            {
+                fields.Add(nameGroup.Value);
+            }
+            else if (match.Groups.Count > 1)
+            {
+                fields.Add(match.Groups[1].Value);
+            }
+        }
+        return fields;
+    }
+
+    private static string StripComments(string text)
+    {
+        // Remove // comments
+        text = LineCommentRegex().Replace(text, string.Empty);
+        // Remove /* */ comments
+        text = BlockCommentRegex().Replace(text, string.Empty);
+        return text;
+    }
+
+    // C#: internal delegate*<...> glName; capture Name without the gl prefix
+    [GeneratedRegex(@"^\s*internal\s+(?:unsafe\s+)?delegate\*<[^>]+?>\s+gl(?<name>[A-Za-z0-9_]+)\s*;", RegexOptions.Multiline)]
+    private static partial Regex CSharpFieldRegex();
+
+    // C: PFNGLXYZPROC Name; capture the Name
+    [GeneratedRegex(@"^\s*PFNGL[A-Z0-9_]+PROC\s+(?<name>[A-Za-z0-9_]+)\s*;", RegexOptions.Multiline)]
+    private static partial Regex CStructFieldRegex();
+
+    [GeneratedRegex("//.*", RegexOptions.None)]
+    private static partial Regex LineCommentRegex();
+
+    [GeneratedRegex("/\\*.*?\\*/", RegexOptions.Singleline)]
+    private static partial Regex BlockCommentRegex();
+}

StgSharpDebug/Program.cs

@@ -39,7 +39,9 @@ namespace StgSharp
 
         private static string testExpPath = @"D:\Programmer\stepcode\data\ap203\ap203.exp";
 
-        internal static unsafe void Main(string[] args)
+        internal static unsafe void Main(
+                                    string[] args
+        )
         {
             try
             {
@@ -48,12 +50,8 @@ namespace StgSharp
                      .UseModule<GraphicModule>()
                      .InitializeModule();
 
-                // TestRender();
-                // TestHlsf();
-
-
-                // HlsfStressTest.Run();
-                /**/
+                TestRender();
+                /*
                 HybridLayerSegregatedFitAllocator hlsf;
                 unchecked {
                     hlsf = new((nuint)(64 * (ulong)10000 * 10000));
@@ -79,7 +77,7 @@ namespace StgSharp
                     Console.WriteLine($"{i}");
                     GC.Collect();
                 }
-                /**/
+                /*
                 MatrixCompute.Mul(n, m, p);
                 for (int i = 0; i < 20; i++)
                 {

StgSharpDebug/RenderStream/Partical.cs

@@ -1,4 +1,4 @@
-//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 // file="Partical"
 // Project: StgSharp
@@ -75,7 +75,9 @@ namespace StgSharp
         public TextureProvider ButtonTextureProvider { get; private set; }
 
         // render a controlling item
-        public void ButtonMain(IEnumerable<PlainGeometryMesh> items)
+        public void ButtonMain(
+                    IEnumerable<PlainGeometryMesh> items
+        )
         {
             // Console.WriteLine("Render Button Itself");
 
@@ -106,7 +108,7 @@ namespace StgSharp
             temp++;
 
             // GL.ClearError();
-            GL.Viewport(0, 0, (uint)Width, (uint)Height);
+            GL.Viewport(0, 0, Width, Height);
 
             // Console.Clear();
             buffer.UpdateAllParticles();
@@ -117,12 +119,13 @@ namespace StgSharp
             vao.Bind(0); //GL.Assert(true);
             t.Bind2D(0); //GL.Assert(false);
 
-            GL.Viewport(0, 0, (uint)Width, (uint)Height);
+            GL.Viewport(0, 0, Width, Height);
 
             /**/
 
-            GL.TextureImage2d<byte>(Texture2DTarget.Texture2D, 0, ImageChannel.WithAlphaChannel, (uint)Width,
-                                    (uint)Height, ImageChannel.WithAlphaChannel, PixelChannelLayout.Byte, null);
+            GL.TextureImage2d<byte>(Texture2DTarget.Texture2D, 0, ImageChannel.WithAlphaChannel,
+                                    Width, Height, ImageChannel.WithAlphaChannel,
+                                    PixelChannelLayout.Byte, null);
             /**/
 
             // GL.Assert(false);
@@ -162,8 +165,8 @@ namespace StgSharp
             // GL.ClearError();
             // Console.Write($"Size set to {Height},{Width}");
             // Console.WriteLine($"Image resized to {i.Height} {i.Width}");
-            GL.GetTextureImage(Texture2DTarget.Texture2D, 0, ImageChannel.WithAlphaChannel, PixelChannelLayout.Byte,
-                               i.PixelBuffer);
+            GL.GetTextureImage(Texture2DTarget.Texture2D, 0, ImageChannel.WithAlphaChannel,
+                               PixelChannelLayout.Byte, i.PixelBuffer);
             /*
             for (int num = 0; num < i.PixelBuffer.Length; num+=10000)
             {
@@ -189,12 +192,19 @@ namespace StgSharp
             GL.Assert(false);
         }
 
-        public void RenderButton(ButtonStatus status, float statusBegin, in TextureProvider provider)
+        public void RenderButton(
+                    ButtonStatus status,
+                    float statusBegin,
+                    in TextureProvider provider
+        )
         {
             provider.UpdateFromImage(i);
         }
 
-        internal static Vec3 DefaultRotation(TimeSpanProvider provider, out float rotation)
+        internal static Vec3 DefaultRotation(
+                             TimeSpanProvider provider,
+                             out float rotation
+        )
         {
             rotation = 1.0f / 60;
             float angle = (float)provider.CurrentSecond * 2;
@@ -261,7 +271,8 @@ namespace StgSharp
             ebo = CreateElementBuffer(1);
             vbo.Bind(0);
 
-            Rectangle rec = new Rectangle(0.05f, 0.05f, 0.05f, -0.05f, -0.05f, -0.05f, -0.05f, 0.05f);
+            Rectangle rec = new Rectangle(0.05f, 0.05f, 0.05f, -0.05f, -0.05f, -0.05f, -0.05f,
+                                          0.05f);
 
             // GL.Assert(true);
             vao.Bind(0);
@@ -271,7 +282,8 @@ namespace StgSharp
 
             vbo.WriteVectorData<Vec4>(1, buffer.CoordAndRotationSpan, BufferUsage.StreamDraw);
             vao.SetVertexAttribute(1, 3, TypeCode.Single, false, 4 * sizeof(float), 0);
-            vao.SetVertexAttribute(2, 1, TypeCode.Single, false, 4 * sizeof(float), 3 * sizeof(float));
+            vao.SetVertexAttribute(2, 1, TypeCode.Single, false, 4 * sizeof(float),
+                                   3 * sizeof(float));
 
             GL.VertexAttributeDivisor(1, 1);
             GL.VertexAttributeDivisor(2, 1);
@@ -310,13 +322,15 @@ namespace StgSharp
             // GL.Assert(true);
             t = CreateTexture(1);
             t.Bind2D(0);
-            GL.TextureImage2d<byte>(Texture2DTarget.Texture2D, 0, ImageChannel.WithAlphaChannel, (uint)Width,
-                                    (uint)Height, ImageChannel.WithAlphaChannel, PixelChannelLayout.Byte, null!);
+            GL.TextureImage2d<byte>(Texture2DTarget.Texture2D, 0, ImageChannel.WithAlphaChannel,
+                                    Width, Height, ImageChannel.WithAlphaChannel,
+                                    PixelChannelLayout.Byte, null!);
             t.Set2dWrapProperty(0, TextureWrap.Repeat, TextureWrap.Repeat);
             t.Set2dFilterProperty(0, TextureFilter.Linear, TextureFilter.Linear);
 
             // GL.Assert(true);
-            GL.FrameBufferTexture2d(FrameBufferTarget.All, glAttachment.Color(0), Texture2DTarget.Texture2D, t[0], 0);
+            GL.FrameBufferTexture2d(FrameBufferTarget.All, glAttachment.Color(0),
+                                    Texture2DTarget.Texture2D, t[0], 0);
 
             GL.SetRenderBufferStorage(RenderBufferInternalFormat.Depth24_Stencil8, this.Size);
             GL.CombineFrameBufferRenderBuffer(FrameBufferAttachment.DepthAndStencil, rbo[0]);
@@ -367,8 +381,10 @@ namespace StgSharp
             // GL.Assert(true);
 
             autoT = CreateAutoTexture(4);
-            autoT.DefaultTextureProperty = new TextureProperty(TextureFilter.Nearest, TextureFilter.Nearest,
-                                                               TextureWrap.Repeat, TextureWrap.Repeat);
+            autoT.DefaultTextureProperty = new TextureProperty(TextureFilter.Nearest,
+                                                               TextureFilter.Nearest,
+                                                               TextureWrap.Repeat,
+                                                               TextureWrap.Repeat);
 
             f_t = CreateTexture(1);
             f_t.Bind2D(0);