daily update on 20241129 by nitload youmu, frameworkDialogue added

内核源代码/StgSharp/Graphics/CPUanimation/IImageProvider.cs

@@ -0,0 +1,43 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="IImageProvider.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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.Text;
+
+namespace StgSharp.Graphics
+{
+    public interface IImageProvider
+    {
+
+        Image ProvideImage();
+
+    }
+}

内核源代码/StgSharp/Graphics/CPUanimation/ImageHelper.cs

@@ -0,0 +1,89 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="ImageHelper.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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.ComponentModel;
+using System.Text;
+
+namespace StgSharp.Graphics
+{
+    public static class ImageHelper
+    {
+
+        public static void Resize(
+            Image i,
+            int width,
+            int height,
+            ImageMovement move )
+        {
+            if( i == null ) {
+                throw new ArgumentNullException( nameof( i ) );
+            }
+            if( i.Size == (width, height) ) {
+                return;
+            }
+            if( !Enum.IsDefined( typeof( ImageMovement ), move ) ) {
+                throw new InvalidEnumArgumentException( nameof( move ) );
+            }
+            byte[] oldData = i.Data;
+            i.Data = new byte[width * height * i.PixelSize];
+            i.Height = height;
+            i.Width = width;
+            i.PixelUpdateCount++;
+            switch( move ) {
+                case ImageMovement.Discard:
+                    break;
+                case ImageMovement.Top:
+                    break;
+                default:
+                    throw new NotImplementedException();
+            }
+        }
+
+    }
+
+    [Flags]
+    public enum ImageMovement
+    {
+#pragma warning disable CA1008 
+        Discard = 0,
+        #pragma warning restore CA1008 
+        Top = 1,
+        Bottom = 2,
+        Left = 4,
+        Right = 8,
+        TopLeft = Top | Left,
+        BottomLeft = Bottom | Left,
+        TopRight = Top | Right,
+        BottomRight = Bottom | Right,
+
+    }
+}

内核源代码/StgSharp/Graphics/Define/BufferObjectBase.cs

@@ -0,0 +1,83 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="BufferObjectBase.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Graphics
+{
+    /// <summary>
+    /// Interface of all kinds OpenGL buffer objects
+    /// </summary>
+    public abstract class BufferObjectBase : IDisposable
+    {
+
+        protected GlHandle[] _bufferHandle;
+        protected RenderStream binding;
+
+        /// <summary>
+        /// Get the only handle to one of the Object instance
+        /// </summary>
+        /// <param name="index"></param>
+        /// <returns></returns>
+        public GlHandle this[ int index ] => _bufferHandle[ index ];
+
+        /// <summary>
+        /// Bind a buffer instance to OpenGL
+        /// </summary>
+        /// <param name="index"> Index of handle of the object in this instance to be bind </param>
+        public abstract void Bind( int index );
+
+        public void Dispose()
+        {
+            Dispose( disposing: true );
+            GC.SuppressFinalize( this );
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"This is a {GetType().FullName}, containing {_bufferHandle.Length} buffer handles: {_bufferHandle.ToString()}.";
+        }
+
+        protected abstract void Dispose( bool disposing );
+
+        ~BufferObjectBase()
+        {
+            Dispose( disposing: false );
+        }
+
+    }
+}

内核源代码/StgSharp/Graphics/Define/StructDefine.cs

@@ -0,0 +1,959 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="StructDefine.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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.InteropServices;
+
+/**/
+
+namespace StgSharp.Graphics
+{
+    //rename types in style of GLFW
+
+    using GLFWbool = Boolean;
+
+    //strucs defined in GLFW3.h
+
+    #region GLFW3 struct
+
+    [StructLayout( LayoutKind.Sequential )]
+    public unsafe struct GLFWcontext
+    {
+
+        private delegate*<byte*> extensionSupported;
+        private delegate*<delegate*<void>, void> getProcAddress;
+
+        /*
+        void (* makeCurrent) (glfwWindow*);
+        void (* swapBuffers) (glfwWindow*);
+        void (* swapInterval) (int);
+        int (* extensionSupported) (const byte*);
+        GLFWglproc(*getProcAddress)(const byte*);
+        void (* destroy) (glfwWindow*);
+        */
+
+        private delegate*<glfwWindow*> makeCurrent;
+        private delegate*<glfwWindow*> swapBuffer;
+        private delegate*<int> swapInterval;
+        private GLFWbool forward, debug, noerror;
+
+        private int client;
+        private int major, minor, revision;
+        private int profile;
+        private int release;
+        private int robustness;
+        private int source;
+        private IntPtr destroy;
+
+        //PFNGLGETINTEGERVPROC GetIntegerv;
+        private IntPtr GetIntegerv;
+
+        //PFNGLGETSTRINGPROC GetString;
+        private IntPtr GetString;
+
+        //PFNGLGETSTRINGIPROC GetStringi;
+        private IntPtr GetStringi;
+
+        internal struct egl
+        {
+
+            private void* client;
+
+            /*
+        EGLConfig config;
+        EGLContext handle;
+        EGLSurface surface;
+        */
+            private void* config;
+            private void* handle;
+            private void* surface;
+
+        }
+
+        internal struct osmesa
+        {
+
+            private void* buffer;
+
+            //OSMesaContext handle;
+            private void* handle;
+            private int height;
+
+            private int width;
+
+        }
+
+        // This is defined in platform.h
+        //GLFW_PLATFORM_CONTEXT_STATE
+    }
+
+    [StructLayout( LayoutKind.Sequential )]
+    public unsafe struct glfwVideomode
+    {
+        /*! The refresh rate, in Hz, of the video mode.
+         */
+
+        private int refreshRate;
+        /*! The bit depth of the blue channel of the video mode.
+         */
+        public int blueBits;
+        /*! The bit depth of the green channel of the video mode.
+         */
+        public int greenBits;
+        /*! The height, in screen coordinates, of the video mode.
+         */
+        public int height;
+        /*! The bit depth of the red channel of the video mode.
+         */
+        public int redBits;
+
+        /*! The width, in screen coordinates, of the video mode.
+         */
+        public int width;
+
+    }
+
+    [StructLayout( LayoutKind.Sequential )]
+    public unsafe struct glfwGammaramp
+    {
+        /*! An array of value describing the response of the blue channel.
+         */
+
+        private ushort* blue;
+        /*! An array of value describing the response of the green channel.
+         */
+        private ushort* green;
+
+        /*! An array of value describing the response of the red channel.
+         */
+        private ushort* red;
+        /*! The number of elements in each array.
+         */
+        private uint size;
+
+    }
+
+    [StructLayout( LayoutKind.Sequential )]
+    public unsafe struct GLFWimage
+    {
+        /*! The pixel _data of this image, arranged left-to-right, top-to-bottom.
+         */
+
+        private byte* pixels;
+
+        /*! The height, in pixels, of this image.
+         */
+        private int height;
+        /*! The width, in pixels, of this image.
+         */
+        private int width;
+
+    }
+
+    [StructLayout( LayoutKind.Sequential )]
+    public unsafe struct GLFWgamepadstate
+    {
+        /*! The states of each [gamepad button](@ref gamepad_buttons), `GLFW_PRESS`
+         *  or `GLFW_RELEASE`.
+         */
+
+        public fixed byte buttons[ 15 ];
+
+        /*! The states of each [gamepad axis](@ref gamepad_axes), in the range -1.0
+         *  to 1.0 inclusive.
+         */
+        public fixed float axes[ 6 ];
+
+    }
+
+    [StructLayout( LayoutKind.Sequential )]
+    public unsafe struct GLFWallocator
+    {
+
+        private void* user;
+
+        //GLFWallocatefun allocate;
+        private IntPtr allocate;
+
+        //GLFWdeallocatefun deallocate;
+        private IntPtr deallocate;
+
+        //GLFWreallocatefun reallocate;
+        private IntPtr reallocate;
+
+    }
+
+    [StructLayout( LayoutKind.Sequential )]
+    public unsafe struct glfwMonitor
+    {
+
+        private glfwVideomode* modes;
+
+        private glfwWindow* window;
+
+        private fixed byte name[ 128 ];
+        private glfwGammaramp currentRamp;
+
+        private glfwGammaramp originalRamp;
+        private glfwVideomode currentMode;
+        private int modeCount;
+
+        private int width, height;
+        private IntPtr userPointer;
+
+        public glfwMonitor() { }
+
+        public unsafe string Name
+        {
+            get
+            {
+                fixed( byte* cptr = name ) {
+                    return Marshal.PtrToStringAnsi( ( IntPtr )cptr );
+                }
+            }
+        }
+
+    }
+
+    [StructLayout( LayoutKind.Sequential )]
+    internal unsafe struct glfwWindow
+    {
+
+        private glfwWindow* next;
+        private void* userPointer;
+        private bool rawMouseMotion;
+        private Callbacks callbacks;
+
+        // Virtual cursor position when cursor is disabled
+        private double virtualCursorPosX, virtualCursorPosY;
+        private int autoIconify;
+        private int cursorMode;
+        private int decorated;
+        private int doublebuffer;
+        private int floating;
+        private int focusOnShow;
+        private int lockKeyMods;
+        private int maxwidth, maxheight;
+
+        private int minwidth, minheight;
+        private int mousePassthrough;
+        private int numer, denom;
+
+        // Window settings and state
+        private int resizable;
+        private int shouldClose;
+
+        private int stickyKeys;
+        private int stickyMouseButtons;
+        private IntPtr cursor; // _GLFWcursor* cursor;
+        // glfwVideomode videoMode; // 根据GLFWvidmode的定义转换
+        private IntPtr monitor; // _GLFWmonitor* monitor;
+        public fixed byte keys[ GLconst.GLFW_KEY_LAST + 1 ];
+        public fixed byte mouseButtons[ GLconst.GLFW_MOUSE_BUTTON_LAST + 1 ];
+
+        // _GLFWcontext viewPortDisplay; // 根据_GLFWcontext的定义转换
+
+        // Callbacks are represented as IntPtr since we don't need the actual function pointers in C#
+        internal struct Callbacks
+        {
+
+            internal IntPtr character;
+            internal IntPtr charmods;
+            internal IntPtr close;
+            internal IntPtr cursorEnter;
+            internal IntPtr cursorPos;
+            internal IntPtr drop;
+            internal IntPtr fbsize;
+            internal IntPtr focus;
+            internal IntPtr iconify;
+            internal IntPtr key;
+            internal IntPtr maximize;
+            internal IntPtr mouseButton;
+            internal IntPtr pos;
+            internal IntPtr refresh;
+            internal IntPtr scale;
+            internal IntPtr scroll;
+            internal IntPtr size;
+
+        }
+
+        // GLFW_PLATFORM_WINDOW_STATE platformWindowState; 
+    }
+
+    [StructLayout( LayoutKind.Sequential )]
+    public struct GLFWwindowCallback { }
+
+    [StructLayout( LayoutKind.Sequential )]
+    public struct GLFWcursor
+    {
+
+        //GLFWcursor* next;
+        private IntPtr next;
+
+        // This is defined in platform.h
+        // not completed in tranformation
+        // GLFW_PLATFORM_CURSOR_STATE;
+    }
+
+    /*
+    [StructLayout(LayoutKind.Sequential)]
+    public unsafe struct GLFWerror
+    {
+        //GLFWerror* next;
+        IntPtr next;
+        int code;
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = (int)GLconst.GLFW_MESSAGE_SIZE)]
+        byte[] description = new byte[GLconst.GLFW_MESSAGE_SIZE];
+
+        public GLFWerror()
+        {
+        }
+    }
+    */
+
+    [StructLayout( LayoutKind.Sequential )]
+    public unsafe struct GLFWinitconfig
+    {
+
+        private GLFWbool hatButtons;
+
+        private int angleType;
+        private int platformID;
+
+        //PFN_vkGetInstanceProcAddr vulkanLoader;
+        private IntPtr vulkanLoader;
+
+    }
+
+    [StructLayout( LayoutKind.Sequential )]
+    public unsafe struct GLFWwndconfig
+    {
+
+        private byte* title;
+
+        private GLFWbool autoIconify;
+        private GLFWbool centerCursor;
+        private GLFWbool decorated;
+        private GLFWbool floating;
+        private GLFWbool focused;
+        private GLFWbool focusOnShow;
+        private GLFWbool maximized;
+        private GLFWbool mousePassthrough;
+        private GLFWbool resizable;
+        private GLFWbool scaleToMonitor;
+        private GLFWbool visible;
+        private int height;
+        private int width;
+
+        private int xpos;
+        private int ypos;
+
+        internal Ns ns = new Ns();
+
+        internal Win32 win32 = new Win32();
+
+        internal Wl wl = new Wl();
+
+        internal X11 x11 = new X11();
+
+        public GLFWwndconfig() { }
+
+        internal struct Ns
+        {
+
+            private GLFWbool retina = false;
+            public fixed byte frameName[ 256 ];
+
+            public Ns() { }
+
+        }
+
+        internal struct X11
+        {
+
+            public fixed byte className[ 256 ];
+            public fixed byte instanceName[ 256 ];
+
+            public X11() { }
+
+        }
+
+        internal struct Win32
+        {
+
+            private GLFWbool keymenu;
+
+        }
+
+        internal struct Wl
+        {
+
+            public fixed byte appId[ 256 ];
+
+            public Wl() { }
+
+        }
+
+    }
+
+    [StructLayout( LayoutKind.Sequential )]
+    public unsafe struct GLFWctxconfig
+    {
+
+        private GLFWbool debug;
+        private GLFWbool forward;
+        private GLFWbool noerror;
+
+        private int client;
+        private int major;
+        private int minor;
+        private int profile;
+        private int release;
+        private int robustness;
+        private int source;
+
+        //glfwWindow* share;
+        private IntPtr share;
+
+        internal Nsgl nsgl = new Nsgl();
+
+        public GLFWctxconfig() { }
+
+        internal struct Nsgl
+        {
+
+            private GLFWbool offline;
+
+        }
+
+    }
+
+    [StructLayout( LayoutKind.Sequential )]
+    public unsafe struct GLFWfbconfig
+    {
+
+        private GLFWbool doublebuffer;
+        private GLFWbool sRGB;
+        private GLFWbool stereo;
+        private GLFWbool transparent;
+
+        private int accumAlphaBits;
+        private int accumBlueBits;
+        private int accumGreenBits;
+        private int accumRedBits;
+        private int alphaBits;
+        private int auxBuffers;
+        private int blueBits;
+        private int depthBits;
+        private int greenBits;
+
+        private int redBits;
+        private int samples;
+        private int stencilBits;
+        private uintptr_t handle;
+
+    }
+
+    [StructLayout( LayoutKind.Sequential )]
+    internal unsafe struct GLFWlibrary
+    {
+
+        [MarshalAs(
+            UnmanagedType.ByValArray,
+            SizeConst = GLconst.GLFW_JOYSTICK_LAST + 1 )]
+        private GLFWjoystick[] joysticks = new GLFWjoystick[GLconst.GLFW_JOYSTICK_LAST + 1];
+
+        private GLFWallocator allocator;
+
+        private GLFWbool initialized;
+
+        private GLFWbool joysticksInitialized;
+        private GLFWls contextSlot;
+
+        private GLFWls errorSlot;
+        private GLFWmutex errorLock;
+
+        private GLFWplatform platform;
+
+        private int mappingCount;
+
+        private int monitorCount;
+
+        //GLFWcursor* cursorListHead;
+        private IntPtr cursorListHead;
+
+        //GLFWerror* errorListHead;
+        private IntPtr errorListHead;
+
+        //GLFWmapping* mappings;
+        private IntPtr mappings;
+
+        //GLFWmonitor** monitors;
+        private IntPtr monitors;
+
+        //glfwWindow* windowListHead;
+        private IntPtr windowListHead;
+
+        internal Callbacks callbacks = new Callbacks();
+
+        internal Egl egl = new Egl();
+
+        internal Hints hints = new Hints();
+
+        internal Osmesa osmesa = new Osmesa();
+
+        public GLFWlibrary() { }
+
+        internal unsafe struct Hints
+        {
+
+            private GLFWctxconfig context;
+            private GLFWfbconfig framebuffer;
+
+            private GLFWinitconfig init;
+            private GLFWwndconfig window;
+            private int refreshRate;
+
+        }
+
+        internal unsafe struct timer
+        {
+
+            private ulong offset;
+
+            // This is defined in platform.h
+
+            //not transformed function defination
+            //GLFW_PLATFORM_LIBRARY_TIMER_STATE
+        }
+
+        internal unsafe struct Egl
+        {
+
+            internal void* display;
+
+            internal void* handle;
+
+            internal bool ANGLE_platform_angle;
+            internal bool ANGLE_platform_angle_d3d;
+            internal bool ANGLE_platform_angle_metal;
+            internal bool ANGLE_platform_angle_opengl;
+            internal bool ANGLE_platform_angle_vulkan;
+            internal bool EXT_client_extensions;
+            internal bool EXT_platform_base;
+            internal bool EXT_platform_wayland;
+            internal bool EXT_platform_x11;
+            internal bool EXT_present_opaque;
+            internal bool KHR_colorSpace;
+            internal bool KHR_context_flush_control;
+
+            internal bool KHR_create_context;
+            internal bool KHR_create_context_no_error;
+            internal bool KHR_get_all_proc_addresses;
+            internal bool prefix;
+            internal int major, minor;
+
+            internal int platform;
+            internal IntPtr BindAPI;
+            internal IntPtr CreateContext;
+            internal IntPtr CreatePlatformWindowSurfaceEXT;
+            internal IntPtr CreateWindowSurface;
+            internal IntPtr DestroyContext;
+            internal IntPtr DestroySurface;
+
+            internal IntPtr GetConfigAttrib;
+            internal IntPtr GetConfigs;
+            internal IntPtr GetDisplay;
+            internal IntPtr GetError;
+
+            internal IntPtr GetPlatformDisplayEXT;
+            internal IntPtr GetProcAddress;
+            internal IntPtr Initialize;
+            internal IntPtr MakeCurrent;
+            internal IntPtr QueryString;
+            internal IntPtr SwapBuffers;
+            internal IntPtr SwapInterval;
+            internal IntPtr Terminate;
+
+        }
+
+        internal unsafe struct Osmesa
+        {
+
+            private void* handle;
+
+            private IntPtr CreateContextAttribs;
+
+            private IntPtr CreateContextExt;
+            private IntPtr DestroyContext;
+            private IntPtr GetColorBuffer;
+            private IntPtr GetDepthBuffer;
+            private IntPtr GetProcAddress;
+            private IntPtr MakeCurrent;
+
+        }
+
+        internal unsafe struct vk
+        {
+
+            private void* handle;
+
+            private GLFWbool available;
+            private GLFWbool EXT_metal_surface;
+            private GLFWbool KHR_surface;
+            private GLFWbool KHR_wayland_surface;
+            private GLFWbool KHR_win32_surface;
+            private GLFWbool KHR_xcb_surface;
+            private GLFWbool KHR_xlib_surface;
+            private GLFWbool MVK_macos_surface;
+            private IntPtr GetInstanceProcAddr;
+            private fixed ulong extensions[ 2 ];
+
+            public vk() { }
+
+        }
+
+        internal unsafe struct Callbacks
+        {
+
+            private IntPtr joystick;
+
+            private IntPtr monitor;
+
+        }
+
+    }
+
+    [StructLayout( LayoutKind.Sequential )]
+    public unsafe struct GLFWmapelement
+    {
+
+        private byte index;
+
+        private byte type;
+
+        private sbyte axisOffset;
+        private sbyte axisScale;
+
+    }
+
+    [StructLayout( LayoutKind.Sequential )]
+    public unsafe struct GLFWmapping
+    {
+
+        [MarshalAs( UnmanagedType.ByValArray, SizeConst = 6 )]
+        private GLFWmapelement[] axes = new GLFWmapelement[6];
+
+        [MarshalAs( UnmanagedType.ByValArray, SizeConst = 15 )]
+        private GLFWmapelement[] buttons = new GLFWmapelement[15];
+        private fixed byte guid[ 33 ];
+
+        private fixed byte name[ 128 ];
+
+        public GLFWmapping() { }
+
+    }
+
+    [StructLayout( LayoutKind.Sequential )]
+    public unsafe struct GLFWjoystick
+    {
+
+        private float* axes;
+        private byte* buttons;
+        private byte* hats;
+        private void* userPointer;
+        private fixed byte guid[ 33 ];
+        private fixed byte name[ 128 ];
+
+        private GLFWbool allocated;
+        private GLFWbool connected;
+        private int axisCount;
+        private int buttonCount;
+        private int hatCount;
+
+        //GLFWmapping* mapping;
+        private IntPtr mapping;
+
+        // This is defined in platform.h
+        // not completed in transforming
+        // GLFW_PLATFORM_JOYSTICK_STATE;
+
+        public GLFWjoystick() { }
+
+    }
+
+    [StructLayout( LayoutKind.Sequential )]
+    public unsafe struct GLFWls
+    {
+
+        // This is defined in platform.h
+
+        //GLFW_PLATFORM_TLS_STATE
+    }
+
+    [StructLayout( LayoutKind.Sequential )]
+    public unsafe struct GLFWplatform
+    {
+
+        private int platformID;
+
+        // init
+        //GLFWbool(*init)(void);
+        private IntPtr init;
+
+        //void (* terminate) (void);
+        private IntPtr terminate;
+        internal IntPtr createCursor;
+        internal IntPtr createStandardCursor;
+
+        // window
+        internal IntPtr createWindow;
+        internal IntPtr destroyCursor;
+
+        internal IntPtr destroyWindow;
+        internal IntPtr focusWindow;
+        internal IntPtr framebufferTransparent;
+
+        // monitor
+        internal IntPtr freeMonitor;
+        internal IntPtr getClipboardString;
+
+        internal IntPtr getEGLNativeDisplay;
+        internal IntPtr getEGLNativeWindow;
+
+        // EGL
+        //EGLenum(*getEGLPlatform)(EGLint**);
+        //EGLNativeDisplayType(*getEGLNativeDisplay)(void);
+        //EGLNativeWindowType(*getEGLNativeWindow)(glfwWindow*);
+        internal IntPtr getEGLPlatform;
+        internal IntPtr getFramebufferSize;
+        internal IntPtr getGammaRamp;
+        internal IntPtr getKeyScancode;
+        internal IntPtr getMappingName;
+        internal IntPtr getMonitorContentScale;
+
+        internal IntPtr getMonitorPos;
+        internal IntPtr getMonitorWorkarea;
+
+        // vulkan
+        //void (* getRequiredInstanceExtensions) (byte**);
+        //GLFWbool(*getPhysicalDevicePresentationSupport)(VkInstance, VkPhysicalDevice, uint32_t);
+        //VkResult(*createWindowSurface)(VkInstance, glfwWindow*,const VkAllocationCallbacks*, VkSurfaceKHR*);
+        internal IntPtr getRequiredInstanceExtensions;
+        internal IntPtr getScancodeName;
+        internal IntPtr getVideoMode;
+        internal IntPtr getVideoModes;
+        internal IntPtr getWindowContentScale;
+        internal IntPtr getWindowFrameSize;
+        internal IntPtr getWindowOpacity;
+        internal IntPtr getWindowPos;
+        internal IntPtr getWindowSize;
+        internal IntPtr GLFWwindow;
+        internal IntPtr hideWindow;
+        internal IntPtr iconifyWindow;
+        internal IntPtr initJoysticks;
+        internal IntPtr maximizeWindow;
+        internal IntPtr pollEvents;
+        internal IntPtr pollJoystick;
+        internal IntPtr postEmptyEvent;
+        internal IntPtr rawMouseMotionSupported;
+        internal IntPtr requestWindowAttention;
+        internal IntPtr restoreWindow;
+        internal IntPtr setClipboardString;
+        internal IntPtr setCursor;
+        internal IntPtr setCursorMode;
+
+        #region input
+
+        /* void (* getCursorPos) (glfwWindow*, double*, double*);
+        void (* setCursorPos) (glfwWindow*, double, double);
+        void (* setCursorMode) (glfwWindow*, int);
+        void (* setRawMouseMotion) (glfwWindow*, GLFWbool);
+        GLFWbool(*rawMouseMotionSupported)(void);
+        GLFWbool(*createCursor)(GLFWcursor*,const GLFWimage*,int,int);
+        GLFWbool(*createStandardCursor)(GLFWcursor*, int);
+        void (* destroyCursor) (GLFWcursor*);
+        void (* setCursor) (glfwWindow*, GLFWcursor*);
+        const byte* (*getScancodeName)(int);
+        int (* getKeyScancode) (int);
+        void (* setClipboardString) (const byte*);
+            const byte* (*getClipboardString)(void);
+        GLFWbool(*initJoysticks)(void);
+        void (* terminateJoysticks) (void);
+        GLFWbool(*pollJoystick)(GLFWjoystick*, int);
+        const byte* (*getMappingName)(void);
+        void (* updateGamepadGUID) (byte*);
+        // monitor
+        void (* freeMonitor) (GLFWmonitor*);
+        void (* getMonitorPos) (GLFWmonitor*, int*, int*);
+        void (* getMonitorContentScale) (GLFWmonitor*, float*, float*);
+        void (* getMonitorWorkarea) (GLFWmonitor*, int*, int*, int*, int*);
+        glfwVideomode* (* getVideoModes) (GLFWmonitor*, int*);
+        void (* getVideoMode) (GLFWmonitor*, glfwVideomode*);
+        GLFWbool(*getGammaRamp)(GLFWmonitor*, glfwGammaramp*);
+        void (* setGammaRamp) (GLFWmonitor*,const glfwGammaramp*);
+        // window
+        GLFWbool(*createWindow)(glfwWindow*,const GLFWwndconfig*,const GLFWctxconfig*,const GLFWfbconfig*);
+        void (* destroyWindow) (glfwWindow*);
+        void (* setWindowTitle) (glfwWindow*,const byte*);
+        void (* setWindowIcon) (glfwWindow*, int,const GLFWimage*);
+        void (* getWindowPos) (glfwWindow*, int*, int*);
+        void (* setWindowPos) (glfwWindow*, int, int);
+        void (* getWindowSize) (glfwWindow*, int*, int*);
+        void (* setWindowSize) (glfwWindow*, int, int);
+        void (* setWindowSizeLimits) (glfwWindow*, int, int, int, int);
+        void (* setWindowAspectRatio) (glfwWindow*, int, int);
+        void (* getFramebufferSize) (glfwWindow*, int*, int*);
+        void (* getWindowFrameSize) (glfwWindow*, int*, int*, int*, int*);
+        void (* getWindowContentScale) (glfwWindow*, float*, float*);
+        void (* iconifyWindow) (glfwWindow*);
+        void (* restoreWindow) (glfwWindow*);
+        void (* maximizeWindow) (glfwWindow*);
+        void (* showWindow) (glfwWindow*);
+        void (* hideWindow) (glfwWindow*);
+        void (* requestWindowAttention) (glfwWindow*);
+        void (* focusWindow) (glfwWindow*);
+        void (* setWindowMonitor) (glfwWindow*, GLFWmonitor*, int, int, int, int, int);
+        GLFWbool(*windowFocused)(glfwWindow*);
+        GLFWbool(*windowIconified)(glfwWindow*);
+        GLFWbool(*windowVisible)(glfwWindow*);
+        GLFWbool(*windowMaximized)(glfwWindow*);
+        GLFWbool(*windowHovered)(glfwWindow*);
+        GLFWbool(*framebufferTransparent)(glfwWindow*);
+        float (* getWindowOpacity) (glfwWindow*);
+        void (* setWindowResizable) (glfwWindow*, GLFWbool);
+        void (* setWindowDecorated) (glfwWindow*, GLFWbool);
+        void (* setWindowFloating) (glfwWindow*, GLFWbool);
+        void (* setWindowOpacity) (glfwWindow*, float);
+        void (* setWindowMousePassthrough) (glfwWindow*, GLFWbool);
+        void (* pollEvents) (void);
+        void (* waitEvents) (void);
+        void (* waitEventsTimeout) (double);
+        void (* postEmptyEvent) (void);
+        */
+
+        #endregion
+
+        internal IntPtr setCursorPos;
+        internal IntPtr setGammaRamp;
+        internal IntPtr setRawMouseMotion;
+        internal IntPtr setWindowAspectRatio;
+        internal IntPtr setWindowDecorated;
+        internal IntPtr setWindowFloating;
+        internal IntPtr setWindowIcon;
+        internal IntPtr setWindowMonitor;
+        internal IntPtr setWindowMousePassthrough;
+        internal IntPtr setWindowOpacity;
+        internal IntPtr setWindowPos;
+        internal IntPtr setWindowResizable;
+        internal IntPtr setWindowSize;
+        internal IntPtr setWindowSizeLimits;
+        internal IntPtr setWindowTitle;
+        internal IntPtr showWindow;
+        internal IntPtr terminateJoysticks;
+        internal IntPtr updateGamepadGUID;
+
+        internal IntPtr VkPhysicalDevice;
+        internal IntPtr waitEvents;
+        internal IntPtr waitEventsTimeout;
+        internal IntPtr windowFocused;
+        internal IntPtr windowHovered;
+        internal IntPtr windowIconified;
+        internal IntPtr windowMaximized;
+        internal IntPtr windowVisible;
+
+    }
+
+    [StructLayout( LayoutKind.Sequential )]
+    public unsafe struct GLFWmutex
+    {
+
+        // This is defined in platform.h
+        //GLFW_PLATFORM_MUTEX_STATE
+    }
+
+    //public unsafe struct VkAllocationCallbacks { }
+
+    [StructLayout( LayoutKind.Sequential )]
+    internal unsafe struct VkExtensionProperties
+    {
+
+        private fixed byte extensionName[ 256 ];
+        private uint specVersion;
+
+        public VkExtensionProperties() { }
+
+    }
+
+    /*
+    [StructLayout(LayoutKind.Sequential)]
+    internal unsafe struct GLFWerror
+    {
+        IntPtr next;
+        int code;
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1024)]
+        byte[] description = new byte[1024];
+
+        public GLFWerror()
+        {
+        }
+    }
+    */
+
+    [StructLayout( LayoutKind.Explicit, Size = 16 )]
+    public struct uintptr_t
+    {
+
+        [FieldOffset( 0 )]
+        private long part1;
+
+        [FieldOffset( 8 )]
+        private long part2;
+
+    }
+
+    #endregion GLFW3 struct
+
+    #region glad struct
+
+    [StructLayout( LayoutKind.Sequential )]
+    internal struct GLsync
+    {
+
+        public IntPtr Handle;
+
+    }
+
+    #endregion glad struct
+}
+
+/**/

内核源代码/StgSharp/Graphics/Define/glApiDefine.cs

@@ -0,0 +1,97 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="glApiDefine.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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.Math;
+
+using System;
+using System.Numerics;
+using System.Runtime.InteropServices;
+
+namespace StgSharp.Graphics
+{
+    /// <summary>
+    /// Function handler to load an opengl function by searching its name.
+    /// </summary>
+    /// <param name="name"> the name of the Opengl function </param>
+    /// <returns> An Intptr value representing the pointer to the function </returns>
+    public delegate IntPtr glLoader( string name );
+
+    #region StgSharpDele
+
+    public unsafe delegate void FrameBufferSizeHandler(
+        IntPtr window,
+        int width,
+        int height );
+
+    public unsafe delegate void FramePositionHandler(
+        IntPtr window,
+        float width,
+        float height );
+
+    #endregion
+
+
+    #region glDEBUG
+
+    internal unsafe delegate void GLDEBUGPROC(
+        int source,
+        int type,
+        uint id,
+        int severity,
+        int length,
+        sbyte* message,
+        void* userParam );
+    internal unsafe delegate void GLDEBUGPROCARB(
+        int source,
+        int type,
+        uint id,
+        int severity,
+        int length,
+        sbyte* message,
+        void* userParam );
+    internal unsafe delegate void GLDEBUGPROCKHR(
+        int source,
+        int type,
+        uint id,
+        int severity,
+        int length,
+        sbyte* message,
+        void* userParam );
+    internal unsafe delegate void GLDEBUGPROCAMD(
+        uint id,
+        int category,
+        int severity,
+        int length,
+        sbyte* message,
+        void* userParam );
+
+#endregion
+
+}

内核源代码/StgSharp/Graphics/Define/glEnum.cs

@@ -0,0 +1,258 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="glEnum.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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.Runtime.CompilerServices;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public enum PixelChannelLayout
+    {
+
+        UByte = GLconst.UNSIGNED_BYTE,
+        Byte = GLconst.BYTE,
+        UShort = GLconst.UNSIGNED_SHORT,
+        Short = GLconst.SHORT,
+        UInt = GLconst.UNSIGNED_INT,
+        Int = GLconst.INT,
+        Float = GLconst.FLOAT,
+        UByte332 = GLconst.UNSIGNED_BYTE_3_3_2,
+        UByte233Rev = GLconst.UNSIGNED_BYTE_2_3_3_REV,
+        UShort565 = GLconst.UNSIGNED_SHORT_5_6_5,
+        UShort565Rev = GLconst.UNSIGNED_SHORT_5_6_5_REV,
+        UShort4444 = GLconst.UNSIGNED_SHORT_4_4_4_4,
+        UShort4444Rev = GLconst.UNSIGNED_SHORT_4_4_4_4_REV,
+        UShort5551 = GLconst.UNSIGNED_SHORT_5_5_5_1,
+        UShort1555Rev = GLconst.UNSIGNED_SHORT_1_5_5_5_REV,
+        UInt8888 = GLconst.UNSIGNED_INT_8_8_8_8,
+        UInt8888Rev = GLconst.UNSIGNED_INT_8_8_8_8_REV,
+        UInt1010102 = GLconst.UNSIGNED_INT_10_10_10_2,
+        UInt2101010Rev = GLconst.UNSIGNED_INT_2_10_10_10_REV
+
+    }
+
+    public enum FrameBufferStatus
+    {
+
+        Complete = GLconst.FRAMEBUFFER_COMPLETE, // GL_FRAMEBUFFER_COMPLETE
+        IncompleteAttachment = GLconst.FRAMEBUFFER_INCOMPLETE_ATTACHMENT, // GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT
+        IncompleteMissingAttachment = GLconst.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT, // GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT
+        IncompleteDrawBuffer = GLconst.FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER, // GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER
+        IncompleteReadBuffer = GLconst.FRAMEBUFFER_INCOMPLETE_READ_BUFFER, // GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER
+        Unsupported = GLconst.FRAMEBUFFER_UNSUPPORTED, // GL_FRAMEBUFFER_UNSUPPORTED
+        IncompleteMultisample = GLconst.FRAMEBUFFER_INCOMPLETE_MULTISAMPLE, // GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE
+        IncompleteLayerTargets = GLconst.FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS // GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS
+
+    }
+
+    internal enum VkStructureType : uint
+    {
+
+        VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000,
+        VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000,
+        VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000,
+        VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
+        VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000,
+        VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT = 1000217000,
+        VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
+
+    }
+
+    public enum FrameBufferChannel
+    {
+
+        STENCIL_INDEX = GLconst.STENCIL_INDEX,
+        DEPTH_COMPONENT = GLconst.DEPTH_COMPONENT,
+        DEPTH_STENCIL = GLconst.DEPTH_STENCIL,
+        RED = GLconst.RED,
+        GREEN = GLconst.GREEN,
+        BLUE = GLconst.BLUE,
+        RGB = GLconst.RGB,
+        BGR = GLconst.BGR,
+        RGBA = GLconst.RGBA,
+        BGRA = GLconst.BGRA
+
+    }
+
+    public enum FrameBufferAttachment
+    {
+
+        Color = GLconst.COLOR_ATTACHMENT0,
+        Depth = GLconst.DEPTH_ATTACHMENT,
+        Stencil = GLconst.STENCIL_ATTACHMENT,
+        DepthAndStencil = GLconst.DEPTH_STENCIL_ATTACHMENT,
+
+    }
+
+    public enum Texture2DTarget
+    {
+
+        Texture2D = GLconst.TEXTURE_2D,
+        ProxyTexture2D = GLconst.PROXY_TEXTURE_2D,
+        Texture1DArray = GLconst.TEXTURE_1D_ARRAY,
+        ProxyTexture1DArray = GLconst.PROXY_TEXTURE_1D_ARRAY,
+        TextureRectangle = GLconst.TEXTURE_RECTANGLE,
+        ProxyTextureRectangle = GLconst.PROXY_TEXTURE_RECTANGLE,
+        TextureCubeMapPositiveX = GLconst.TEXTURE_CUBE_MAP_POSITIVE_X,
+        TextureCubeMapNegativeX = GLconst.TEXTURE_CUBE_MAP_NEGATIVE_X,
+        TextureCubeMapPositiveY = GLconst.TEXTURE_CUBE_MAP_POSITIVE_Y,
+        TextureCubeMapNegativeY = GLconst.TEXTURE_CUBE_MAP_NEGATIVE_Y,
+        TextureCubeMapPositiveZ = GLconst.TEXTURE_CUBE_MAP_POSITIVE_Z,
+        TextureCubeMapNegativeZ = GLconst.TEXTURE_CUBE_MAP_NEGATIVE_Z,
+        ProxyTextureCubeMap = GLconst.PROXY_TEXTURE_CUBE_MAP
+
+    }
+
+    public enum RenderBufferInternalFormat : uint
+    {
+
+        RGBA8 = GLconst.RGBA8,
+        Depth24_Stencil8 = GLconst.DEPTH24_STENCIL8,
+
+    }
+
+    public enum GLOperation : uint
+    {
+
+        StencilTest = GLconst.STENCIL_TEST,
+
+    }
+
+    internal enum VkResult
+    {
+
+        VK_SUCCESS = 0,
+        VK_NOT_READY = 1,
+        VK_TIMEOUT = 2,
+        VK_EVENT_SET = 3,
+        VK_EVENT_RESET = 4,
+        VK_INCOMPLETE = 5,
+        VK_ERROR_OUT_OF_HOST_MEMORY = -1,
+        VK_ERROR_OUT_OF_DEVICE_MEMORY = -2,
+        VK_ERROR_INITIALIZATION_FAILED = -3,
+        VK_ERROR_DEVICE_LOST = -4,
+        VK_ERROR_MEMORY_MAP_FAILED = -5,
+        VK_ERROR_LAYER_NOT_PRESENT = -6,
+        VK_ERROR_EXTENSION_NOT_PRESENT = -7,
+        VK_ERROR_FEATURE_NOT_PRESENT = -8,
+        VK_ERROR_INCOMPATIBLE_DRIVER = -9,
+        VK_ERROR_TOO_MANY_OBJECTS = -10,
+        VK_ERROR_FORMAT_NOT_SUPPORTED = -11,
+        VK_ERROR_SURFACE_LOST_KHR = -1000000000,
+        VK_SUBOPTIMAL_KHR = 1000001003,
+        VK_ERROR_OUT_OF_DATE_KHR = -1000001004,
+        VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001,
+        VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001,
+        VK_ERROR_VALIDATION_FAILED_EXT = -1000011001,
+        VK_RESULT_MAX_ENUM = 0x7FFFFFFF
+
+    }
+
+    #pragma warning disable CA1008 
+    public enum ShaderType : int
+    #pragma warning restore CA1008 
+    {
+
+        Fragment = GLconst.FRAGMENT_SHADER,
+        Vertex = GLconst.VERTEX_SHADER,
+        Compute = GLconst.COMPUTE_SHADER,
+        Geometry = GLconst.GEOMETRY_SHADER,
+
+    }
+
+    #pragma warning disable CA1008 // 枚举应具有零值
+    public enum BufferType : int
+    #pragma warning restore CA1008 // 枚举应具有零值
+    {
+
+        ArrayBuffer = GLconst.ARRAY_BUFFER,
+        ElementArrayBuffer = GLconst.ELEMENT_ARRAY_BUFFER,
+        AtomicCounterBuffer = GLconst.ATOMIC_COUNTER_BUFFER,
+        COPY_READ_BUFFER = GLconst.COPY_READ_BUFFER,
+        COPY_WRITE_BUFFER = GLconst.COPY_WRITE_BUFFER,
+        DISPATCH_INDIRECT_BUFFER = GLconst.DISPATCH_INDIRECT_BUFFER,
+        DRAW_INDIRECT_BUFFER = GLconst.DRAW_INDIRECT_BUFFER,
+        PIXEL_PACK_BUFFER = GLconst.PIXEL_PACK_BUFFER,
+        PIXEL_UNPACK_BUFFER = GLconst.PIXEL_UNPACK_BUFFER,
+        QUERY_BUFFER = GLconst.QUERY_BUFFER,
+        SHADER_STORAGE_BUFFER = GLconst.SHADER_STORAGE_BUFFER,
+        TEXTURE_BUFFER = GLconst.TEXTURE_BUFFER,
+        TRANSFORM_FEEDBACK_BUFFER = GLconst.TRANSFORM_FEEDBACK_BUFFER,
+        UNIFORM_BUFFER = GLconst.UNIFORM_BUFFER,
+
+    }
+
+    #pragma warning disable CA1008 // 枚举应具有零值
+    public enum BufferUsage : int
+    #pragma warning restore CA1008 // 枚举应具有零值
+    {
+
+        StreamDraw = 0x88E0,
+        StreamRead = 0x88E1,
+        StreamCopy = 0x88E2,
+        StaticDraw = 0x88E4,
+        StaticRead = 0x88E5,
+        StaticCopy = 0x88E6,
+        DynamicDraw = 0x88E8,
+        DynamicRead = 0x88E9,
+        DynamicCopy = 0x88EA
+
+    }
+
+    public enum MaskBufferBit
+    {
+
+        COLOR = GLconst.COLOR_BUFFER_BIT,
+        DEPTH = GLconst.DEPTH_BUFFER_BIT,
+        STENCIL = GLconst.STENCIL_BUFFER_BIT,
+
+    }
+
+    public enum GeometryType : uint
+    {
+
+        POINTS = 0x0000,
+        LINES = 0x0001,
+        LINE_LOOP = 0x0002,
+        LINE_STRIP = 0x0003,
+        TRIANGLES = 0x0004,
+        TRIANGLE_STRIP = 0x0005,
+        TRIANGLE_FAN = 0x0006
+
+    }
+
+    public enum TextureFiltering
+    {
+
+        Nearest = 0x2600,
+        Linear = 0x2601
+
+    }
+}

内核源代码/StgSharp/Graphics/Define/glType.cs

@@ -0,0 +1,149 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="glType.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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.Geometries;
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace StgSharp.Graphics
+{
+    public delegate IntPtr GLfuncLoader( string name );
+
+    internal delegate void GLVULKANPROCNV();
+
+    public unsafe struct GLhandleARB
+    {
+
+        private dynamic value;
+
+        public unsafe GLhandleARB( dynamic value )
+        {
+            if( !RuntimeInformation.IsOSPlatform( OSPlatform.OSX ) ) {
+                if( value.GetType().Name != "Uint32" ) {
+                    goto errorlog;
+                }
+                this.value = value;
+            } else {
+                if( value.GetType().Name != "IntPtr" ) {
+                    goto errorlog;
+                }
+                this.value = value;
+            }
+
+            errorlog:
+            {
+                InternalIO.InternalWriteLog(
+                    $"{value.GetType().Name} does not match definination of GLhandlARB on OS {Environment.OSVersion.Platform} ",
+                    LogType.Error );
+            }
+        }
+
+        public static implicit operator uint( GLhandleARB value )
+        {
+            return ( uint )value;
+        }
+
+    }
+
+    #region GLFW_dele
+
+    internal unsafe delegate void GLFWwindowsizefun(
+        glfwWindow* window,
+        int width,
+        int height );
+    internal unsafe delegate void GLFWwindowrefreshfun( glfwWindow* window );
+    internal unsafe delegate void GLFWwindowposfun(
+        glfwWindow* window,
+        int xpos,
+        int ypos );
+    internal unsafe delegate void GLFWwindowmaximizefun(
+        glfwWindow* window,
+        int maximized );
+    internal unsafe delegate void GLFWwindowiconifyfun(
+        glfwWindow* window,
+        int iconified );
+    internal unsafe delegate void GLFWwindowfocusfun(
+        glfwWindow* window,
+        int focused );
+    internal unsafe delegate void GLFWwindowcontentscalefun(
+        glfwWindow* window,
+        float xscale,
+        float yscale );
+    internal unsafe delegate void GLFWwindowclosefun( glfwWindow* window );
+    internal unsafe delegate void GLFWvkproc();
+    internal unsafe delegate void GLFWscrollfun(
+        glfwWindow* window,
+        double xoffset,
+        double yoffset );
+    internal unsafe delegate void GLFWmousebuttonfun(
+        glfwWindow* window,
+        int button,
+        int action,
+        int mods );
+    internal unsafe delegate void GLFWmonitorfun(
+        glfwMonitor* monitor,
+        int monitorevent );
+    internal unsafe delegate void GLFWkeyfun(
+        glfwWindow* window,
+        int key,
+        int scancode,
+        int action,
+        int mods );
+    internal unsafe delegate void GLFWjoystickfun( int jid, int keyevent );
+    public unsafe delegate void GLFWglproc();
+    internal unsafe delegate void GLFWerrorfun(
+        int error_code,
+        sbyte* description );
+    internal unsafe delegate void GLFWdropfun(
+        glfwWindow* window,
+        int path_count,
+        sbyte*[] paths );
+    internal unsafe delegate void GLFWcursorposfun(
+        glfwWindow* window,
+        double xpos,
+        double ypos );
+    internal unsafe delegate void GLFWcursorenterfun(
+        glfwWindow* window,
+        int entered );
+    internal unsafe delegate void GLFWcharmodsfun(
+        glfwWindow* window,
+        uint codepoint,
+        int mods );
+    internal unsafe delegate void GLFWcharfun(
+        glfwWindow* window,
+        uint codepoint );
+
+#endregion
+
+}

内核源代码/StgSharp/Graphics/IGraphicAPIs.cs

@@ -0,0 +1,46 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="IGraphicAPIs.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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.Text;
+
+namespace StgSharp.Graphics
+{
+    public interface IGraphicAPIs
+    {
+
+        public IntPtr GraphicApiPackageHandle
+        {
+            get;
+        }
+
+    }
+}

内核源代码/StgSharp/Graphics/Image.cs

@@ -0,0 +1,337 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Image.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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.Data;
+using StgSharp.Graphics.OpenGL;
+using StgSharp.Math;
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Graphics
+{
+    public class Image : ISSDSerializable, IImageProvider
+    {
+
+        private byte[] _data;
+        private ImageInfo _rawInfo;
+        private int _pixelUpdateCount = 0;
+
+        internal unsafe Image()
+        {
+            _rawInfo = new ImageInfo();
+        }
+
+        internal Image( ImageInfo information )
+        {
+            _rawInfo = information;
+            _data = Array.Empty<byte>();
+
+            //int length = _rawInfo.width * _rawInfo.height * _rawInfo.channel;
+        }
+
+        public (int width, int height) Size
+        {
+            get => (_rawInfo.Width, _rawInfo.Height);
+        }
+
+        public byte[] PixelBuffer
+        {
+            get
+            {
+                if( ( _data.Length == 0 ) || ( _data == null ) ) {
+                    GetBytes();
+                    return _data!;
+                }
+                return _data;
+            }
+        }
+
+        public ImageChannel Channel => _rawInfo.Channel;
+
+        /// <summary>
+        /// Hash code of time pixels updated last time.
+        /// </summary>
+        public int PixelUpdateCount
+        {
+            get => _pixelUpdateCount;
+            internal set => _pixelUpdateCount = value;
+        }
+
+        public int ChannelCount => _rawInfo.ChannelCount;
+
+        public int Height
+        {
+            get => _rawInfo.Height;
+            internal set => _rawInfo.Height = value;
+        }
+
+        public int Width
+        {
+            get => _rawInfo.Width;
+            internal set => _rawInfo.Width = value;
+        }
+
+        public int PixelSize => GlHelper.GetPixelSize(
+            _rawInfo.pixelLayout, _rawInfo.Channel );
+
+        public PixelChannelLayout PixelLayout
+        {
+            get => _rawInfo.pixelLayout;
+            private set => _rawInfo.pixelLayout = value;
+        }
+
+        public SerializableTypeCode SSDTypeCode => SerializableTypeCode.PixelImage;
+
+        internal ref byte[] Data
+        {
+            get => ref _data;
+        }
+
+        public void FromBytes( byte[] stream ) { }
+
+        public static unsafe Image FromFile( string route, ImageLoader loader )
+        {
+            Image ret = new Image();
+            fixed( ImageInfo* iptr = &ret._rawInfo ) {
+                InternalIO.InternalLoadImage( route, iptr, loader );
+            }
+            return ret;
+        }
+
+        public static Image FromMemory(
+            (int width, int height) size,
+            ImageChannel channel,
+            byte[] stream )
+        {
+            ImageInfo _info = new ImageInfo
+            {
+                Height = size.height,
+                Width = size.width,
+                Channel = channel,
+                StreamPtr = IntPtr.Zero
+            };
+            Image ret = new Image( _info );
+            ret.PixelLayout = PixelChannelLayout.Byte;
+            ret._data = stream;
+            return ret;
+        }
+
+        public static Image FromMemory(
+            (int width, int height) size,
+            ImageChannel channel,
+            PixelChannelLayout layout,
+            byte[] stream )
+        {
+            ImageInfo _info = new ImageInfo
+            {
+                Height = size.height,
+                Width = size.width,
+                Channel = channel,
+                StreamPtr = IntPtr.Zero
+            };
+            Image ret = new Image( _info );
+            ret.PixelLayout = layout;
+            ret._data = stream;
+            return ret;
+        }
+
+        public unsafe byte[] GetBytes()
+        {
+            if( _data.Length == 0 ) {
+                int size = Width * Height * GlHelper.GetPixelSize(
+                    PixelLayout, Channel );
+                _data = new Span<byte>( ( byte* )_rawInfo.StreamPtr,
+                                        size ).ToArray();
+                fixed( ImageInfo* pptr = &_rawInfo ) {
+                    InternalIO.InternalUnloadImage( pptr );
+                }
+                _rawInfo.StreamPtr = IntPtr.Zero;
+            }
+            return _data;
+        }
+
+        public Image ProvideImage() => this;
+
+        internal static Image FromMemory(
+            ImageInfo info,
+            byte[] data,
+            int operationCount )
+        {
+            return new Image
+            {
+                _rawInfo = info,
+                _data = data,
+                _pixelUpdateCount = operationCount
+            };
+        }
+
+        byte[] ISSDSerializable.GetBytes()
+        {
+            throw new NotImplementedException();
+        }
+
+    }
+
+    [StructLayout( LayoutKind.Sequential )]
+    internal struct ImageInfo
+    {
+
+        private ImageChannel channel;
+        private int height;
+        private int width;
+        private IntPtr pixelPtr;
+        internal PixelChannelLayout pixelLayout;
+
+        public ImageChannel Channel
+        {
+            get => channel;
+            set { channel = value; }
+        }
+
+        public int ChannelCount
+        {
+            get => GlHelper.GetChannelCount( channel );
+        }
+
+        public int Height
+        {
+            get => height;
+            set => height = value;
+        }
+
+        public int StreamSize
+        {
+            get => width * height * GlHelper.GetPixelSize(
+                pixelLayout, channel );
+        }
+
+        public int Width
+        {
+            get => width;
+            set => width = value;
+        }
+
+        public IntPtr StreamPtr
+        {
+            get => pixelPtr;
+            internal set => pixelPtr = value;
+        }
+
+        public override int GetHashCode()
+        {
+            int hash = 17;
+            hash = hash * 17 + width;
+            hash = hash * 17 + height;
+            hash = hash * 17 + ( int )channel;
+            return hash;
+        }
+
+        public override string ToString()
+        {
+            return $"{channel}\t{width}\t{height}\t{(ulong)StreamPtr}";
+        }
+
+    }
+
+    public enum ImageChannel : uint
+    {
+
+        SingleColor = GLconst.RED,
+        DoubleColor = GLconst.RG,
+        TripleColor = GLconst.RGB,
+        WithAlphaChannel = GLconst.RGBA,
+
+    }
+}
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public static partial class GlHelper
+    {
+
+        internal static int GetChannelCount( ImageChannel channel )
+        {
+            return channel switch
+            {
+                ImageChannel.SingleColor => 1,
+                ImageChannel.DoubleColor => 2,
+                ImageChannel.TripleColor => 3,
+                ImageChannel.WithAlphaChannel => 4,
+                _ => throw new InvalidCastException(
+                    "Unknown color channel decoding setting." )
+            };
+        }
+
+        internal static int GetPixelSize(
+            PixelChannelLayout layout,
+            ImageChannel cahnnel )
+        {
+            return layout switch
+            {
+                PixelChannelLayout.UByte => sizeof( byte ) * GetChannelCount(
+                    cahnnel ),
+                PixelChannelLayout.Byte => sizeof( byte ) * GetChannelCount(
+                    cahnnel ),
+                PixelChannelLayout.UShort => sizeof( short ) * GetChannelCount(
+                    cahnnel ),
+                PixelChannelLayout.Short => sizeof( short ) * GetChannelCount(
+                    cahnnel ),
+                PixelChannelLayout.UInt => sizeof( int ) * GetChannelCount(
+                    cahnnel ),
+                PixelChannelLayout.Int => sizeof( int ) * GetChannelCount(
+                    cahnnel ),
+                PixelChannelLayout.Float => sizeof( float ) * GetChannelCount(
+                    cahnnel ),
+                PixelChannelLayout.UByte332 => sizeof( byte ),
+                PixelChannelLayout.UByte233Rev => sizeof( byte ),
+                PixelChannelLayout.UShort565 => sizeof( short ),
+                PixelChannelLayout.UShort565Rev => sizeof( short ),
+                PixelChannelLayout.UShort4444 => sizeof( short ),
+                PixelChannelLayout.UShort4444Rev => sizeof( short ),
+                PixelChannelLayout.UShort5551 => sizeof( short ),
+                PixelChannelLayout.UShort1555Rev => sizeof( short ),
+                PixelChannelLayout.UInt8888 => sizeof( int ),
+                PixelChannelLayout.UInt8888Rev => sizeof( int ),
+                PixelChannelLayout.UInt1010102 => sizeof( int ),
+                PixelChannelLayout.UInt2101010Rev => sizeof( int ),
+                _ => throw new ArgumentException( "Unknown layout type" ),
+            };
+        }
+
+    }
+}

内核源代码/StgSharp/Graphics/OpenGL/Buffer/AutoTexture.cs

@@ -0,0 +1,162 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="AutoTexture.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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 System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+using System.Threading.Tasks;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    /// <summary>
+    /// A collection of a sets of OpenGL textures. The collection can automatically select one of
+    /// the  texture with minimum costs to upgrade pixels to buffer. Usually <see
+    /// cref="AutoTextureGL" /> is used for <see cref="IImageProvider" /> loading, but not for
+    /// target of  <see cref="OpenGLFunction.FrameBufferTexture2d(FrameBufferTarget, uint,
+    /// Texture2DTarget, GlHandle, int)" />.
+    /// </summary>
+    public sealed class AutoTextureGL
+    {
+
+        private TextureProperty[] propertyCache;
+        private BidirectionalDictionary<Image, int> imageIndexMap = new BidirectionalDictionary<Image, int>(
+            );
+        private Dictionary<Image, int> imageUpdateIndex = new Dictionary<Image, int>(
+            );
+
+        private int _size, _currentIndex;
+        private LinkedList<int> usedTextureIndex;
+        private Queue<int> unusedTextureUnitIndex;
+        private TextureGL texturePackage;
+
+        private TextureProperty _textureProperty;
+
+        private AutoTextureGL( TextureGL texture )
+        {
+            texturePackage = texture;
+            _size = texture.Count;
+            imageIndexMap = new BidirectionalDictionary<Image, int>();
+            unusedTextureUnitIndex = new Queue<int>(
+                Enumerable.Range( 0, _size ) );
+            usedTextureIndex = new LinkedList<int>();
+            propertyCache = new TextureProperty[_size];
+        }
+
+        public AutoTextureGL( int textureObjectSize, [NotNull]glRender binding )
+        {
+            this._size = textureObjectSize;
+            imageIndexMap = new BidirectionalDictionary<Image, int>();
+            texturePackage = new TextureGL( textureObjectSize, binding );
+            unusedTextureUnitIndex = new Queue<int>(
+                Enumerable.Range( 0, _size ) );
+            usedTextureIndex = new LinkedList<int>();
+            propertyCache = new TextureProperty[_size];
+        }
+
+        public TextureProperty DefaultTextureProperty
+        {
+            get => _textureProperty;
+            set => _textureProperty = value;
+        }
+
+        private OpenGLFunction GL
+        {
+            get => texturePackage.GL;
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void SelectTextureAndBind( Image i )
+        {
+            TextureProperty property = _textureProperty;
+
+            SelectTextureAndBind( i, property );
+        }
+
+        public void SelectTextureAndBind(
+            [NotNull]Image i,
+            TextureProperty property )
+        {
+            //usable texture with image match
+            if( imageIndexMap.TryGetValue( i, out int index ) ) {
+                //prop setting match
+                if( propertyCache[ index ] == property ) {
+                    _currentIndex = index;                          //GL.Assert(true);
+                    texturePackage.Bind2D( index );                   //GL.Assert(true);
+                    if( i.PixelUpdateCount != imageUpdateIndex[ i ] ) {
+                        texturePackage.LoadTexture( index, i );       //GL.Assert(true);
+                    }
+                } else {
+                    _currentIndex = index;                          //GL.Assert(true);
+                    texturePackage.Bind2D( index );                   //GL.Assert(true);
+                    texturePackage.Set2dProperty( index, property );  //GL.Assert(true);
+                    if( i.PixelUpdateCount != imageUpdateIndex[ i ] ) {
+                        texturePackage.LoadTexture( index, i );       //GL.Assert(true);
+                    }
+                }
+            } else {
+                if( unusedTextureUnitIndex.TryDequeue( out int newIndex ) ) {
+                    //has extra unused texture object
+                    imageIndexMap.Add( i, index );
+                    texturePackage.Bind2D( index );
+                    texturePackage.Set2dProperty( index, property );
+                    texturePackage.LoadTexture( index, i );
+                    usedTextureIndex.AddLast( newIndex );
+                    propertyCache[ newIndex ] = property;
+                    imageUpdateIndex[ i ] = i.PixelUpdateCount;
+                } else {
+                    //recycle from current
+                    int reusedIndex = usedTextureIndex.First!.Value;
+                    usedTextureIndex.RemoveFirst();
+                    usedTextureIndex.AddLast( reusedIndex );
+                    imageIndexMap[ i ] = reusedIndex;
+                    propertyCache[ newIndex ] = property;
+                    imageUpdateIndex[ i ] = i.PixelUpdateCount;
+                }
+            }
+        }
+
+        public static AutoTextureGL ToAuto( [NotNull]TextureGL texture )
+        {
+            if( texture.IndexOfCurrentTexture != -1 ) {
+                throw new InvalidOperationException(
+                    "Texture to be converted has been editted." );
+            }
+            return new AutoTextureGL( texture );
+        }
+
+    }
+}

内核源代码/StgSharp/Graphics/OpenGL/Buffer/EBO.cs

@@ -0,0 +1,92 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="EBO.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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;
+using StgSharp.Graphics.OpenGL;
+using StgSharp.Math;
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    /// <summary>
+    /// A collection of handle to Element Buffer Object in OpenglFunc. Each <see langword="uint" />
+    /// value indexed from instance of this class this is the only handle to one Element Buffer
+    /// Object.
+    /// </summary>
+    public sealed unsafe class ElementBuffer : GlBufferObjectBase
+    {
+
+        internal ElementBuffer( int n, glRender binding )
+            : base( binding )
+        {
+            _bufferHandle = GL.GenBuffers( n );
+        }
+
+        public override sealed void Bind( int index )
+        {
+            GL.BindBuffer(
+                BufferType.ElementArrayBuffer, _bufferHandle[ index ] );
+        }
+
+        public void SetValue<T>( int index, T[] bufferArray, BufferUsage usage )
+            where T: struct, IConvertible
+        {
+            GL.BindBuffer(
+                BufferType.ElementArrayBuffer, _bufferHandle[ index ] );
+            GL.SetBufferData(
+                BufferType.ElementArrayBuffer, bufferArray, usage );
+        }
+
+        public void SetValue<T>(
+            int index,
+            ReadOnlySpan<T> bufferSpan,
+            BufferUsage usage )
+            where T: struct, IConvertible
+        {
+            GL.BindBuffer(
+                BufferType.ElementArrayBuffer, _bufferHandle[ index ] );
+            GL.SetBufferData( BufferType.ElementArrayBuffer, bufferSpan,
+                              usage );
+        }
+
+        protected override sealed void Dispose( bool disposing )
+        {
+            if( disposing ) {
+                GL.DeleteBuffers( _bufferHandle );
+            }
+        }
+
+    }
+}

内核源代码/StgSharp/Graphics/OpenGL/Buffer/FBO.cs

@@ -0,0 +1,101 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="FBO.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    #pragma warning disable CA1008 
+    #pragma warning disable CA1028 
+    public enum FrameBufferTarget : uint
+    #pragma warning restore CA1028 
+    #pragma warning restore CA1008 
+    {
+
+        Read = GLconst.READ_FRAMEBUFFER,
+        All = GLconst.FRAMEBUFFER,
+        Draw = GLconst.DRAW_FRAMEBUFFER,
+
+    }
+
+    public sealed class FrameBuffer : GlBufferObjectBase
+    {
+
+        internal unsafe FrameBuffer( int count, glRender binding )
+            : base( binding )
+        {
+            _bufferHandle = GL.GenFrameBuffers( count );
+        }
+
+        /// <summary>
+        /// Bind the frame buffer object with name frame buffer to the frame buffer target specified
+        /// by target. <see langword="FrameBufferTarget.All" /> will be set as default target.
+        /// </summary>
+        /// <param name="index"> Index of object to be binded in handle set </param>
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public override unsafe void Bind( int index )
+        {
+            GL.BindFrameBuffer( FrameBufferTarget.All, _bufferHandle[ index ] );
+        }
+
+        /// <summary>
+        /// Bind the frame buffer object with name frame buffer to the frame buffer target specified
+        /// by target. Target of this frame buffer should be set manually.
+        /// </summary>
+        /// <param name="target"> The frame buffer target of the binding operation. </param>
+        /// <param name="index"> Index of object to be binded in handle set </param>
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public unsafe void Bind( FrameBufferTarget target, int index )
+        {
+            GL.BindFrameBuffer( target, _bufferHandle[ index ] );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static void BindNull()
+        {
+            OpenGLFunction.CurrentGL
+                .BindFrameBuffer( FrameBufferTarget.All, GlHandle.Zero );
+        }
+
+        protected override void Dispose( bool disposing )
+        {
+            throw new NotImplementedException();
+        }
+
+    }
+}

内核源代码/StgSharp/Graphics/OpenGL/Buffer/GLBufferObjectBase.cs

@@ -0,0 +1,53 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="GLBufferObjectBase.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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.Collections.Generic;
+using System.Text;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public abstract class GlBufferObjectBase : BufferObjectBase
+    {
+
+        private readonly glRender _contextBinding;
+
+        protected GlBufferObjectBase( glRender contextBinding )
+        {
+            binding = contextBinding;
+            _contextBinding = contextBinding;
+        }
+
+        protected OpenGLFunction GL => _contextBinding.GL;
+
+    }
+}

内核源代码/StgSharp/Graphics/OpenGL/Buffer/RBO.cs

@@ -0,0 +1,73 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="RBO.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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.Collections.Generic;
+using System.Security.Principal;
+using System.Text;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public sealed class RenderBuffer : GlBufferObjectBase
+    {
+
+        public RenderBuffer( int count, glRender binding )
+            : base( binding )
+        {
+            _bufferHandle = GL.GenRenderBuffer( count );
+        }
+
+        public override void Bind( int index )
+        {
+            GL.BindRenderBuffer( this[ index ] );
+        }
+
+        public void Store(
+            RenderBufferInternalFormat format,
+            (int width, int height) size )
+        {
+            if( ( size.width > binding.Width ) || ( size.height > binding.Height ) ) {
+                StgSharp.LogWarning(
+                    "FrameBuffer is larger than current canvas binding" );
+            }
+        }
+
+        protected override void Dispose( bool disposing )
+        {
+            foreach( GlHandle item in _bufferHandle ) {
+                Console.WriteLine( "removing a render buffer" );
+                GL.DeleteRenderBuffer( item );
+            }
+        }
+
+    }
+}

内核源代码/StgSharp/Graphics/OpenGL/Buffer/TextureGL.cs

@@ -0,0 +1,299 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="TextureGL.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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.Data.Intrinsic;
+using StgSharp.Math;
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Drawing;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public sealed unsafe class TextureGL
+    {
+
+        private int currentEditingTextureIndex;
+
+        private OpenGLFunction _gl;
+        internal GlHandle[] _textureHandle;
+
+        internal TextureGL( int count, glRender binding )
+        {
+            //sourceList = new Image[count];
+            this._gl = binding.GL;
+            _textureHandle = _gl.GenTextures( count );
+        }
+
+        public GlHandle this[ int index ]
+        {
+            get => _textureHandle[ index ];
+        }
+
+        public int Count
+        {
+            get => _textureHandle.Length;
+        }
+
+        //internal Image[] sourceList;
+
+        public int IndexOfCurrentTexture
+        {
+            get => currentEditingTextureIndex;
+        }
+
+        internal OpenGLFunction GL => _gl;
+
+        public void ActivateAs( TextureUnit unit )
+        {
+            _gl.ActiveTextureUnit( ( uint )unit );
+        }
+
+        public void Bind2D( int index )
+        {
+            currentEditingTextureIndex = index;
+            _gl.BindTexture( GLconst.TEXTURE_2D, _textureHandle[ index ] );
+        }
+
+        /// <summary>
+        /// Load an <see cref="Image" /> to certain texture.
+        /// </summary>
+        /// <param name="index"> </param>
+        /// <param name="i"> </param>
+        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.GenerateMipmap( Texture2DTarget.Texture2D );
+        }
+
+        #region texture setting
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void Set2dFilterProperty(
+            int index,
+            TextureFilter onMinify,
+            TextureFilter onMagnify )
+        {
+            #if DEBUG
+            if( index != currentEditingTextureIndex ) {
+                throw new InvalidOperationException(
+                    "Texture to be editted is not the one being activated." );
+            }
+            #endif
+            _gl.TextureParameter(
+                GLconst.TEXTURE_2D, GLconst.TEXTURE_MIN_FILTER,
+                ( int )onMinify );
+            _gl.TextureParameter(
+                GLconst.TEXTURE_2D, GLconst.TEXTURE_MAG_FILTER,
+                ( int )onMagnify );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void Set2dWrapProperty(
+            int index,
+            TextureWrap onHorizontial,
+            TextureWrap onVertical )
+        {
+            #if DEBUG
+            if( index != currentEditingTextureIndex ) {
+                throw new InvalidOperationException(
+                    "Texture to be editted is not the one being activated." );
+            }
+            #endif
+            _gl.TextureParameter(
+                GLconst.TEXTURE_2D, GLconst.TEXTURE_WRAP_S,
+                ( int )onHorizontial );
+            _gl.TextureParameter(
+                GLconst.TEXTURE_2D, GLconst.TEXTURE_WRAP_T, ( int )onVertical );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void Set2dProperty( int index, TextureProperty property )
+        {
+            Set2dFilterProperty(
+                index, property.FilterOnMinify, property.FilterOnMagnify );
+            Set2dWrapProperty(
+                index, property.WrapOnHorizontial, property.WrapOnVertical );
+        }
+
+        #endregion texture setting
+    }
+
+    [StructLayout( LayoutKind.Explicit )]
+    public struct TextureProperty
+    {
+
+        [FieldOffset( 0 )] private M128 mask;
+        [FieldOffset( 0 )] private TextureFilter mag;
+        [FieldOffset( 4 )] private TextureFilter min;
+
+        [FieldOffset( 8 )] private  TextureWrap hori;
+        [FieldOffset( 12 )] private TextureWrap vert;
+
+        public TextureProperty(
+            TextureFilter onMagnify,
+            TextureFilter onMinify,
+            TextureWrap onHorizontial,
+            TextureWrap onVertical )
+        {
+            FilterOnMagnify = onMagnify;
+            FilterOnMinify = onMinify;
+            WrapOnHorizontial = onHorizontial;
+            WrapOnVertical = onVertical;
+        }
+
+        public TextureFilter FilterOnMagnify
+        {
+            get => mag;
+            set => mag = value;
+        }
+
+        public TextureFilter FilterOnMinify
+        {
+            get => min;
+            set => min = value;
+        }
+
+        public TextureWrap WrapOnHorizontial
+        {
+            get => hori;
+            set => hori = value;
+        }
+
+        public TextureWrap WrapOnVertical
+        {
+            get => vert;
+            set => vert = value;
+        }
+
+        public override bool Equals( [NotNullWhen( true )] object obj )
+        {
+            return base.Equals( obj );
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(
+                FilterOnMagnify, FilterOnMagnify, WrapOnHorizontial,
+                WrapOnVertical );
+        }
+
+        public override string ToString()
+        {
+            return $"FilterOnMagnify:{FilterOnMagnify}, " + $"FilterOnMagnify:{FilterOnMagnify}, " + $"WrapOnHorizontial:{WrapOnHorizontial}, " + $"WrapOnVertical:{WrapOnVertical}";
+        }
+
+        public static bool operator !=(
+            TextureProperty left,
+            TextureProperty right )
+        {
+            return left.mask != right.mask;
+        }
+
+        public static bool operator ==(
+            TextureProperty left,
+            TextureProperty right )
+        {
+            return left.mask == right.mask;
+        }
+
+        public static implicit operator TextureProperty(
+            (
+            TextureFilter onMagnify, TextureFilter onMinify,
+            TextureWrap onHorizontial, TextureWrap onVertical
+            ) propertyValueTuple )
+        {
+            return new TextureProperty(
+                propertyValueTuple.onMagnify, propertyValueTuple.onMinify,
+                propertyValueTuple.onHorizontial,
+                propertyValueTuple.onVertical );
+        }
+
+    }
+
+    #pragma warning disable CA1008
+    public enum TextureFilter
+    #pragma warning restore CA1008
+    {
+
+        Nearest = GLconst.NEAREST,
+        Linear = GLconst.LINEAR,
+        NearestLinearMipmap = GLconst.NEAREST_MIPMAP_LINEAR,
+        LinearLinearMipmap = GLconst.LINEAR_MIPMAP_LINEAR,
+        NearestNearestMipmap = GLconst.NEAREST_MIPMAP_NEAREST,
+        LinearNearestMipmap = GLconst.LINEAR_MIPMAP_NEAREST,
+
+    }
+
+    #pragma warning disable CA1008
+    public enum TextureUnit
+    #pragma warning restore CA1008
+    {
+
+        Unit0 = GLconst.TEXTURE0,
+        Unit1 = GLconst.TEXTURE1,
+        Unit2 = GLconst.TEXTURE2,
+        Unit3 = GLconst.TEXTURE3,
+        Unit4 = GLconst.TEXTURE4,
+        Unit5 = GLconst.TEXTURE5,
+        Unit6 = GLconst.TEXTURE6,
+        Unit7 = GLconst.TEXTURE7,
+        Unit8 = GLconst.TEXTURE8,
+        Unit9 = GLconst.TEXTURE9,
+        Unit10 = GLconst.TEXTURE10,
+        Unit11 = GLconst.TEXTURE11,
+        Unit12 = GLconst.TEXTURE12,
+        Unit13 = GLconst.TEXTURE13,
+        Unit14 = GLconst.TEXTURE14,
+        Unit15 = GLconst.TEXTURE15,
+
+    }
+
+    #pragma warning disable CA1008 
+    public enum TextureWrap
+    #pragma warning restore CA1008 
+    {
+
+        Repeat = GLconst.REPEAT,
+        MirroredRepeat = GLconst.MIRRORED_REPEAT,
+        ClampToEdge = GLconst.CLAMP_TO_EDGE,
+        ClampToBorder = GLconst.CLAMP_TO_BORDER,
+
+    }
+}

内核源代码/StgSharp/Graphics/OpenGL/Buffer/VAO.cs

@@ -0,0 +1,81 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="VAO.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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.Runtime.CompilerServices;
+using System.Text;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public sealed unsafe class VertexArray : GlBufferObjectBase
+    {
+
+        internal VertexArray( int n, glRender binding )
+            : base( binding )
+        {
+            _bufferHandle = GL.GenVertexArrays( n );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public override sealed void Bind( int index )
+        {
+            GL.BindVertexArray( _bufferHandle[ index ] );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static void BindNull()
+        {
+            OpenGLFunction.CurrentGL.BindVertexArray( GlHandle.Zero );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void SetVertexAttribute(
+            uint index,
+            int vertexLength,
+            TypeCode dataType,
+            bool isNomalized,
+            uint stride,
+            int pointer )
+        {
+            GL.SetVertexAttribute(
+                index, vertexLength, dataType, isNomalized, stride, pointer );
+        }
+
+        protected override sealed void Dispose( bool disposing )
+        {
+            if( disposing ) {
+                GL.DeleteVertexArrays( _bufferHandle );
+            }
+        }
+
+    }
+}

内核源代码/StgSharp/Graphics/OpenGL/Buffer/VBO.cs

@@ -0,0 +1,170 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="VBO.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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.Math;
+
+using System;
+using System.Collections.Generic;
+using System.Net.Security;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public sealed unsafe class VertexBuffer : GlBufferObjectBase
+    {
+
+        internal VertexBuffer( int n, glRender binding )
+            : base( binding )
+        {
+            _bufferHandle = GL.GenBuffers( n );
+        }
+
+        public override sealed void Bind( int index )
+        {
+            GL.BindBuffer( BufferType.ArrayBuffer, _bufferHandle[ index ] );
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void Unbind()
+        {
+            GL.BindBuffer( BufferType.ArrayBuffer, GlHandle.Zero );
+        }
+
+        /// <summary>
+        /// Set _data to current vertex buffer object
+        /// </summary>
+        /// <typeparam name="T"> Type of bufferData </typeparam>
+        /// <param name="index"> Index to find certain VBO in this instance </param>
+        /// <param name="bufferData"> Data to write in </param>
+        /// <param name="usage"> How OpenGL use these _data, defined by <see cref="BufferUsage" /></param>
+        public void WriteMatrixData<T>(
+            int index,
+            T bufferData,
+            BufferUsage usage )
+            where T: struct, IMat
+        {
+            GL.BindBuffer( BufferType.ArrayBuffer, _bufferHandle[ index ] );
+            GL.SetBufferData( BufferType.ArrayBuffer, bufferData, usage );
+        }
+
+        /// <summary>
+        /// Set _data to current vertex buffer object
+        /// </summary>
+        /// <typeparam name="T"> Type of bufferData </typeparam>
+        /// <param name="index"> Index to find certain VBO in this instance </param>
+        /// <param name="bufferArray"> Data to write in </param>
+        /// <param name="usage"> How OpenGL use these _data, defined by <see cref="BufferUsage" /></param>
+        public void WriteScalerData<T>(
+            int index,
+            T[] bufferArray,
+            BufferUsage usage )
+            where T: struct,
+#if NET8_0_OR_GREATER
+            INumber
+#else
+            IConvertible
+        #endif
+        {
+            GL.BindBuffer( BufferType.ArrayBuffer, _bufferHandle[ index ] );
+            GL.SetBufferData( BufferType.ArrayBuffer, bufferArray, usage );
+        }
+
+        /// <summary>
+        /// Set _data to current vertex buffer object
+        /// </summary>
+        /// <typeparam name="T"> Type of bufferData </typeparam>
+        /// <param name="index"> Index to find certain VBO in this instance </param>
+        /// <param name="scalerSpan"> A <see cref="Span{T}" /> of _data to write in </param>
+        /// <param name="usage"> How OpenGL use these _data, defined by <see cref="BufferUsage" /></param>
+        public void WriteScalerData<T>(
+            int index,
+            ReadOnlySpan<T> scalerSpan,
+            BufferUsage usage )
+            where T: struct,
+#if NET8_0_OR_GREATER
+            INumber
+#else
+            IConvertible
+        #endif
+        {
+            GL.BindBuffer( BufferType.ArrayBuffer, _bufferHandle[ index ] );
+            GL.SetBufferData( BufferType.ArrayBuffer, scalerSpan, usage );
+        }
+
+        /// <summary>
+        /// Set _data to current vertex buffer object
+        /// </summary>
+        /// <typeparam name="T"> Type of bufferData </typeparam>
+        /// <param name="index"> Index to find certain VBO in this instance </param>
+        /// <param name="vectorSpan"> A <see cref="Span{T}" /> of _data to write in </param>
+        /// <param name="usage"> How OpenGL use these _data, defined by <see cref="BufferUsage" /></param>
+        public void WriteVectorData<T>(
+            int index,
+            ReadOnlySpan<T> vectorSpan,
+            BufferUsage usage )
+            where T: struct, IVector
+        {
+            GL.BindBuffer( BufferType.ArrayBuffer, _bufferHandle[ index ] );
+            GL.SetBufferVectorData( BufferType.ArrayBuffer, vectorSpan, usage );
+        }
+
+        /// <summary>
+        /// Set _data to current vertex buffer object
+        /// </summary>
+        /// <typeparam name="T"> Type of bufferData </typeparam>
+        /// <param name="index"> Index to find certain VBO in this instance </param>
+        /// <param name="vectorArray"> A array of _data to write in </param>
+        /// <param name="usage"> How OpenGL use these _data, defined by <see cref="BufferUsage" /></param>
+        public void WriteVectorData<T>(
+            int index,
+            T[] vectorArray,
+            BufferUsage usage )
+            where T: struct, IVector
+        {
+            GL.BindBuffer( BufferType.ArrayBuffer, _bufferHandle[ index ] );
+            GL.SetBufferVectorData( BufferType.ArrayBuffer, vectorArray,
+                                    usage );
+        }
+
+        protected override sealed void Dispose( bool disposing )
+        {
+            if( disposing ) {
+                GL.DeleteBuffers( _bufferHandle );
+            }
+        }
+
+    }
+}

内核源代码/StgSharp/Graphics/OpenGL/ShaderEdit/IglConvertable.cs

@@ -0,0 +1,68 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="IglConvertable.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Graphics.ShaderEdit
+{
+    public interface IglConvertable
+    {
+
+        /// <summary>
+        ///
+        /// </summary>
+        public void DisplayGLtypeDefinition();
+
+        /// <summary>
+        ///
+        /// </summary>
+        public void GainAllUniforms(
+            ShaderProgram source,
+            params string[] uniformName );
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        public ShaderStruct GetConvertedGLtype();
+
+        /// <summary>
+        ///
+        /// </summary>
+        public void SetAllUniforms();
+
+    }
+}

内核源代码/StgSharp/Graphics/OpenGL/ShaderEdit/Shader.cs

@@ -0,0 +1,271 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Shader.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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;
+using StgSharp.Data;
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Xml.Linq;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public abstract partial class glRender : RenderStream
+    {
+
+        /// <summary>
+        /// Create an instance of <see cref="Shader" /> program
+        /// </summary>
+        /// <returns> New instance of <see cref="Shader" /> instance. </returns>
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        protected override sealed ShaderProgram CreateShaderProgram()
+        {
+            return new ShaderProgram( this );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        protected override sealed Shader CreateShaderSegment(
+            ShaderType type,
+            int count )
+        {
+            return new Shader( GL.CreateShaderSet( count, type ), type, this );
+        }
+
+    }
+
+    public class Shader : ISSDSerializable
+    {
+
+        private readonly OpenGLFunction GL;
+        internal readonly GlHandle[] handle;
+        public readonly ShaderType type;
+
+        internal unsafe Shader(
+            GlHandle[] handle,
+            ShaderType usage,
+            glRender stream )
+        {
+            this.handle = handle;
+            GL = stream.GL;
+            type = usage;
+        }
+
+        public SerializableTypeCode SSDTypeCode => SerializableTypeCode.Shader;
+
+        /// <summary>
+        /// Attach one shader code to a shader program.
+        /// </summary>
+        /// <param name="target"> Shader program to attach </param>
+        /// <param name="index"> Index of shader code in current shader code set. </param>
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void AttachTo( int index, ShaderProgram target )
+        {
+            GL.AttachShader( target.handle, handle[ index ] );
+        }
+
+        public void CheckStatus( int index, ShaderStatus status )
+        {
+            string log = GL.GetShaderStatus( this, index, ( int )status );
+            if( !string.IsNullOrEmpty( log ) ) {
+                throw new Exception( $"{$"Shader Error \t{status}\n"}{log}" );
+            }
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public unsafe void Compile( int index, byte[] codeStream )
+        {
+            if( codeStream == null ) {
+                throw new ArgumentNullException( nameof( codeStream ) );
+            }
+            GL.LoadShaderSource( handle[ index ], codeStream );
+            GL.CompileShader( handle[ index ] );
+            CheckStatus( index, ShaderStatus.CompileStatus );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public unsafe void Compile( int index, string codeStream )
+        {
+            if( codeStream == null ) {
+                throw new ArgumentNullException( nameof( codeStream ) );
+            }
+            GL.LoadShaderSource(
+                handle[ index ], Encoding.ASCII.GetBytes( codeStream ) );
+            GL.CompileShader( handle[ index ] );
+            CheckStatus( index, ShaderStatus.CompileStatus );
+        }
+
+        public void FromBytes( byte[] stream )
+        {
+            throw new NotImplementedException();
+        }
+
+        public static byte[] FromCodeFile( string fileRoute )
+        {
+            string str = File.ReadAllText( fileRoute );
+            if( string.IsNullOrEmpty( str ) ) {
+                throw new InvalidOperationException(
+                    $"Cannot load and GLSL code from {fileRoute}" );
+            }
+            return Encoding.UTF8.GetBytes( str );
+        }
+
+        public byte[] GetBytes()
+        {
+            return Array.Empty<byte>();
+        }
+
+        public byte[] GetBytes( out int length )
+        {
+            throw new NotImplementedException();
+        }
+
+        public override string ToString()
+        {
+            return $"This is a {type} shader, its shader handles are {handle.ToString()}.";
+        }
+
+    }
+
+    public enum ShaderStatus : int
+    {
+
+        CompileStatus = GLconst.COMPILE_STATUS,
+
+    }
+
+    public class ShaderProgram
+    {
+
+        private readonly OpenGLFunction GL;
+        internal readonly GlHandle handle;
+
+        /// <summary>
+        /// CustomizeInit a program with no shader attached.
+        /// </summary>
+        internal unsafe ShaderProgram( glRender binding )
+        {
+            GL = binding.GL;
+            handle = GL.CreateProgram();
+        }
+
+        /// <summary>
+        /// Get a uniform form current shader, the value type of the uniform should be provided.
+        /// </summary>
+        /// <param name="name"> ContextName of the Uniform in shader code </param>
+        /// <returns></returns>
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public unsafe Uniform<T> GetUniform<T>( string name ) where T: struct
+        {
+            return new Uniform<T>( GL.GetUniformLocation( this.handle, name ) );
+        }
+
+        /// <summary>
+        /// Get a uniform form current shader, the value type of the uniform should be provided.
+        /// </summary>
+        /// <param name="name"> ContextName of the Uniform in shader code </param>
+        /// <returns></returns>
+        public unsafe Uniform<T, U> GetUniform<T, U>( string name )
+            where T: struct
+            where U: struct
+        {
+            return new Uniform<T, U>(
+                GL.GetUniformLocation( this.handle, name ) );
+        }
+
+        /// <summary>
+        /// Get a uniform form current shader, the value type of the uniform should be provided.
+        /// </summary>
+        /// <param name="name"> ContextName of the Uniform in shader code </param>
+        /// <returns></returns>
+        public unsafe Uniform<T, U, V> GetUniform<T, U, V>( string name )
+            where T: struct
+            where U: struct
+            where V: struct
+        {
+            return new Uniform<T, U, V>(
+                GL.GetUniformLocation( this.handle, name ) );
+        }
+
+        /// <summary>
+        /// Get a uniform form current shader, the value type of the uniform should be provided.
+        /// </summary>
+        /// <param name="name"> ContextName of the Uniform in shader code </param>
+        /// <returns></returns>
+        public unsafe Uniform<T, U, V, W> GetUniform<T, U, V, W>( string name )
+            where T: struct
+            where U: struct
+            where V: struct
+            where W: struct
+        {
+            return new Uniform<T, U, V, W>(
+                GL.GetUniformLocation( this.handle, name ) );
+        }
+
+        /// <summary>
+        /// Link the shader to current viewPortDisplay.
+        /// </summary>
+        public unsafe void Link()
+        {
+            if( InternalIO.InternalLinkShaderProgram(
+                ( OpenglContext* )this.GL.ContextHandle, handle.Value ) == 0 ) {
+                IntPtr logPtr = InternalIO.InternalReadSSCLog();
+                try {
+                    byte[] logByte = new byte[512];
+                    Marshal.Copy( logPtr, logByte, 0, 512 );
+                    string log = Encoding.UTF8.GetString( logByte );
+                    log = log.Replace( "\0", string.Empty );
+                    InternalIO.InternalWriteLog( log, LogType.Error );
+                }
+                catch( Exception ex ) {
+                    InternalIO.InternalWriteLog( ex.Message, LogType.Error );
+                }
+            }
+        }
+
+        /// <summary>
+        /// Let the current viewPortDisplay use this shader.
+        /// </summary>
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public unsafe void Use()
+        {
+            GL.UseProgram( handle );
+        }
+
+        ~ShaderProgram()
+        {
+            //handle.Dispose();
+        }
+
+    }
+}

内核源代码/StgSharp/Graphics/OpenGL/ShaderEdit/Uniform.cs

@@ -0,0 +1,198 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Uniform.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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;
+using StgSharp.Math;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public class Uniform
+    {
+
+        internal GlHandle id;
+
+        public GlHandle Handle
+        {
+            get => id;
+        }
+
+    }
+
+    public sealed class Uniform<T> : Uniform where T: struct
+    {
+
+        internal Uniform() { }
+
+        internal unsafe Uniform( GlHandle id )
+        {
+            this.id = id;
+        }
+
+        internal static Uniform<T> FromHandle( GlHandle handle )
+        {
+            return new Uniform<T> { id = handle };
+        }
+
+    }
+
+    public sealed class Uniform<T, U> : Uniform where T: struct where U: struct
+    {
+
+        internal Uniform() { }
+
+        internal unsafe Uniform( GlHandle id )
+        {
+            this.id = id;
+        }
+
+        internal static Uniform<T, U> FromHandle( GlHandle handle )
+        {
+            return new Uniform<T, U> { id = handle };
+        }
+
+    }
+
+    public sealed class Uniform<T, U, V> : Uniform where T: struct
+        where U: struct
+        where V: struct
+    {
+
+        internal Uniform() { }
+
+        internal unsafe Uniform( GlHandle id )
+        {
+            this.id = id;
+        }
+
+        internal static Uniform<T, U, V> FromHandle( GlHandle handle )
+        {
+            return new Uniform<T, U, V> { id = handle };
+        }
+
+    }
+
+    public sealed class Uniform<T, U, V, W> : Uniform where T: struct
+        where U: struct
+        where V: struct
+        where W: struct
+    {
+
+        internal Uniform() { }
+
+        internal unsafe Uniform( GlHandle id )
+        {
+            this.id = id;
+        }
+
+        internal static Uniform<T, U, V, W> FromHandle( GlHandle handle )
+        {
+            return new Uniform<T, U, V, W> { id = handle };
+        }
+
+    }
+
+    public unsafe partial class OpenGLFunction
+    {
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void SetUniformValue( Uniform<Matrix44> uniform, Matrix44 mat )
+        {
+            Matrix44 temp = mat;
+            Context.glUniformMatrix4fv(
+                uniform.id.SignedValue, 1, false, ( float* )&temp );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void SetUniformValue(
+            Uniform<float, float, float, float> uniform,
+            Vec4 vec )
+        {
+            Vec4 temp = vec;
+            Context.glUniform1fv( uniform.id.SignedValue, 4, &temp );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void SetUniformValue( Uniform<Vec4> uniform, Vec4 vec )
+        {
+            Vec4 temp = vec;
+            Context.glUniform1fv( uniform.id.SignedValue, 4, &temp );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void SetUniformValue( Uniform<float> uniform, float v0 )
+        {
+            Context.glUniform1f( uniform.id.SignedValue, v0 );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void SetUniformValue( Uniform<int> uniform, int i0 )
+        {
+            Context.glUniform1i( uniform.id.SignedValue, i0 );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void SetUniformValue(
+            Uniform<float, float> uniform,
+            float v0,
+            float v1 )
+        {
+            Context.glUniform2f( uniform.id.SignedValue, v0, v1 );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void SetUniformValue(
+            Uniform<float, float, float> uniform,
+            float v0,
+            float v1,
+            float v2 )
+        {
+            Context.glUniform3f( uniform.id.SignedValue, v0, v1, v2 );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void SetUniformValue(
+            Uniform<float, float, float, float> uniform,
+            float v0,
+            float v1,
+            float v2,
+            float v3 )
+        {
+            Context.glUniform4f( uniform.id.SignedValue, v0, v1, v2, v3 );
+        }
+
+    }
+}

内核源代码/StgSharp/Graphics/OpenGL/glAPICalling.cs

@@ -0,0 +1,44 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="glAPICalling.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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.Text;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    [AttributeUsage( AttributeTargets.Method )]
+    public sealed class OpenGLAPICallingAttribute : Attribute
+    {
+
+        public OpenGLAPICallingAttribute() { }
+
+    }
+}

内核源代码/StgSharp/Graphics/OpenGL/glApiManagerConst.cs

@@ -0,0 +1,688 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="glApiManagerConst.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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.Text;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public static partial class glManager
+    {
+
+        #region coreVersion
+
+        private static bool core10 = false;
+        private static bool core11 = false;
+        private static bool core12 = false;
+        private static bool core13 = false;
+        private static bool core14 = false;
+        private static bool core15 = false;
+        private static bool core20 = false;
+        private static bool core21 = false;
+        private static bool core30 = false;
+        private static bool core31 = false;
+        private static bool core32 = false;
+        private static bool core33 = false;
+        private static bool core40 = false;
+        private static bool core41 = false;
+        private static bool core42 = false;
+        private static bool core43 = false;
+        private static bool core44 = false;
+        private static bool core45 = false;
+        private static bool core46 = false;
+
+        #endregion
+
+        #region extension
+
+        private static bool _3DFX_tbuffer;
+        private static bool _3DFX_texture_compression_FXT1;
+        private static bool _4DFX_multisample;
+        private static bool AMD_blend_minmax_factor;
+        private static bool AMD_conservative_depth;
+        private static bool AMD_debug_output;
+        private static bool AMD_depth_clamp_separate;
+        private static bool AMD_draw_buffers_blend;
+        private static bool AMD_framebuffer_multisample_advanced;
+        private static bool AMD_framebuffer_sample_positions;
+        private static bool AMD_gcn_shader;
+        private static bool AMD_gpu_shader_half_float;
+        private static bool AMD_gpu_shader_int16;
+        private static bool AMD_gpu_shader_int64;
+        private static bool AMD_interleaved_elements;
+        private static bool AMD_multi_draw_indirect;
+        private static bool AMD_name_gen_delete;
+        private static bool AMD_occlusion_query_event;
+        private static bool AMD_performance_monitor;
+        private static bool AMD_pinned_memory;
+        private static bool AMD_query_buffer_object;
+        private static bool AMD_sample_positions;
+        private static bool AMD_seamless_cubemap_per_texture;
+        private static bool AMD_shader_atomic_counter_ops;
+        private static bool AMD_shader_ballot;
+        private static bool AMD_shader_explicit_vertex_parameter;
+        private static bool AMD_shader_gpu_shader_half_float_fetch;
+        private static bool AMD_shader_image_load_store_lod;
+        private static bool AMD_shader_stencil_export;
+        private static bool AMD_shader_trinary_minmax;
+        private static bool AMD_sparse_texture;
+        private static bool AMD_stencil_operation_extended;
+        private static bool AMD_texture_gather_bias_lod;
+        private static bool AMD_texture_texture4;
+        private static bool AMD_transform_feedback3_lines_triangles;
+        private static bool AMD_transform_feedback4;
+        private static bool AMD_vertex_shader_layer;
+        private static bool AMD_vertex_shader_tessellator;
+        private static bool AMD_vertex_shader_viewport_index;
+        private static bool APPLE_aux_depth_stencil;
+        private static bool APPLE_client_storage;
+        private static bool APPLE_element_array;
+        private static bool APPLE_fence;
+        private static bool APPLE_float_pixels;
+        private static bool APPLE_flush_buffer_range;
+        private static bool APPLE_object_purgeable;
+        private static bool APPLE_rgb_422;
+        private static bool APPLE_row_bytes;
+        private static bool APPLE_specular_vector;
+        private static bool APPLE_texture_range;
+        private static bool APPLE_transform_hint;
+        private static bool APPLE_vertex_array_object;
+        private static bool APPLE_vertex_array_range;
+        private static bool APPLE_vertex_program_evaluators;
+        private static bool APPLE_ycbcr_422;
+        private static bool ARB_arrays_of_arrays;
+        private static bool ARB_base_instance;
+        private static bool ARB_bindless_texture;
+        private static bool ARB_blend_func_extended;
+        private static bool ARB_buffer_storage;
+        private static bool ARB_cl_event;
+        private static bool ARB_clear_buffer_object;
+        private static bool ARB_clear_texture;
+        private static bool ARB_clip_control;
+        private static bool ARB_color_buffer_float;
+        private static bool ARB_compatibility;
+        private static bool ARB_compressed_texture_pixel_storage;
+        private static bool ARB_compute_shader;
+        private static bool ARB_compute_variable_group_size;
+        private static bool ARB_conditional_render_inverted;
+        private static bool ARB_conservative_depth;
+        private static bool ARB_copy_buffer;
+        private static bool ARB_copy_image;
+        private static bool ARB_cull_distance;
+        private static bool ARB_debug_output;
+        private static bool ARB_depth_buffer_float;
+        private static bool ARB_depth_clamp;
+        private static bool ARB_depth_texture;
+        private static bool ARB_derivative_control;
+        private static bool ARB_direct_state_access;
+        private static bool ARB_draw_buffers;
+        private static bool ARB_draw_buffers_blend;
+        private static bool ARB_draw_elements_base_vertex;
+        private static bool ARB_draw_indirect;
+        private static bool ARB_draw_instanced;
+        private static bool ARB_enhanced_layouts;
+        private static bool ARB_ES2_compatibility;
+        private static bool ARB_ES3_1_compatibility;
+        private static bool ARB_ES3_2_compatibility;
+        private static bool ARB_ES3_compatibility;
+        private static bool ARB_explicit_attrib_location;
+        private static bool ARB_explicit_uniform_location;
+        private static bool ARB_fragment_coord_conventions;
+        private static bool ARB_fragment_layer_viewport;
+        private static bool ARB_fragment_program;
+        private static bool ARB_fragment_program_shadow;
+        private static bool ARB_fragment_shader;
+        private static bool ARB_fragment_shader_interlock;
+        private static bool ARB_framebuffer_no_attachments;
+        private static bool ARB_framebuffer_object;
+        private static bool ARB_framebuffer_sRGB;
+        private static bool ARB_geometry_shader4;
+        private static bool ARB_get_program_binary;
+        private static bool ARB_get_texture_sub_image;
+        private static bool ARB_gl_spirv;
+        private static bool ARB_gpu_shader_fp64;
+        private static bool ARB_gpu_shader_int64;
+        private static bool ARB_gpu_shader5;
+        private static bool ARB_half_float_pixel;
+        private static bool ARB_half_float_vertex;
+        private static bool ARB_imaging;
+        private static bool ARB_indirect_parameters;
+        private static bool ARB_instanced_arrays;
+        private static bool ARB_internalformat_query;
+        private static bool ARB_internalformat_query2;
+        private static bool ARB_invalidate_subdata;
+        private static bool ARB_map_buffer_alignment;
+        private static bool ARB_map_buffer_range;
+        private static bool ARB_matrix_palette;
+        private static bool ARB_multi_bind;
+        private static bool ARB_multi_draw_indirect;
+        private static bool ARB_multisample;
+        private static bool ARB_multitexture;
+        private static bool ARB_occlusion_query;
+        private static bool ARB_occlusion_query2;
+        private static bool ARB_parallel_shader_compile;
+        private static bool ARB_pipeline_statistics_query;
+        private static bool ARB_pixel_buffer_object;
+        private static bool ARB_point_parameters;
+        private static bool ARB_point_sprite;
+        private static bool ARB_polygon_offset_clamp;
+        private static bool ARB_post_depth_coverage;
+        private static bool ARB_program_interface_query;
+        private static bool ARB_provoking_vertex;
+        private static bool ARB_query_buffer_object;
+        private static bool ARB_robust_buffer_access_behavior;
+        private static bool ARB_robustness;
+        private static bool ARB_robustness_isolation;
+        private static bool ARB_sample_locations;
+        private static bool ARB_sample_shading;
+        private static bool ARB_sampler_objects;
+        private static bool ARB_seamless_cube_map;
+        private static bool ARB_seamless_cubemap_per_texture;
+        private static bool ARB_separate_shader_objects;
+        private static bool ARB_shader_atomic_counter_ops;
+        private static bool ARB_shader_atomic_counters;
+        private static bool ARB_shader_ballot;
+        private static bool ARB_shader_bit_encoding;
+        private static bool ARB_shader_clock;
+        private static bool ARB_shader_draw_parameters;
+        private static bool ARB_shader_group_vote;
+        private static bool ARB_shader_image_load_store;
+        private static bool ARB_shader_image_size;
+        private static bool ARB_shader_objects;
+        private static bool ARB_shader_precision;
+        private static bool ARB_shader_stencil_export;
+        private static bool ARB_shader_storage_buffer_object;
+        private static bool ARB_shader_subroutine;
+        private static bool ARB_shader_texture_image_samples;
+        private static bool ARB_shader_texture_lod;
+        private static bool ARB_shader_viewport_layer_array;
+        private static bool ARB_shading_language_100;
+        private static bool ARB_shading_language_420pack;
+        private static bool ARB_shading_language_include;
+        private static bool ARB_shading_language_packing;
+        private static bool ARB_shadow;
+        private static bool ARB_shadow_ambient;
+        private static bool ARB_sparse_buffer;
+        private static bool ARB_sparse_texture;
+        private static bool ARB_sparse_texture_clamp;
+        private static bool ARB_sparse_texture2;
+        private static bool ARB_spirv_extensions;
+        private static bool ARB_stencil_texturing;
+        private static bool ARB_sync;
+        private static bool ARB_tessellation_shader;
+        private static bool ARB_texture_barrier;
+        private static bool ARB_texture_border_clamp;
+        private static bool ARB_texture_buffer_object;
+        private static bool ARB_texture_buffer_object_rgb32;
+        private static bool ARB_texture_buffer_range;
+        private static bool ARB_texture_compression;
+        private static bool ARB_texture_compression_bptc;
+        private static bool ARB_texture_compression_rgtc;
+        private static bool ARB_texture_cube_map;
+        private static bool ARB_texture_cube_map_array;
+        private static bool ARB_texture_env_add;
+        private static bool ARB_texture_env_combine;
+        private static bool ARB_texture_env_crossbar;
+        private static bool ARB_texture_env_dot3;
+        private static bool ARB_texture_filter_anisotropic;
+        private static bool ARB_texture_filter_minmax;
+        private static bool ARB_texture_float;
+        private static bool ARB_texture_gather;
+        private static bool ARB_texture_mirror_clamp_to_edge;
+        private static bool ARB_texture_mirrored_repeat;
+        private static bool ARB_texture_multisample;
+        private static bool ARB_texture_non_power_of_two;
+        private static bool ARB_texture_query_levels;
+        private static bool ARB_texture_query_lod;
+        private static bool ARB_texture_rectangle;
+        private static bool ARB_texture_rg;
+        private static bool ARB_texture_rgb10_a2ui;
+        private static bool ARB_texture_stencil8;
+        private static bool ARB_texture_storage;
+        private static bool ARB_texture_storage_multisample;
+        private static bool ARB_texture_swizzle;
+        private static bool ARB_texture_view;
+        private static bool ARB_timer_query;
+        private static bool ARB_transform_feedback_instanced;
+        private static bool ARB_transform_feedback_overflow_query;
+        private static bool ARB_transform_feedback2;
+        private static bool ARB_transform_feedback3;
+        private static bool ARB_transpose_matrix;
+        private static bool ARB_uniform_buffer_object;
+        private static bool ARB_vertex_array_bgra;
+        private static bool ARB_vertex_array_object;
+        private static bool ARB_vertex_attrib_64bit;
+        private static bool ARB_vertex_attrib_binding;
+        private static bool ARB_vertex_blend;
+        private static bool ARB_vertex_buffer_object;
+        private static bool ARB_vertex_program;
+        private static bool ARB_vertex_shader;
+        private static bool ARB_vertex_type_10f_11f_11f_rev;
+        private static bool ARB_vertex_type_2_10_10_10_rev;
+        private static bool ARB_viewport_array;
+        private static bool ARB_window_pos;
+        private static bool ATI_draw_buffers;
+        private static bool ATI_element_array;
+        private static bool ATI_envmap_bumpmap;
+        private static bool ATI_fragment_shader;
+        private static bool ATI_map_object_buffer;
+        private static bool ATI_meminfo;
+        private static bool ATI_pixel_format_float;
+        private static bool ATI_pn_triangles;
+        private static bool ATI_separate_stencil;
+        private static bool ATI_text_fragment_shader;
+        private static bool ATI_texture_env_combine3;
+        private static bool ATI_texture_float;
+        private static bool ATI_texture_mirror_once;
+        private static bool ATI_vertex_array_object;
+        private static bool ATI_vertex_attrib_array_object;
+        private static bool ATI_vertex_streams;
+        private static bool EXT_422_pixels;
+        private static bool EXT_abgr;
+        private static bool EXT_bgra;
+        private static bool EXT_bindable_uniform;
+        private static bool EXT_blend_color;
+        private static bool EXT_blend_equation_separate;
+        private static bool EXT_blend_func_separate;
+        private static bool EXT_blend_logic_op;
+        private static bool EXT_blend_minmax;
+        private static bool EXT_blend_subtract;
+        private static bool EXT_clip_volume_hint;
+        private static bool EXT_cmyka;
+        private static bool EXT_color_subtable;
+        private static bool EXT_compiled_vertex_array;
+        private static bool EXT_convolution;
+        private static bool EXT_coordinate_frame;
+        private static bool EXT_copy_texture;
+        private static bool EXT_cull_vertex;
+        private static bool EXT_debug_label;
+        private static bool EXT_debug_marker;
+        private static bool EXT_depth_bounds_test;
+        private static bool EXT_direct_state_access;
+        private static bool EXT_draw_buffers2;
+        private static bool EXT_draw_instanced;
+        private static bool EXT_draw_range_elements;
+        private static bool EXT_EGL_image_storage;
+        private static bool EXT_EGL_sync;
+        private static bool EXT_external_buffer;
+        private static bool EXT_fog_coord;
+        private static bool EXT_framebuffer_blit;
+        private static bool EXT_framebuffer_blit_layers;
+        private static bool EXT_framebuffer_multisample;
+        private static bool EXT_framebuffer_multisample_blit_scaled;
+        private static bool EXT_framebuffer_object;
+        private static bool EXT_framebuffer_sRGB;
+        private static bool EXT_geometry_shader4;
+        private static bool EXT_gpu_program_parameters;
+        private static bool EXT_gpu_shader4;
+        private static bool EXT_histogram;
+        private static bool EXT_index_array_formats;
+        private static bool EXT_index_func;
+        private static bool EXT_index_material;
+        private static bool EXT_index_texture;
+        private static bool EXT_light_texture;
+        private static bool EXT_memory_object;
+        private static bool EXT_memory_object_fd;
+        private static bool EXT_memory_object_win32;
+        private static bool EXT_misc_attribute;
+        private static bool EXT_multi_draw_arrays;
+        private static bool EXT_multisample;
+        private static bool EXT_multiview_tessellation_geometry_shader;
+        private static bool EXT_multiview_texture_multisample;
+        private static bool EXT_multiview_timer_query;
+        private static bool EXT_packed_depth_stencil;
+        private static bool EXT_packed_float;
+        private static bool EXT_packed_pixels;
+        private static bool EXT_paletted_texture;
+        private static bool EXT_pixel_buffer_object;
+        private static bool EXT_pixel_transform;
+        private static bool EXT_pixel_transform_color_table;
+        private static bool EXT_point_parameters;
+        private static bool EXT_polygon_offset;
+        private static bool EXT_polygon_offset_clamp;
+        private static bool EXT_post_depth_coverage;
+        private static bool EXT_provoking_vertex;
+        private static bool EXT_raster_multisample;
+        private static bool EXT_rescale_normal;
+        private static bool EXT_secondary_color;
+        private static bool EXT_semaphore;
+        private static bool EXT_semaphore_fd;
+        private static bool EXT_semaphore_win32;
+        private static bool EXT_separate_shader_objects;
+        private static bool EXT_separate_specular_color;
+        private static bool EXT_shader_framebuffer_fetch;
+        private static bool EXT_shader_framebuffer_fetch_non_coherent;
+        private static bool EXT_shader_image_load_formatted;
+        private static bool EXT_shader_image_load_store;
+        private static bool EXT_shader_integer_mix;
+        private static bool EXT_shader_samples_identical;
+        private static bool EXT_shadow_funcs;
+        private static bool EXT_shared_texture_palette;
+        private static bool EXT_sparse_texture2;
+        private static bool EXT_stencil_clear_tag;
+        private static bool EXT_stencil_two_side;
+        private static bool EXT_stencil_wrap;
+        private static bool EXT_subtexture;
+        private static bool EXT_texture;
+        private static bool EXT_texture_array;
+        private static bool EXT_texture_buffer_object;
+        private static bool EXT_texture_compression_latc;
+        private static bool EXT_texture_compression_rgtc;
+        private static bool EXT_texture_compression_s3tc;
+        private static bool EXT_texture_cube_map;
+        private static bool EXT_texture_env_add;
+        private static bool EXT_texture_env_combine;
+        private static bool EXT_texture_env_dot3;
+        private static bool EXT_texture_filter_anisotropic;
+        private static bool EXT_texture_filter_minmax;
+        private static bool EXT_texture_integer;
+        private static bool EXT_texture_lod_bias;
+        private static bool EXT_texture_mirror_clamp;
+        private static bool EXT_texture_object;
+        private static bool EXT_texture_perturb_normal;
+        private static bool EXT_texture_shadow_lod;
+        private static bool EXT_texture_shared_exponent;
+        private static bool EXT_texture_snorm;
+        private static bool EXT_texture_sRGB;
+        private static bool EXT_texture_sRGB_decode;
+        private static bool EXT_texture_sRGB_R8;
+        private static bool EXT_texture_sRGB_RG8;
+        private static bool EXT_texture_storage;
+        private static bool EXT_texture_swizzle;
+        private static bool EXT_texture3D;
+        private static bool EXT_timer_query;
+        private static bool EXT_transform_feedback;
+        private static bool EXT_vertex_array;
+        private static bool EXT_vertex_array_bgra;
+        private static bool EXT_vertex_attrib_64bit;
+        private static bool EXT_vertex_shader;
+        private static bool EXT_vertex_weighting;
+        private static bool EXT_win32_keyed_mutex;
+        private static bool EXT_window_rectangles;
+        private static bool EXT_x11_sync_object;
+        private static bool GREMEDY_frame_terminator;
+        private static bool GREMEDY_string_marker;
+        private static bool HP_convolution_border_modes;
+        private static bool HP_image_transform;
+        private static bool HP_occlusion_test;
+        private static bool HP_texture_lighting;
+        private static bool IBM_cull_vertex;
+        private static bool IBM_multimode_draw_arrays;
+        private static bool IBM_rasterpos_clip;
+        private static bool IBM_static_data;
+        private static bool IBM_texture_mirrored_repeat;
+        private static bool IBM_vertex_array_lists;
+        private static bool INGR_blend_func_separate;
+        private static bool INGR_color_clamp;
+        private static bool INGR_interlace_read;
+        private static bool INTEL_blackhole_render;
+        private static bool INTEL_conservative_rasterization;
+        private static bool INTEL_fragment_shader_ordering;
+        private static bool INTEL_framebuffer_CMAA;
+        private static bool INTEL_map_texture;
+        private static bool INTEL_parallel_arrays;
+        private static bool INTEL_performance_query;
+        private static bool KHR_blend_equation_advanced;
+        private static bool KHR_blend_equation_advanced_coherent;
+        private static bool KHR_context_flush_control;
+        private static bool KHR_debug;
+        private static bool KHR_no_error;
+        private static bool KHR_parallel_shader_compile;
+        private static bool KHR_robust_buffer_access_behavior;
+        private static bool KHR_robustness;
+        private static bool KHR_shader_subgroup;
+        private static bool KHR_texture_compression_astc_hdr;
+        private static bool KHR_texture_compression_astc_ldr;
+        private static bool KHR_texture_compression_astc_sliced_3d;
+        private static bool MESA_framebuffer_flip_x;
+        private static bool MESA_framebuffer_flip_y;
+        private static bool MESA_framebuffer_swap_xy;
+        private static bool MESA_pack_invert;
+        private static bool MESA_program_binary_formats;
+        private static bool MESA_resize_buffers;
+        private static bool MESA_shader_integer_functions;
+        private static bool MESA_tile_raster_order;
+        private static bool MESA_window_pos;
+        private static bool MESA_ycbcr_texture;
+        private static bool MESAX_texture_stack;
+        private static bool NV_alpha_to_coverage_dither_control;
+        private static bool NV_bindless_multi_draw_indirect;
+        private static bool NV_bindless_multi_draw_indirect_count;
+        private static bool NV_bindless_texture;
+        private static bool NV_blend_equation_advanced;
+        private static bool NV_blend_equation_advanced_coherent;
+        private static bool NV_blend_minmax_factor;
+        private static bool NV_blend_square;
+        private static bool NV_clip_space_w_scaling;
+        private static bool NV_command_list;
+        private static bool NV_compute_program5;
+        private static bool NV_compute_shader_derivatives;
+        private static bool NV_conditional_render;
+        private static bool NV_conservative_raster;
+        private static bool NV_conservative_raster_dilate;
+        private static bool NV_conservative_raster_pre_snap;
+        private static bool NV_conservative_raster_pre_snap_triangles;
+        private static bool NV_conservative_raster_underestimation;
+        private static bool NV_copy_depth_to_color;
+        private static bool NV_copy_image;
+        private static bool NV_deep_texture3D;
+        private static bool NV_depth_buffer_float;
+        private static bool NV_depth_clamp;
+        private static bool NV_draw_texture;
+        private static bool NV_draw_vulkan_image;
+        private static bool NV_evaluators;
+        private static bool NV_explicit_multisample;
+        private static bool NV_fence;
+        private static bool NV_fill_rectangle;
+        private static bool NV_float_buffer;
+        private static bool NV_fog_distance;
+        private static bool NV_fragment_coverage_to_color;
+        private static bool NV_fragment_program;
+        private static bool NV_fragment_program_option;
+        private static bool NV_fragment_program2;
+        private static bool NV_fragment_program4;
+        private static bool NV_fragment_shader_barycentric;
+        private static bool NV_fragment_shader_interlock;
+        private static bool NV_framebuffer_mixed_samples;
+        private static bool NV_framebuffer_multisample_coverage;
+        private static bool NV_geometry_program4;
+        private static bool NV_geometry_shader_passthrough;
+        private static bool NV_geometry_shader4;
+        private static bool NV_gpu_multicast;
+        private static bool NV_gpu_program4;
+        private static bool NV_gpu_program5;
+        private static bool NV_gpu_program5_mem_extended;
+        private static bool NV_gpu_shader5;
+        private static bool NV_half_float;
+        private static bool NV_internalformat_sample_query;
+        private static bool NV_light_max_exponent;
+        private static bool NV_memory_attachment;
+        private static bool NV_memory_object_sparse;
+        private static bool NV_mesh_shader;
+        private static bool NV_multisample_coverage;
+        private static bool NV_multisample_filter_hint;
+        private static bool NV_occlusion_query;
+        private static bool NV_packed_depth_stencil;
+        private static bool NV_parameter_buffer_object;
+        private static bool NV_parameter_buffer_object2;
+        private static bool NV_path_rendering;
+        private static bool NV_path_rendering_shared_edge;
+        private static bool NV_pixel_data_range;
+        private static bool NV_point_sprite;
+        private static bool NV_present_video;
+        private static bool NV_primitive_restart;
+        private static bool NV_primitive_shading_rate;
+        private static bool NV_query_resource;
+        private static bool NV_query_resource_tag;
+        private static bool NV_register_combiners;
+        private static bool NV_register_combiners2;
+        private static bool NV_representative_fragment_test;
+        private static bool NV_robustness_video_memory_purge;
+        private static bool NV_sample_locations;
+        private static bool NV_sample_mask_override_coverage;
+        private static bool NV_scissor_exclusive;
+        private static bool NV_shader_atomic_counters;
+        private static bool NV_shader_atomic_float;
+        private static bool NV_shader_atomic_float64;
+        private static bool NV_shader_atomic_fp16_vector;
+        private static bool NV_shader_atomic_int64;
+        private static bool NV_shader_buffer_load;
+        private static bool NV_shader_buffer_store;
+        private static bool NV_shader_storage_buffer_object;
+        private static bool NV_shader_subgroup_partitioned;
+        private static bool NV_shader_texture_footprint;
+        private static bool NV_shader_thread_group;
+        private static bool NV_shader_thread_shuffle;
+        private static bool NV_shading_rate_image;
+        private static bool NV_stereo_view_rendering;
+        private static bool NV_tessellation_program5;
+        private static bool NV_texgen_emboss;
+        private static bool NV_texgen_reflection;
+        private static bool NV_texture_barrier;
+        private static bool NV_texture_compression_vtc;
+        private static bool NV_texture_env_combine4;
+        private static bool NV_texture_expand_normal;
+        private static bool NV_texture_multisample;
+        private static bool NV_texture_rectangle;
+        private static bool NV_texture_rectangle_compressed;
+        private static bool NV_texture_shader;
+        private static bool NV_texture_shader2;
+        private static bool NV_texture_shader3;
+        private static bool NV_timeline_semaphore;
+        private static bool NV_transform_feedback;
+        private static bool NV_transform_feedback2;
+        private static bool NV_uniform_buffer_std430_layout;
+        private static bool NV_uniform_buffer_unified_memory;
+        private static bool NV_vdpau_interop;
+        private static bool NV_vdpau_interop2;
+        private static bool NV_vertex_array_range;
+        private static bool NV_vertex_array_range2;
+        private static bool NV_vertex_attrib_integer_64bit;
+        private static bool NV_vertex_buffer_unified_memory;
+        private static bool NV_vertex_program;
+        private static bool NV_vertex_program1_1;
+        private static bool NV_vertex_program2;
+        private static bool NV_vertex_program2_option;
+        private static bool NV_vertex_program3;
+        private static bool NV_vertex_program4;
+        private static bool NV_video_capture;
+        private static bool NV_viewport_array2;
+        private static bool NV_viewport_swizzle;
+        private static bool NVX_blend_equation_advanced_multi_draw_buffers;
+        private static bool NVX_conditional_render;
+        private static bool NVX_gpu_memory_info;
+        private static bool NVX_gpu_multicast2;
+        private static bool NVX_linked_gpu_multicast;
+        private static bool NVX_progress_fence;
+        private static bool OES_byte_coordinates;
+        private static bool OES_compressed_paletted_texture;
+        private static bool OES_fixed_point;
+        private static bool OES_query_matrix;
+        private static bool OES_read_format;
+        private static bool OES_single_precision;
+        private static bool OML_interlace;
+        private static bool OML_resample;
+        private static bool OML_subsample;
+        private static bool OVR_multiview;
+        private static bool OVR_multiview2;
+        private static bool PGI_misc_hints;
+        private static bool PGI_vertex_hints;
+        private static bool REND_screen_coordinates;
+        private static bool S3_s3tc;
+        private static bool SGI_color_matrix;
+        private static bool SGI_color_table;
+        private static bool SGI_texture_color_table;
+        private static bool SGIS_detail_texture;
+        private static bool SGIS_fog_function;
+        private static bool SGIS_generate_mipmap;
+        private static bool SGIS_multisample;
+        private static bool SGIS_pixel_texture;
+        private static bool SGIS_point_line_texgen;
+        private static bool SGIS_point_parameters;
+        private static bool SGIS_sharpen_texture;
+        private static bool SGIS_texture_border_clamp;
+        private static bool SGIS_texture_color_mask;
+        private static bool SGIS_texture_edge_clamp;
+        private static bool SGIS_texture_filter4;
+        private static bool SGIS_texture_lod;
+        private static bool SGIS_texture_select;
+        private static bool SGIS_texture4D;
+        private static bool SGIX_async;
+        private static bool SGIX_async_histogram;
+        private static bool SGIX_async_pixel;
+        private static bool SGIX_blend_alpha_minmax;
+        private static bool SGIX_calligraphic_fragment;
+        private static bool SGIX_clipmap;
+        private static bool SGIX_convolution_accuracy;
+        private static bool SGIX_depth_pass_instrument;
+        private static bool SGIX_depth_texture;
+        private static bool SGIX_flush_raster;
+        private static bool SGIX_fog_offset;
+        private static bool SGIX_fragment_lighting;
+        private static bool SGIX_framezoom;
+        private static bool SGIX_igloo_interface;
+        private static bool SGIX_instruments;
+        private static bool SGIX_interlace;
+        private static bool SGIX_ir_instrument1;
+        private static bool SGIX_list_priority;
+        private static bool SGIX_pixel_texture;
+        private static bool SGIX_pixel_tiles;
+        private static bool SGIX_polynomial_ffd;
+        private static bool SGIX_reference_plane;
+        private static bool SGIX_resample;
+        private static bool SGIX_scalebias_hint;
+        private static bool SGIX_shadow;
+        private static bool SGIX_shadow_ambient;
+        private static bool SGIX_sprite;
+        private static bool SGIX_subsample;
+        private static bool SGIX_tag_sample_buffer;
+        private static bool SGIX_texture_add_env;
+        private static bool SGIX_texture_coordinate_clamp;
+        private static bool SGIX_texture_lod_bias;
+        private static bool SGIX_texture_multi_buffer;
+        private static bool SGIX_texture_scale_bias;
+        private static bool SGIX_vertex_preclip;
+        private static bool SGIX_ycrcb;
+        private static bool SGIX_ycrcb_subsample;
+        private static bool SGIX_ycrcba;
+        private static bool SUN_convolution_border_modes;
+        private static bool SUN_global_alpha;
+        private static bool SUN_mesh_array;
+        private static bool SUN_slice_accum;
+        private static bool SUN_triangle_list;
+        private static bool SUN_vertex;
+        private static bool SUNX_constant_data;
+        private static bool WIN_phong_shading;
+        private static bool WIN_specular_fog;
+
+        #endregion
+    }
+}

内核源代码/StgSharp/Graphics/OpenGL/glException.cs

@@ -0,0 +1,111 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="glException.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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.Diagnostics;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Runtime.Serialization;
+using System.Text;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public sealed class GlErrorOverflowException : Exception
+    {
+
+        public GlErrorOverflowException( int errorCount, uint errorCode )
+            : base(
+            "Too many opengl error detected at certain position. " + $"The amount of errors exceeds {errorCount}. " + $"Code of the last error is {errorCode}" ) { }
+
+    }
+
+    public sealed class GlExecutionException : Exception
+    {
+
+        public GlExecutionException( uint errorCode )
+            : base( $"Critical OpenGL error: {errorCode}" ) { }
+
+    }
+
+    public sealed class GlArrayFormatException : Exception
+    {
+
+        internal GlArrayFormatException( string message ) : base( message ) { }
+
+        internal GlArrayFormatException(
+            SerializationInfo info,
+            StreamingContext context )
+            : base( info, context ) { }
+
+        internal GlArrayFormatException(
+            string message,
+            Exception innerException )
+            : base( message, innerException ) { }
+
+        public GlArrayFormatException(
+            PixelChannelLayout layout,
+            string arrayname )
+            : base( $"{arrayname} cannot be used as layout of {layout}" ) { }
+
+    }
+
+    public static partial class GlHelper
+    {
+
+        public static bool CheckArrayFormat(
+            this Array array,
+            PixelChannelLayout layout )
+        {
+            return layout switch
+            {
+                PixelChannelLayout.Byte or PixelChannelLayout.UByte332 or PixelChannelLayout.UByte233Rev => ( array is byte[] ) || ( array is sbyte[] ),
+                PixelChannelLayout.Short => array is short[],
+                PixelChannelLayout.UShort => array is ushort[],
+                PixelChannelLayout.Int => array is int[],
+                PixelChannelLayout.Float => array is float[],
+                PixelChannelLayout.UShort4444 => ( array is ushort[] ) || ( array is byte[] ),
+                PixelChannelLayout.UByte => ( array is byte[] ) || ( array is sbyte[] ),
+                PixelChannelLayout.UInt => array is uint[],
+                PixelChannelLayout.UShort565 or
+                PixelChannelLayout.UShort565Rev or
+                PixelChannelLayout.UShort4444Rev or
+                PixelChannelLayout.UShort5551 or
+                PixelChannelLayout.UShort1555Rev => array is ushort[],
+                PixelChannelLayout.UInt8888Rev or
+                PixelChannelLayout.UInt1010102 or
+                PixelChannelLayout.UInt2101010Rev => array is int[],
+                PixelChannelLayout.UInt8888 => array is uint[] or byte[],
+                _ => false,
+            };
+        }
+
+    }
+}

内核源代码/StgSharp/Graphics/OpenGL/glFucntionSourceManager.cs

@@ -0,0 +1,92 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="glFucntionSourceManager.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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;
+
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public partial class OpenGLFunction
+    {
+
+        private Lazy<int> textureUnitCountGetter;
+        private Lazy<ConcurrentQueue<TextureUnit>> unusedTextureImageUintInitilizing;
+
+        public int TextureUnitCount
+        {
+            get => textureUnitCountGetter.Value;
+        }
+
+        private ConcurrentQueue<TextureUnit> UnusedTextureImageUint
+        {
+            get => unusedTextureImageUintInitilizing.Value;
+        }
+
+        internal void ReturnAvailableUnit( IEnumerable<TextureUnit> source )
+        {
+            int v = GLconst.TEXTURE0 + TextureUnitCount;
+            foreach( TextureUnit unit in source ) {
+                if( ( int )unit > v ) {
+                    throw new InvalidOperationException(
+                        "Source contains texture unit beyond context support." );
+                }
+            }
+        }
+
+        internal int TryGetAvailableTextureUnit(
+            int count,
+            out IEnumerable<TextureUnit> result )
+        {
+            result = new Queue<TextureUnit>();
+            for( int i = 0; i < count; i++ ) {
+                if( UnusedTextureImageUint.TryDequeue( out TextureUnit unit ) ) {
+                    ( result as Queue<TextureUnit> )!.Enqueue( unit );
+                } else {
+                    return i;
+                }
+            }
+            return count;
+        }
+
+        private ConcurrentQueue<TextureUnit> InitializeUnusedTextureImageUint()
+        {
+            ConcurrentQueue<TextureUnit> result = new ConcurrentQueue<TextureUnit>(
+                );
+            for( int index = 0; index < TextureUnitCount; index++ ) {
+                result.Enqueue( ( TextureUnit )( GLconst.TEXTURE0 + index ) );
+            }
+            return result;
+        }
+
+    }
+}

内核源代码/StgSharp/Graphics/OpenGL/glFunction.cs

@@ -0,0 +1,848 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="glFunction.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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;
+
+using StgSharp.Math;
+
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Runtime.ExceptionServices;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+
+namespace StgSharp
+{
+    internal static unsafe partial class InternalIO
+    {
+
+        [DllImport(
+            SSC_libName,
+            EntryPoint = "glCheckShaderStat",
+            CallingConvention = CallingConvention.Cdecl )]
+        #pragma warning disable CA5392
+        internal static extern int glCheckShaderStatus(
+            ref OpenglContext context,
+            uint shaderHandle,
+            int key,
+            ref IntPtr logPtr );
+#pragma warning restore CA5392
+    }
+}
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public unsafe partial class OpenGLFunction
+    {
+
+        private static Dictionary<IntPtr, OpenGLFunction> contextToGLMap = new Dictionary<IntPtr, OpenGLFunction>(
+            );
+        private static ThreadLocal<OpenGLFunction> _currentGL = new ThreadLocal<OpenGLFunction>(
+            );
+        private OpenglContext* _context;
+
+        private Lazy<int> _attachmentColorRange;
+
+        private OpenGLFunction()
+        {
+            textureUnitCountGetter = new Lazy<int>(
+                () => GetMaskInteger( GLconst.MAX_TEXTURE_IMAGE_UNITS ) );
+            unusedTextureImageUintInitilizing = new Lazy<ConcurrentQueue<TextureUnit>>(
+                InitializeUnusedTextureImageUint );
+            _attachmentColorRange = new Lazy<int>(
+                () => {
+                    return GetMaskInteger(
+                        ( uint )GLconst.MAX_COLOR_ATTACHMENTS );
+                } );
+        }
+
+        public int AttachmentColorRange
+        {
+            get => _attachmentColorRange.Value;
+        }
+
+        public static OpenGLFunction CurrentGL
+        {
+            get { return _currentGL.Value; }
+            internal set { _currentGL.Value = value; }
+        }
+
+        internal IntPtr ContextHandle => ( IntPtr )_context;
+
+        protected ref OpenglContext Context
+        {
+            get
+            {
+                #if DEBUG
+                if( ( IntPtr )_context == IntPtr.Zero ) {
+                    throw new NullReferenceException();
+                }
+                #endif
+                return ref ( *_context );
+            }
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void ActiveTextureUnit( uint type )
+        {
+            Context.glActiveTexture( type );
+        }
+
+        [Conditional( "DEBUG" )]
+        public void Assert( bool shouldReportWhenNormal )
+        {
+            uint code = Context.glGetError();
+            if( code != GLconst.NO_ERROR ) {
+                throw new GlExecutionException( code );
+            }
+            if( shouldReportWhenNormal ) {
+                Console.WriteLine( "OpenGL runs normally" );
+            }
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void AttachShader( GlHandle program, GlHandle shader )
+        {
+            Context.glAttachShader( program.Value, shader.Value );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void BindBuffer( BufferType bufferType, GlHandle handle )
+        {
+            Context.glBindBuffer( ( uint )bufferType, handle.Value );
+        }
+
+        /// <summary>
+        /// Bind a frame buffer to a frame buffer target Same function as <see
+        /// href="https://docs._gl/gl3/glBindFramebuffer">glBindFramebuffer</see>.
+        /// </summary>
+        /// <param name="target"> The frame buffer target of the binding operation. </param>
+        /// <param name="handle"> The handle of the frame buffer object to bind. </param>
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void BindFrameBuffer( FrameBufferTarget target, GlHandle handle )
+        {
+            Context.glBindFramebuffer( ( uint )target, handle.Value );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void BindRenderBuffer( GlHandle handle )
+        {
+            Context.glBindRenderbuffer( GLconst.RENDERBUFFER, handle.Value );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void BindTexture( uint type, GlHandle texture )
+        {
+            Context.glBindTexture( type, texture.Value );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void BindVertexArray( GlHandle handle )
+        {
+            Context.glBindVertexArray( handle.Value );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public FrameBufferStatus CheckFrameBufferStatus(
+            FrameBufferTarget target )
+        {
+            return ( FrameBufferStatus )Context.glCheckFramebufferStatus(
+                ( uint )target );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void Clear( MaskBufferBit mask )
+        {
+            Context.glClear( ( uint )mask );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public unsafe void ClearColor( float R, float G, float B, float A )
+        {
+            Context.glClearColor( R, G, B, A );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void ClearError()
+        {
+            uint code = 0;
+            for( int i = 0; i < 1024; i++ ) {
+                code = Context.glGetError();
+                if( code == 0 ) {
+                    return;
+                }
+
+                //Console.WriteLine(code);
+            }
+            foreach( ProcessThread thread in Process.GetCurrentProcess().Threads ) {
+                Debugger.Break();
+            }
+            throw new GlErrorOverflowException( 1024, code );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public unsafe void ClearGraphicError()
+        {
+            while( Context.glGetError() != 0 ) { }
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void CombineFrameBufferRenderBuffer(
+            FrameBufferAttachment attachment,
+            GlHandle rboHandle )
+        {
+            Context.glFramebufferRenderbuffer(
+                GLconst.FRAMEBUFFER, ( uint )attachment, GLconst.RENDERBUFFER,
+                rboHandle.Value );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void CompileShader( GlHandle shaderhandle )
+        {
+            Context.glCompileShader( shaderhandle.Value );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public unsafe GlHandle CreateGraphicProgram()
+        {
+            return GlHandle.Alloc( Context.glCreateProgram() );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public GlHandle CreateProgram()
+        {
+            return GlHandle.Alloc( Context.glCreateProgram() );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public unsafe GlHandle[] CreateProgram( int count )
+        {
+            GlHandle[] h = new GlHandle[count];
+            for( int i = 0; i < count; i++ ) {
+                h.SetValue( i, Context.glCreateProgram() );
+            }
+            return h;
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public GlHandle[] CreateShaderSet( int count, ShaderType type )
+        {
+            GlHandle[] ret = new GlHandle[count];
+            uint t = ( uint )type;
+            for( int i = 0; i < count; i++ ) {
+                uint id = Context.glCreateShader( t );
+                if( id == 0 ) {
+                    uint error = Context.glGetError();
+                    throw new InvalidOperationException(
+                        $"Failed in creating shader: {error}" );
+                }
+                ret[ i ] = GlHandle.Alloc( id );
+            }
+            return ret;
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public unsafe void DeleteBuffer( GlHandle handle )
+        {
+            Context.glDeleteBuffers( 1, ( uint* )&handle );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public unsafe void DeleteBuffers( GlHandle[] handle )
+        {
+            if( ( handle == null ) || ( handle.Length == 0 ) ) {
+                throw new ArgumentNullException( nameof( handle ) );
+            }
+            fixed( GlHandle* hptr = handle ) {
+                uint* iptr = ( uint* )hptr;
+                for( int i = 0; i < handle.Length; i++ ) {
+                    Context.glDeleteBuffers( 1, iptr + i );
+                }
+            }
+        }
+
+        /// <summary>
+        /// Delete a render buffer object Very simlilar function as <see
+        /// href="https://docs.gl/gl3/glDeleteRenderbuffers">glDeleteRenderbuffers</see>. The only
+        /// deifference is that this mehtod can only delete one renderbuffer at the same time.
+        /// </summary>
+        /// <param name="bufferHandle"> Handle to buffer to delete. </param>
+        public unsafe void DeleteRenderBuffer( GlHandle bufferHandle )
+        {
+            Context.glDeleteRenderbuffers( 1, &bufferHandle.Value );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public unsafe void DeleteVertexArrays( GlHandle[] arrays )
+        {
+            fixed( GlHandle* hptr = arrays ) {
+                uint* iptr = ( uint* )hptr;
+                for( int i = 0; i < arrays.Length; i++ ) {
+                    Context.glDeleteVertexArrays( 1, iptr + i );
+                }
+            }
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public unsafe void DrawElements(
+            GeometryType mode,
+            uint count,
+            TypeCode type,
+            IntPtr ptr )
+        {
+            uint a;
+            a = type switch
+            {
+                TypeCode.UInt32 => GLconst.UNSIGNED_INT,
+                TypeCode.UInt16 => GLconst.UNSIGNED_SHORT,
+                TypeCode.Byte => GLconst.UNSIGNED_BYTE,
+                _ => throw new ArgumentException(
+                    $"{$"{$"Parameter error in parameter {nameof(type)} method DrawElements. "}"}{$"{$"Only {typeof(uint).Name},{typeof(ushort).Name},{typeof(byte).Name} types are supported."}"}" )
+            };
+            Context.glDrawElements( ( uint )mode, count, a, ( void* )ptr );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void DrawElementsInstanced(
+            GeometryType mode,
+            uint count,
+            TypeCode type,
+            IntPtr ptr,
+            uint amount )
+        {
+            uint a;
+            switch( type ) {
+                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:
+                    InternalIO.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 );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void Enable( GLOperation operation )
+        {
+            Context.glEnable( ( uint )operation );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void FrameBufferTexture2d(
+            FrameBufferTarget target,
+            uint attachment,
+            Texture2DTarget texTarget,
+            GlHandle textureHandle,
+            int level )
+        {
+            Context.glFramebufferTexture2D(
+                ( uint )target, attachment, ( uint )texTarget,
+                textureHandle.Value, level );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public unsafe GlHandle[] GenBuffers( int count )
+        {
+            GlHandle[] h = new GlHandle[count];
+            fixed( GlHandle* hptr = h ) {
+                for( int i = 0; i < count; i++ ) {
+                    Context.glGenBuffers( count, ( ( uint* )hptr ) + i );
+                }
+            }
+            return h;
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void GenerateMipmap( Texture2DTarget target )
+        {
+            Context.glGenerateMipmap( ( uint )target );
+        }
+
+        public unsafe GlHandle[] GenFrameBuffers( int count )
+        {
+            GlHandle[] h = new GlHandle[count];
+            fixed( GlHandle* hptr = h ) {
+                Context.glGenFramebuffers( 1, ( uint* )hptr );
+            }
+            return h;
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public unsafe GlHandle[] GenRenderBuffer( int count )
+        {
+            GlHandle[] h = new GlHandle[count];
+            fixed( GlHandle* hptr = h ) {
+                Context.glGenRenderbuffers( count, ( uint* )hptr );
+            }
+            return h;
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public unsafe GlHandle[] GenTextures( int count )
+        {
+            GlHandle[] h = new GlHandle[count];
+            fixed( GlHandle* hptr = h ) {
+                Context.glGenTextures( count, ( uint* )hptr );
+            }
+            return h;
+        }
+
+        public unsafe GlHandle[] GenVertexArrays( int count )
+        {
+            GlHandle[] h = new GlHandle[count];
+            fixed( GlHandle* hptr = h ) {
+                Context.glGenVertexArrays( count, ( uint* )hptr );
+            }
+            return h;
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public uint GetError()
+        {
+            return Context.glGetError();
+        }
+
+        public unsafe int GetMaskInteger( uint statusCode )
+        {
+            int ret = 0;
+            Context.glGetIntegerv( statusCode, &ret );
+            return ret;
+        }
+
+        public string GetShaderStatus( Shader s, int index, int key )
+        {
+            IntPtr sptr = IntPtr.Zero;
+            if( InternalIO.glCheckShaderStatus(
+                ref Context, s.handle[ index ].Value, key, ref sptr ) == 0 ) {
+                return Marshal.PtrToStringAnsi( sptr );
+            }
+            return string.Empty;
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public unsafe void GetTextureImage<T>(
+            Texture2DTarget target,
+            int level,
+            ImageChannel channel,
+            PixelChannelLayout channelLayout,
+            T[] dataStream )
+            where T: struct,
+#if NET8_0_OR_GREATER
+            INumber
+#else
+            IConvertible
+        #endif
+        {
+            #pragma warning disable CS8500
+            fixed( T* tptr = dataStream ) {
+                Context.glGetTexImage(
+                    ( uint )target, level, ( uint )channel,
+                    ( uint )channelLayout, tptr );
+            }
+            #pragma warning restore CS8500
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void GetTextureLevelProperty(
+            uint textureTypeMask,
+            int level,
+            uint propertyMask,
+            out int propertyValue )
+        {
+            fixed( int* iptr = &propertyValue ) {
+                Context.glGetTexLevelParameteriv(
+                    textureTypeMask, level, propertyMask, iptr );
+            }
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public unsafe GlHandle GetUniformLocation(
+            GlHandle program,
+            string name )
+        {
+            byte[] code = Encoding.UTF8.GetBytes( name );
+            fixed( byte* ptr = code ) {
+                int ret = Context.glGetUniformLocation( program.Value, ptr );
+                #if DEBUG
+                if( ( ret == GLconst.INVALID_OPERATION ) || ( ret == GLconst.INVALID_VALUE ) ) {
+                    throw new InvalidOperationException();
+                }
+                if( ret == -1 ) {
+                    throw new UniformEmptyReferenceException(
+                        nameof( program ), name );
+                }
+                #endif
+                return GlHandle.SignedAlloc( ret );
+            }
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public unsafe void LoadShaderSource(
+            GlHandle shaderHandle,
+            byte[] codeStream )
+        {
+            fixed( byte* streamPtr = codeStream ) {
+                Context.glShaderSource(
+                    shaderHandle.Value, 1, &streamPtr, ( void* )0 );
+            }
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void ReadPixels(
+            (int X, int Y) beginPosition,
+            (int width, int height) size,
+            FrameBufferChannel format,
+            PixelChannelLayout dataType,
+            ref byte[] stream )
+        {
+            fixed( byte* bptr = stream ) {
+                Context.glReadPixels(
+                    beginPosition.X, beginPosition.Y, size.width, size.height,
+                    ( uint )format, ( uint )dataType, bptr );
+            }
+        }
+
+        public void RereadImage(
+            in Image i,
+            (int X, int Y) beginPosition,
+            FrameBufferChannel format,
+            PixelChannelLayout dataType )
+        {
+            byte[] pixels = i.PixelBuffer;
+            if( !pixels.CheckArrayFormat( dataType ) ) {
+                throw new GlArrayFormatException( dataType, "i.PixelArray" );
+            }
+            fixed( byte* bptr = pixels ) {
+                Context.glReadPixels(
+                    beginPosition.X, beginPosition.Y, i.Width, i.Height,
+                    ( uint )format, ( uint )dataType, bptr );
+            }
+            i.PixelUpdateCount++;
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public unsafe void SetBufferData<T>(
+            BufferType bufferType,
+            T bufferData,
+            BufferUsage usage )
+            where T: struct
+        {
+            int size = Marshal.SizeOf<T>();
+            #pragma warning disable CS8500
+            T* p = &bufferData;
+            #pragma warning restore CS8500
+            Context.glBufferData(
+                ( uint )bufferType, ( IntPtr )size, ( IntPtr )p,
+                ( uint )usage );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public unsafe void SetBufferData<T>(
+            BufferType bufferType,
+            T[] bufferArray,
+            BufferUsage usage )
+            where T: struct,
+#if NET8_0_OR_GREATER
+            INumber
+#else
+            IConvertible
+        #endif
+        {
+            int size = bufferArray.Length * Marshal.SizeOf( typeof( T ) );
+            if( bufferArray == null ) {
+                return;
+            }
+            #pragma warning disable CS8500
+            fixed( void* bufferPtr = bufferArray )
+ #pragma warning restore CS8500
+ {
+                Context.glBufferData(
+                    ( uint )bufferType, ( IntPtr )size, ( IntPtr )bufferPtr,
+                    ( uint )usage );
+            }
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public unsafe void SetBufferData<T>(
+            BufferType bufferType,
+            ReadOnlySpan<T> bufferArray,
+            BufferUsage usage )
+            where T: struct,
+#if NET8_0_OR_GREATER
+            INumber
+#else
+            IConvertible
+        #endif
+        {
+            int size = bufferArray.Length * Marshal.SizeOf( typeof( T ) );
+            if( bufferArray == null ) {
+                return;
+            }
+            #pragma warning disable CS8500
+            fixed( void* bufferPtr = bufferArray )
+ #pragma warning restore CS8500
+ {
+                Context.glBufferData(
+                    ( uint )bufferType, ( IntPtr )size, ( IntPtr )bufferPtr,
+                    ( uint )usage );
+            }
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public unsafe void SetBufferData<T>(
+            BufferType bufferType,
+            Span<T> bufferArray,
+            BufferUsage usage )
+            where T: struct,
+#if NET8_0_OR_GREATER
+            INumber
+#else
+            IConvertible
+        #endif
+        {
+            int size = bufferArray.Length * Marshal.SizeOf( typeof( T ) );
+            if( bufferArray == null ) {
+                return;
+            }
+
+            #pragma warning disable CS8500
+            fixed( void* bufferPtr = &bufferArray.GetPinnableReference() )
+ #pragma warning restore CS8500
+ {
+                Context.glBufferData(
+                    ( uint )bufferType, ( IntPtr )size, ( IntPtr )bufferPtr,
+                    ( uint )usage );
+            }
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public unsafe void SetBufferVectorData<T>(
+            BufferType bufferType,
+            ReadOnlySpan<T> bufferArray,
+            BufferUsage usage )
+            where T: struct, IVector
+        {
+            int size = bufferArray.Length * Marshal.SizeOf( typeof( T ) );
+            if( bufferArray == null ) {
+                return;
+            }
+            #pragma warning disable CS8500
+            fixed( void* bufferPtr = &bufferArray.GetPinnableReference() )
+ #pragma warning restore CS8500
+ {
+                Context.glBufferData(
+                    ( uint )bufferType, ( IntPtr )size, ( IntPtr )bufferPtr,
+                    ( uint )usage );
+            }
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public unsafe void SetBufferVectorData<T>(
+            BufferType bufferType,
+            T[] bufferArray,
+            BufferUsage usage )
+            where T: struct, IVector
+        {
+            int size = bufferArray.Length * Marshal.SizeOf( typeof( T ) );
+            if( bufferArray == null ) {
+                return;
+            }
+            #pragma warning disable CS8500
+            fixed( void* bufferPtr = bufferArray )
+ #pragma warning restore CS8500
+ {
+                Context.glBufferData(
+                    ( uint )bufferType, ( IntPtr )size, ( IntPtr )bufferPtr,
+                    ( uint )usage );
+            }
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public unsafe void SetRenderBufferStorage(
+            RenderBufferInternalFormat internalFormat,
+            (int width, int height) size )
+        {
+            Context.glRenderbufferStorage(
+                GLconst.RENDERBUFFER, ( uint )internalFormat, size.width,
+                size.height );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public unsafe void SetRenderBufferStorage(
+            RenderBufferInternalFormat internalFormat,
+            (uint width, uint height) size )
+        {
+            Context.glRenderbufferStorage(
+                GLconst.RENDERBUFFER, ( uint )internalFormat, ( int )size.width,
+                ( int )size.height );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void SetVertexAttribute(
+            uint index,
+            int size,
+            TypeCode t,
+            bool normalized,
+            uint stride,
+            int pointer )
+        {
+            uint type = InternalIO.GLtype[ t ];
+            Context.glVertexAttribPointer(
+                index, size, type, normalized ? 1 : 0, stride,
+                ( void* )pointer );
+            Context.glEnableVertexAttribArray( index );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void TextureImage2d<T>(
+            Texture2DTarget target,
+            int level,
+            ImageChannel sourceChannel,
+            uint width,
+            uint height,
+            ImageChannel targetChannel,
+            PixelChannelLayout type,
+            T[] pixels )
+            where T: struct,
+#if NET8_0_OR_GREATER
+            INumber
+#else
+            IConvertible
+        #endif
+        {
+            #pragma warning disable CS8500
+            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 );
+            }
+            #pragma warning restore CS8500
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void TextureImage2d<T>(
+            Texture2DTarget target,
+            int level,
+            ImageChannel sourceChannel,
+            uint width,
+            uint height,
+            ImageChannel targetChannel,
+            PixelChannelLayout type,
+            Span<T> pixelSpan )
+            where T: struct,
+#if NET8_0_OR_GREATER
+            INumber 
+#else
+            IConvertible
+        #endif
+        {
+            #pragma warning disable CS8500
+            fixed( T* tptr = pixelSpan ) {
+                Context.glTexImage2D(
+                    ( uint )target, level, ( uint )sourceChannel, width, height,
+                    0, ( uint )targetChannel, ( uint )type, tptr );
+            }
+            #pragma warning restore CS8500
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void TextureParameter( int target, uint pname, int param )
+        {
+            Context.glTexParameteri( ( uint )target, pname, param );
+        }
+
+        public static bool TryGetFunctionPackage(
+            IntPtr handle,
+            out OpenGLFunction functionPackage )
+        {
+            return contextToGLMap.TryGetValue( handle, out functionPackage );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void UseProgram( GlHandle program )
+        {
+            Context.glUseProgram( program.Value );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        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 );
+        }
+
+        public void WaitAccomplishment()
+        {
+            Context.glFinish();
+        }
+
+        internal static OpenGLFunction BuildGlFunctionPackage( IntPtr handle )
+        {
+            OpenGLFunction pack;
+            if( contextToGLMap.TryGetValue( handle, out pack ) ) {
+                return pack;
+            }
+            pack = new OpenGLFunction { _context = ( OpenglContext* )handle };
+            contextToGLMap.Add( handle, pack );
+            return pack;
+        }
+
+        ~OpenGLFunction()
+        {
+            contextToGLMap.Remove( ContextHandle );
+        }
+
+    }
+}
+

内核源代码/StgSharp/Graphics/OpenGL/glHandle.cs

@@ -0,0 +1,70 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="glHandle.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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.Data.Common;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Versioning;
+using System.Security.AccessControl;
+using System.Security.Cryptography;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    [StructLayout( LayoutKind.Explicit, Size = 4 )]
+    public struct GlHandle
+    {
+
+        [FieldOffset( 0 )] public int SignedValue;
+        [FieldOffset( 0 )] public uint Value;
+
+        public static GlHandle Zero
+        {
+            get => new GlHandle { Value = 0 };
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static GlHandle Alloc( uint value )
+        {
+            return new GlHandle { Value = value };
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static GlHandle SignedAlloc( int value )
+        {
+            return new GlHandle { SignedValue = value };
+        }
+
+    }
+}

内核源代码/StgSharp/Graphics/OpenGL/glRenderSourceGenrator.cs

@@ -0,0 +1,107 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="glRenderSourceGenrator.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public partial class glRender
+    {
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        protected AutoTextureGL CreateAutoTexture( int count )
+        {
+            return new AutoTextureGL( count, this );
+        }
+
+        /// <summary>
+        /// Create a set of <see cref="ElementBuffer" />.
+        /// </summary>
+        /// <param name="count"> Amount of EBO to be created. </param>
+        /// <returns></returns>
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        protected ElementBuffer CreateElementBuffer( int count )
+        {
+            return new ElementBuffer( count, this );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        protected FrameBuffer CreateFrameBuffer( int count )
+        {
+            return new FrameBuffer( count, this );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        protected RenderBuffer CreateRenderBuffer( int count )
+        {
+            return new RenderBuffer( count, this );
+        }
+
+        /// <summary>
+        /// Create a sets of <see cref="TextureGL" />
+        /// </summary>
+        /// <param name="count"> Amount of textures to be created. </param>
+        /// <returns></returns>
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        protected TextureGL CreateTexture( int count )
+        {
+            return new TextureGL( count, this );
+        }
+
+        /// <summary>
+        /// Create a set of <see cref="VertexArray" />.
+        /// </summary>
+        /// <param name="count"> Amount of VAO to be created. </param>
+        /// <returns></returns>
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        protected VertexArray CreateVertexArray( int count )
+        {
+            return new VertexArray( count, this );
+        }
+
+        /// <summary>
+        /// Create a set of <see cref="VertexBuffer" />.
+        /// </summary>
+        /// <param name="count"> Amount of Object to be created. </param>
+        /// <returns></returns>
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        protected VertexBuffer CreateVertexBuffer( int count )
+        {
+            return new VertexBuffer( count, this );
+        }
+
+    }
+}

内核源代码/StgSharp/Graphics/OpenGL/glRenderStream.cs

@@ -0,0 +1,191 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="glRenderStream.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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.Math;
+using StgSharp.Threading;
+
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public abstract partial class glRender : RenderStream
+    {
+
+        private protected static readonly ConcurrentDictionary<glRender, Thread> renderToThread
+            = new ConcurrentDictionary<glRender, Thread>();
+
+        private OpenGLFunction _context;
+
+        protected internal OpenGLFunction GL
+        {
+            get { return _context; }
+        }
+
+        /// <summary>
+        /// Initialize an opengl context and load all opengl functions.
+        /// </summary>
+        public unsafe void InitializeContext()
+        {
+            if( ContextHandle == default ) {
+                ContextHandle = Marshal.AllocHGlobal(
+                    Marshal.SizeOf( typeof( OpenglContext ) ) );
+                OpenglContext* contextID = ( OpenglContext* )ContextHandle;
+                contextID->glGetString = ( delegate*<uint, IntPtr> )IntPtr.Zero;
+            }
+            if( GL == null ) {
+                _context = OpenGLFunction.BuildGlFunctionPackage(
+                    ContextHandle );
+            }
+        }
+
+        /// <summary>
+        /// Initialize an OpenGl viewPortDisplay if current form has not been binded to any
+        /// viewPortDisplay.  and set the viewPortDisplay binded to current form as current OpenGL
+        /// viewPortDisplay.
+        /// </summary>
+        /// <exception cref="Exception">
+        /// Something goes wrong and StgSharp fails in creating a new OpenGL viewPortDisplay.
+        /// </exception>
+        public unsafe void MakeAsCurrentContext()
+        {
+            InternalIO.glfwMakeContextCurrent( CanvasHandle );
+            OpenGLFunction.CurrentGL = this.GL;
+        }
+
+        /// <inheritdoc />
+        public override void RenderEnd()
+        {
+            if( !renderToThread.TryGetValue( this,
+                                             out Thread t ) || t != Thread.CurrentThread ) {
+                throw new InvalidOperationException(
+                    $"Current render has had been binded to thread {t!.ManagedThreadId}" );
+            }
+            SwapBuffers();
+            renderToThread[ this ] = ThreadHelper.EmptyThread;
+            InternalIO.glfwMakeContextCurrent( IntPtr.Zero );
+            OpenGLFunction.CurrentGL = null;
+        }
+
+        /// <inheritdoc />
+        public override void RenderStart()
+        {
+            Thread current = Thread.CurrentThread;
+            if( !renderToThread.TryGetValue( this,
+                                             out Thread t ) || t == ThreadHelper.EmptyThread ) {
+                renderToThread[ this ] = current;
+                MakeAsCurrentContext();
+                return;
+            }
+            if( t != current ) {
+                throw new InvalidOperationException(
+                    $"Current render has had been binded to thread {t!.ManagedThreadId}" );
+            }
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public override void SetSizeLimit(
+            int minWidth,
+            int minHeight,
+            int maxWidth,
+            int maxHeight )
+        {
+            InternalIO.glfwSetWindowSizeLimits(
+                this.CanvasHandle, minWidth, minHeight, maxWidth, maxHeight );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        internal override sealed void PlatformSpecifiedInitialize()
+        {
+            InitializeContext();
+            MakeAsCurrentContext();
+            glManager.LoadOpenGLApiTo( BindedViewPortContext.GraphicHandle );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        internal override sealed void Terminate()
+        {
+            CustomizeDeinit();
+        }
+
+        protected override sealed Uniform<Matrix44> NativeCameraUniform(
+            ShaderProgram source,
+            string name )
+        {
+            NativeCamera.GainAllUniforms( source, name );
+            return NativeCamera.convertedUniform;
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        protected override sealed void NativeCameraViewRange(
+            Radius fieldOfRange,
+            Vec2 offset,
+            (float frontDepth, float backDepth) viewDepth )
+        {
+            NativeCamera.SetViewRange(
+                fieldOfRange, this.Size, offset, viewDepth );
+        }
+
+        protected override sealed void NativeCameraViewTarget(
+            Vec3 position,
+            Vec3 direction,
+            Vec3 up )
+        {
+            NativeCamera.SetViewDirection( position, direction, up );
+        }
+
+        #region Key Control
+
+        protected KeyStatus CheckKey( KeyboardKey key )
+        {
+            return InternalIO.glfwGetKey( this.CanvasHandle, ( int )key );
+        }
+
+        protected KeyStatus CheckKey( Mouse key )
+        {
+            return InternalIO.glfwGetKey( this.CanvasHandle, ( int )key );
+        }
+
+        protected KeyStatus CheckKey( Joystick key )
+        {
+            return InternalIO.glfwGetKey( this.CanvasHandle, ( int )key );
+        }
+
+        #endregion
+    }
+}

内核源代码/StgSharp/Graphics/OpenGL/glRenderThreadSecurity.cs

@@ -0,0 +1,49 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="glRenderThreadSecurity.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public partial class glRender
+    {
+
+        private static ConcurrentDictionary<Thread, glRender> threadLocalIndex
+            = new ConcurrentDictionary<Thread, glRender>();
+        private readonly SynchronizationContext mainThreadContext = SynchronizationContext.Current;
+
+    }
+}

内核源代码/StgSharp/Graphics/Pixels.cs

@@ -0,0 +1,81 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Pixels.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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.Runtime.InteropServices;
+using System.Text;
+
+namespace StgSharp.Graphics
+{
+    public interface IPixel
+    {
+
+        public float Red
+        {
+            get;
+            set;
+        }
+
+        public float Green
+        {
+            get;
+            set;
+        }
+
+        public float Blue
+        {
+            get;
+            set;
+        }
+
+        public float Alpha
+        {
+            get;
+            set;
+        }
+
+        internal int Size
+        {
+            get;
+        }
+
+    }
+
+    [StructLayout( LayoutKind.Explicit, Size = 32 )]
+    public unsafe struct Pixel32
+    {
+
+        [FieldOffset( 0 )] private unsafe fixed byte data[ 4 ];
+
+        internal int Size => 4;
+
+    }
+}

内核源代码/StgSharp/Graphics/PlainGeometryMesh.cs

@@ -0,0 +1,103 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="PlainGeometryMesh.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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.Geometries;
+using StgSharp.Math;
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace StgSharp.Graphics
+{
+    public class PlainGeometryMesh
+    {
+
+        private PlainGeometry _shape;
+        private TextureProvider _texture;
+
+        public PlainGeometryMesh(
+            [NotNull] PlainGeometry shape,
+            [NotNull] TextureProvider texture )
+        {
+            if( shape.VertexCount > texture.TextureCoordinate.Length ) {
+                throw new ArgumentException(
+                    paramName: nameof( texture ),
+                    message: "Amount of texture coordination is too less" );
+            }
+            _texture = texture;
+            _shape = shape;
+        }
+
+        //private Image _texture;
+
+        public PlainGeometryMesh(
+            PlainGeometry shape,
+            Image texture,
+            Vec2[] texCoord )
+        {
+            if( shape == null ) {
+                throw new ArgumentNullException( nameof( shape ) );
+            }
+            if( texCoord == null ) {
+                throw new ArgumentNullException( nameof( texCoord ) );
+            }
+
+            if( shape.VertexCount > texCoord.Length ) {
+                throw new ArgumentException(
+                    paramName: nameof( texCoord ),
+                    message: "Amount of texture coordination is too less" );
+            }
+            _texture = new TextureProvider( texture, texCoord );
+        }
+
+        public Vec4[] VertexArray => _shape.VertexStream;
+
+        public Image TextureImage
+        {
+            get => _texture.ProvideImage();
+            internal set => _texture.ReadImage( value );
+        }
+
+        public ReadOnlySpan<int> MeshIndices => _shape.VertexIndices;
+
+        public ReadOnlySpan<Vec4> TextureCoord => MemoryMarshal.Cast<Vec2, Vec4>(
+            _texture.TextureCoordinate );
+
+        public PlainGeometryMesh Resize( PlainGeometry newShape )
+        {
+            return new PlainGeometryMesh( newShape, _texture );
+        }
+
+    }
+}

内核源代码/StgSharp/Graphics/RenderStream.cs

@@ -0,0 +1,257 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="RenderStream.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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 StgSharp.Math;
+
+using StgSharp.MVVM;
+using StgSharp.MVVM.View;
+using StgSharp.Timing;
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Graphics
+{
+    public abstract class RenderStream
+    {
+
+        private protected (int x, int y, int z) _coordStretch;
+        private protected ViewPort primeArgs;
+        private Camera nativeCamera;
+        internal TimeSpanProvider _timeProvider;
+
+        public (int width, int height) Size
+        {
+            get => (Width, Height);
+        }
+
+        public abstract bool IsContextSharable
+        {
+            get;
+        }
+
+        public int Height
+        {
+            get => primeArgs.Height;
+        }
+
+        public int Width
+        {
+            get => primeArgs.Width;
+        }
+
+        public IntPtr Monitor
+        {
+            get => primeArgs.Monitor;
+            internal set => primeArgs.Monitor = value;
+        }
+
+        public string Name
+        {
+            get => primeArgs.Name;
+        }
+
+        public Vec2 GlobalCoordSize => (( Width * 1.0f ) / _coordStretch.x, ( Height * 1.0f ) / _coordStretch.y);
+
+        public ViewPort BindedViewPortContext
+        {
+            get => primeArgs;
+            internal set => primeArgs = value;
+        }
+
+        internal IntPtr CanvasHandle
+        {
+            get => primeArgs.ViewPortID;
+        }
+
+        internal IntPtr ContextHandle
+        {
+            get => primeArgs.GraphicHandle;
+            private protected set => primeArgs.GraphicHandle = value;
+        }
+
+        protected internal Camera NativeCamera
+        {
+            get => nativeCamera;
+            internal set => nativeCamera = value;
+        }
+
+        protected float FramePassed
+        {
+            get => _timeProvider.CurrentSpan;
+        }
+
+        protected int PassedFrames
+        {
+            get => _timeProvider.CurrentSpan;
+        }
+
+        protected float TimePassed
+        {
+            get => _timeProvider.CurrentSecond;
+        }
+
+        protected TimeSpanProvider TimeProvider
+        {
+            get => _timeProvider;
+        }
+
+        /// <summary>
+        /// Set the size limit of current form
+        /// </summary>
+        /// <param name="minWidth"> Minimum width of current form </param>
+        /// <param name="minHeight"> Minimum height of current form </param>
+        /// <param name="maxWidth"> Maximum width of current form </param>
+        /// <param name="maxHeight"> Maximum height of current form </param>
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public abstract void SetSizeLimit(
+            int minWidth,
+            int minHeight,
+            int maxWidth,
+            int maxHeight );
+
+        public static TTarget ShareContextFrom<TSource, TTarget>(
+            [NotNull]TSource source )
+            where TSource: RenderStream
+            where TTarget: RenderStream, new()
+        {
+            TTarget target = new TTarget();
+            target.Initialize(
+                source.BindedViewPortContext, source._coordStretch,
+                source._timeProvider );
+            return target;
+        }
+
+        /**/
+        protected internal static void PollEvents()
+        {
+            InternalIO.glfwPollEvents();
+        }
+
+        private protected void SwapBuffers()
+        {
+            InternalIO.glfwSwapBuffers( CanvasHandle );
+        }
+
+        /**/
+
+        #region native camera operation
+
+        protected abstract void NativeCameraViewRange(
+            Radius fieldOfRange,
+            Vec2 offset,
+            (float frontDepth, float backDepth) viewDepth );
+
+        protected abstract void NativeCameraViewTarget(
+            Vec3 position,
+            Vec3 direction,
+            Vec3 up );
+
+        /// <summary>
+        /// Get <see cref="Uniform{T}" />(TView is <see cref="Matrix44" />) uniform from a shader.
+        /// This uniform will be used as projection matrix of this camera. Additionally, for multi-
+        /// shader rendering, each shader requires a uniform,  so do not ignore return value of this
+        /// method.
+        /// </summary>
+        /// <param name="source"> Shader using this camera </param>
+        /// <param name="name"> ContextName of projection camera named in shader </param>
+        /// <returns>
+        /// <see cref="Uniform{T}" />(TView is <see cref="Matrix44" />) representing  projection
+        /// matrix in shader program.
+        /// </returns>
+        protected abstract Uniform<Matrix44> NativeCameraUniform(
+            ShaderProgram source,
+            string name );
+
+        #endregion
+
+        #region internal operation
+
+        public void Initialize(
+            ViewPort v,
+            (int, int, int) unitCubeSize,
+            TimeSpanProvider timeProvider )
+        {
+            if( v == null ) {
+                throw new ArgumentNullException( nameof( v ) );
+            }
+            primeArgs = v;
+            this._timeProvider = timeProvider;
+            _coordStretch = unitCubeSize;
+            nativeCamera = new Camera();
+            PlatformSpecifiedInitialize();
+            CustomizeInit();
+            InternalIO.glfwMakeContextCurrent( IntPtr.Zero );
+        }
+
+        internal abstract void PlatformSpecifiedInitialize();
+
+        internal abstract void Terminate();
+
+        #endregion
+
+        #region public operation
+
+        protected abstract void CustomizeDeinit();
+
+        protected abstract void CustomizeInit();
+
+        /// <summary>
+        /// Marking the start of current render operations,  and set this renser context as current.
+        /// </summary>
+        public abstract void RenderStart();
+
+        /// <summary>
+        /// Marking the end of current render operations,  and release the binding of this renser
+        /// context to current,  making it available for another thread as current.
+        /// </summary>
+        public abstract void RenderEnd();
+
+        #endregion
+
+        #region public resource generator
+
+        protected abstract Shader CreateShaderSegment(
+            ShaderType type,
+            int count );
+
+        protected abstract ShaderProgram CreateShaderProgram();
+
+    #endregion
+    }
+}

内核源代码/StgSharp/Graphics/ShaderEdit/ShaderGenerator.cs

@@ -0,0 +1,207 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="ShaderGenerator.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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;
+using StgSharp.Graphics.OpenGL;
+using StgSharp.Math;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.Serialization;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Graphics.ShaderEdit
+{
+    public class ShaderGenerator
+    {
+
+        private Dictionary<int, ShaderParameter> uniformDefine;
+        private List<string> codeList;
+        private List<ShaderFunction> usedShaderFunctions;
+
+        public Uniform<T> DefineUniform<T>( string name, int index )
+            where T: struct
+        {
+            ShaderParameter p = new ShaderParameter(
+                name, ShaderParameter.TypeMarshal<T>() );
+            uniformDefine.Add( index, p );
+
+            //return new Uniform<TView>();
+            throw new NotImplementedException();
+        }
+
+    }
+
+    public class ShaderFunction
+    {
+
+        private List<string> codeList;
+        private List<ShaderParameter> inputList;
+        private ShaderParameter outPut;
+        private string name;
+
+        public int ParameterCount => inputList.Count;
+
+        public void EmitCall(
+            ShaderFunction function,
+            ShaderParameter outPut,
+            params ShaderParameter[] inputParams )
+        {
+            if( inputParams.Length != function.ParameterCount ) {
+                // Param list length not equal
+                throw new ArgumentException(
+                    "Provided parameters does not match function's parameter list." );
+            }
+            if( !ShaderParameter.IsSameType( outPut, function.outPut ) ) {
+                // Type of returning value not qual
+                throw new Exception(
+                    "Provided parameters does not match function's parameter list." );
+            }
+            for( int i = 0; i < inputParams.Length; i++ ) {
+                if( !ShaderParameter.IsSameType(
+                    function.inputList[ i ], inputParams[ i ] ) ) {
+                    // Input type not match
+                    throw new Exception(
+                        "Provided parameters does not match function's parameter list." );
+                }
+            }
+            string codeLine = string.Empty;    // adding a line like " outvalue = Func(input1, input2,...); "
+            if( outPut != ShaderParameter.Void ) {
+                codeLine += $"{outPut.name} = ";
+            }
+            codeLine += $"{function.name}(";
+            foreach( ShaderParameter inputParam in inputParams ) {
+                codeLine += inputParam.name;
+            }
+            codeLine += ");\n";
+            codeList.Add( codeLine );
+        }
+
+    }
+
+    public class ShaderParameter
+    {
+
+        public static readonly ShaderParameter Void = new ShaderParameter(
+            string.Empty, InternalShaderType.Void );
+        internal readonly bool isReadOnly;
+        internal readonly InternalShaderType type;
+        internal readonly string name;
+
+        public ShaderParameter( string name, InternalShaderType type )
+        {
+            this.name = name;
+            this.type = type;
+            isReadOnly = false;
+        }
+
+        public static bool IsSameType(
+            ShaderParameter param1,
+            ShaderParameter param2 )
+        {
+            if( param1.type != InternalShaderType.Struct ) {
+                return param1.type == param2.type;
+            } else {
+                throw new Exception( "Struct is currently not supported." );
+            }
+        }
+
+        public static InternalShaderType TypeMarshal<T>() where T: struct
+        {
+            switch( Type.GetTypeCode( typeof( T ) ) ) {
+                case TypeCode.Single:
+                    return InternalShaderType.Float;
+                case TypeCode.Double:
+                    return InternalShaderType.Double;
+                case TypeCode.Int32:
+                    return InternalShaderType.Int;
+                case TypeCode.UInt32:
+                    return InternalShaderType.UInt;
+                default:
+                    break;
+            }
+            switch( typeof( T ).Name ) {
+                case "vec4d":
+                    return InternalShaderType.Vector4;
+                case "Matrix2x2":
+                    return InternalShaderType.Matrix2x2;
+                case "Matrix2x3":
+                    return InternalShaderType.Matrix2x3;
+                case "Matrix2x4":
+                    return InternalShaderType.Matrix2x4;
+                case "Matrix3x2":
+                    return InternalShaderType.Matrix3x2;
+                case "Matrix3x3":
+                    return InternalShaderType.Matrix3x3;
+                case "Matrix3x4":
+                    return InternalShaderType.Matrix3x4;
+                case "Matrix4x2":
+                    return InternalShaderType.Matrix4x2;
+                case "Matrix4x3":
+                    return InternalShaderType.Matrix4x3;
+                case "Matrix4x4":
+                    return InternalShaderType.Matrix4x4;
+                default:
+                    throw new ArgumentException(
+                        "Not supported shader data type." );
+            }
+        }
+
+    }
+
+    public enum InternalShaderType
+    {
+#pragma warning disable CS1591
+        Struct,
+        Void,
+        Int,
+        UInt,
+        Float,
+        Double,
+        Vector2,
+        Vector3,
+        Vector4,
+        VectorD2,
+        VectorD3,
+        VectorD4,
+        Matrix2x2,
+        Matrix2x3,
+        Matrix2x4,
+        Matrix3x2,
+        Matrix3x3,
+        Matrix3x4,
+        Matrix4x2,
+        Matrix4x3,
+        Matrix4x4,
+#pragma warning restore CS1591
+    }
+}

内核源代码/StgSharp/Graphics/ShaderEdit/ShaderStruct.cs

@@ -0,0 +1,97 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="ShaderStruct.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Graphics.ShaderEdit
+{
+    public class ShaderStructMember
+    {
+
+        internal InternalShaderType type;
+        internal object value;
+
+    }
+
+    public class ShaderStruct
+    {
+
+        internal Dictionary<GlHandle, ShaderStructMember> uniformPair;
+
+        internal ShaderStruct() { }
+
+        public ShaderStruct(
+            params (GlHandle, ShaderStructMember)[] uniformPairs )
+        {
+            uniformPair = new Dictionary<GlHandle, ShaderStructMember>();
+            if( uniformPairs.Length == 0 ) {
+                return;
+            }
+
+            foreach( (GlHandle, ShaderStructMember) item in uniformPairs ) {
+                uniformPair.Add( item.Item1, item.Item2 );
+            }
+        }
+
+        public unsafe void SetAllUniforms()
+        {
+            OpenglContext* gl = ( OpenglContext* )OpenGL.OpenGLFunction.CurrentGL.ContextHandle;
+            foreach( KeyValuePair<GlHandle, ShaderStructMember> uniform in uniformPair ) {
+                int id = uniform.Key.SignedValue;
+                ShaderStructMember s = uniform.Value;
+                switch( s.type ) {
+                    case InternalShaderType.Struct:
+                        throw new ArgumentException(
+                            "Incorrect type \"Struct\" defined in this self define type" );
+                    case InternalShaderType.Void:
+                        throw new ArgumentException(
+                            "Incorrect type \"Void\" defined in this self define type" );
+                    case InternalShaderType.Float:
+                        gl->glUniform1f( id, ( float )s.value );
+                        break;
+                    case InternalShaderType.Int:
+                        gl->glUniform1f( id, ( int )s.value );
+                        break;
+                    default:
+                        throw new NotImplementedException();
+                        throw new ArgumentException(
+                            "Incorrect type \"Unknown\" defined in this self define type" );
+                }
+            }
+        }//------------------------------------ End of Class ---------------------------------------
+
+    }
+}

内核源代码/StgSharp/Graphics/TextureBufferImage.cs

@@ -0,0 +1,98 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="TextureBufferImage.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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;
+using StgSharp.Graphics.OpenGL;
+using StgSharp.Math;
+
+using System;
+
+namespace StgSharp.Graphics
+{
+    public class TextureImage : IImageProvider
+    {
+
+        private byte[] _data;
+        private ImageInfo _imageInfo;
+        private int _pixelUpdateCount = 0;
+
+        public TextureImage(
+            Vec2 size,
+            ImageChannel channel,
+            PixelChannelLayout layout,
+            int bufferSize )
+        {
+            this._imageInfo = new ImageInfo
+            {
+                Width = ( int )size.X,
+                Height = ( int )size.Y,
+                Channel = channel,
+                pixelLayout = layout,
+            };
+            if( bufferSize < _imageInfo.Width * _imageInfo.Height * GlHelper.GetPixelSize(
+                layout, channel ) ) {
+                throw new OverflowException(
+                    "Size of data buffer is smaller than default image size." );
+            }
+            _data = new byte[bufferSize];
+        }
+
+        public int Width
+        {
+            get => _imageInfo.Width;
+            internal set => _imageInfo.Width = value;
+        }
+
+        public int Height
+        {
+            get => _imageInfo.Height;
+            internal set => _imageInfo.Height = value;
+        }
+
+        public Image ProvideImage()
+        {
+            return Image.FromMemory( _imageInfo, _data, _pixelUpdateCount );
+        }
+
+        public void Resize( int width, int height )
+        {
+            if( _data.Length < width * height * GlHelper.GetPixelSize(
+                _imageInfo.pixelLayout, _imageInfo.Channel ) ) {
+                throw new OverflowException(
+                    "Size of image is larger than capacity of sata buffer." );
+            }
+            Width = width;
+            Height = height;
+            _pixelUpdateCount++;
+        }
+
+    }
+}

内核源代码/StgSharp/Graphics/TexturePipeline.cs

@@ -0,0 +1,60 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="TexturePipeline.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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.BluePrint;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Graphics
+{
+    public class TexturePipeline : BlueprintPipelineArgs
+    {
+
+        private Image _value;
+
+        public TexturePipeline( Image i )
+        {
+            _value = i;
+        }
+
+        public new Image Value
+        {
+            get => _value;
+            set => _value = value ??
+                throw new ArgumentNullException( nameof( value ) );
+        }
+
+    }
+}

内核源代码/StgSharp/Graphics/TextureProvider.cs

@@ -0,0 +1,86 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="TextureProvider.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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.Math;
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace StgSharp.Graphics
+{
+    public class TextureProvider : IImageProvider
+    {
+
+        private Vec2[] _texCoord;
+        private Image _tex;
+
+        public TextureProvider( Image image, Vec2[] coord )
+        {
+            _tex = image;
+            _texCoord = coord;
+        }
+
+        public ref Vec2 this[ int index ]
+        {
+            get => ref _texCoord[ index ];
+        }
+
+        public Span<Vec2> TextureCoordinate
+        {
+            get => new Span<Vec2>( _texCoord );
+        }
+
+        public Image ProvideImage()
+        {
+            return _tex;
+        }
+
+        public void ReadImage( IImageProvider provider )
+        {
+            _tex = provider.ProvideImage();
+        }
+
+        public void UpdateFromImage( Image i )
+        {
+            if( i == _tex ) {
+                return;
+            }
+            if( i.Size == _tex.Size ) {
+                _tex = i;
+            } else {
+                throw new ArgumentException(
+                    $"Size of {nameof(i)} does not equals to current image." );
+            }
+        }
+
+    }
+}

内核源代码/StgSharp/Graphics/Vulkan/vkHandle.cs

@@ -0,0 +1,51 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="vkHandle.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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.Runtime.InteropServices;
+using System.Security;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Graphics.Vulkan
+{
+    [StructLayout( LayoutKind.Explicit, Size = 8 )]
+    public struct vkHandle
+    {
+
+        [FieldOffset( 0 )] public int SignedHalfValue;
+        [FieldOffset( 0 )] public IntPtr Handle;
+        [FieldOffset( 0 )] public IntPtr UnsignedHandle;
+        [FieldOffset( 0 )] public uint HalfValue;
+
+    }
+}

内核源代码/StgSharp/Graphics/framework.cs

@@ -0,0 +1,509 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="framework.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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;
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+
+#if Windows
+// using Windows.Win32;
+#endif
+
+namespace StgSharp
+{
+    internal partial class InternalIO
+    {
+
+        #region api call
+
+        [DllImport( SSC_libName, EntryPoint = "glfwInit" )] internal static extern unsafe int glfwInit(
+                                                                );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwTerminate" )] internal static extern unsafe void glfwTerminate(
+                                                                     );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwInitHint" )] internal static extern unsafe void glfwInitHint(
+                                                                    int hint,
+                                                                    int value );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetVersion" )] internal static extern unsafe void glfwGetVersion(
+                                                                      int* major,
+                                                                      int* minor,
+                                                                      int* rev );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetVersionString" )] internal static extern unsafe byte* glfwGetVersionString(
+                                                                            );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetError" )] internal static extern unsafe int glfwGetError(
+                                                                    byte** description );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetErrorCallback" )] internal static extern unsafe GLFWerrorfun glfwSetErrorCallback(
+                                                                            GLFWerrorfun callback );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetMonitors" )] internal static extern unsafe IntPtr* glfwGetMonitors(
+                                                                       int* count );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetPrimaryMonitor" )] internal static extern unsafe IntPtr glfwGetPrimaryMonitor(
+                                                                             );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetMonitorPos" )] internal static extern unsafe void glfwGetMonitorPos(
+                                                                         IntPtr monitor,
+                                                                         int* xpos,
+                                                                         int* ypos );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetMonitorWorkarea" )] internal static extern unsafe void glfwGetMonitorWorkarea(
+                                                                              IntPtr monitor,
+                                                                              int* xpos,
+                                                                              int* ypos,
+                                                                              int* width,
+                                                                              int* height );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetMonitorPhysicalSize" )] internal static extern unsafe void glfwGetMonitorPhysicalSize(
+                                                                                  IntPtr monitor,
+                                                                                  int* widthMM,
+                                                                                  int* heightMM );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetMonitorContentScale" )] internal static extern unsafe void glfwGetMonitorContentScale(
+                                                                                  IntPtr monitor,
+                                                                                  float* xscale,
+                                                                                  float* yscale );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetMonitorName" )] internal static extern unsafe byte* glfwGetMonitorName(
+                                                                          IntPtr monitor );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetMonitorUserPointer" )] internal static extern unsafe void glfwSetMonitorUserPointer(
+                                                                                 IntPtr monitor,
+                                                                                 void* pointer );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetMonitorUserPointer" )] internal static extern unsafe void* glfwGetMonitorUserPointer(
+                                                                                 IntPtr monitor );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetMonitorCallback" )] internal static extern unsafe GLFWmonitorfun glfwSetMonitorCallback(
+                                                                              GLFWmonitorfun callback );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetVideoModes" )] internal static extern unsafe glfwVideomode* glfwGetVideoModes(
+                                                                         IntPtr monitor,
+                                                                         int* count );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetVideoMode" )] internal static extern unsafe glfwVideomode* glfwGetVideoMode(
+                                                                        IntPtr monitor );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetGamma" )] internal static extern unsafe void glfwSetGamma(
+                                                                    IntPtr monitor,
+                                                                    float gamma );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetGammaRamp" )] internal static extern unsafe glfwGammaramp* glfwGetGammaRamp(
+                                                                        IntPtr monitor );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetGammaRamp" )] internal static extern unsafe void glfwSetGammaRamp(
+                                                                        IntPtr monitor,
+                                                                        glfwGammaramp* ramp );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwDefaultWindowHints" )] internal static extern unsafe void glfwDefaultWindowHints(
+                                                                              );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwWindowHint" )] internal static extern unsafe void glfwWindowHint(
+                                                                      int hint,
+                                                                      int value );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwWindowHintString" )] internal static extern unsafe void glfwWindowHintString(
+                                                                            int hint,
+                                                                            byte* value );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwCreateWindow" )] internal static extern unsafe IntPtr glfwCreateWindow(
+                                                                        int width,
+                                                                        int height,
+                                                                        byte[] title,
+                                                                        IntPtr monitor,
+                                                                        IntPtr share );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwDestroyWindow" )] internal static extern unsafe void glfwDestroyWindow(
+                                                                         IntPtr window );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwWindowShouldClose" )] internal static extern unsafe int glfwWindowShouldClose(
+                                                                             IntPtr window );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetWindowShouldClose" )] internal static extern unsafe void glfwSetWindowShouldClose(
+                                                                                IntPtr window,
+                                                                                int value );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetWindowTitle" )] internal static extern unsafe void glfwSetWindowTitle(
+                                                                          IntPtr window,
+                                                                          byte* title );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetWindowIcon" )] internal static extern unsafe void glfwSetWindowIcon(
+                                                                         IntPtr window,
+                                                                         int count,
+                                                                         GLFWimage* images );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetWindowPos" )] internal static extern unsafe void glfwGetWindowPos(
+                                                                        IntPtr window,
+                                                                        int* xpos,
+                                                                        int* ypos );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetWindowPos" )] internal static extern unsafe void glfwSetWindowPos(
+                                                                        IntPtr window,
+                                                                        int xpos,
+                                                                        int ypos );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetWindowSize" )] internal static extern unsafe void glfwGetWindowSize(
+                                                                         IntPtr window,
+                                                                         int* width,
+                                                                         int* height );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetWindowSizeLimits" )] internal static extern unsafe void glfwSetWindowSizeLimits(
+                                                                               IntPtr window,
+                                                                               int minwidth,
+                                                                               int minheight,
+                                                                               int maxwidth,
+                                                                               int maxheight );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetWindowAspectRatio" )] internal static extern unsafe void glfwSetWindowAspectRatio(
+                                                                                IntPtr window,
+                                                                                int numer,
+                                                                                int denom );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetWindowSize" )] internal static extern unsafe void glfwSetWindowSize(
+                                                                         IntPtr window,
+                                                                         int width,
+                                                                         int height );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetFramebufferSize" )] internal static extern unsafe void glfwGetFramebufferSize(
+                                                                              IntPtr window,
+                                                                              int* width,
+                                                                              int* height );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetWindowFrameSize" )] internal static extern unsafe void glfwGetWindowFrameSize(
+                                                                              IntPtr window,
+                                                                              int* left,
+                                                                              int* top,
+                                                                              int* right,
+                                                                              int* bottom );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetWindowContentScale" )] internal static extern unsafe void glfwGetWindowContentScale(
+                                                                                 IntPtr window,
+                                                                                 float* xscale,
+                                                                                 float* yscale );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetWindowOpacity" )] internal static extern unsafe float glfwGetWindowOpacity(
+                                                                            IntPtr window );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetWindowOpacity" )] internal static extern unsafe void glfwSetWindowOpacity(
+                                                                            IntPtr window,
+                                                                            float opacity );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwIconifyWindow" )] internal static extern unsafe void glfwIconifyWindow(
+                                                                         IntPtr window );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwRestoreWindow" )] internal static extern unsafe void glfwRestoreWindow(
+                                                                         IntPtr window );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwMaximizeWindow" )] internal static extern unsafe void glfwMaximizeWindow(
+                                                                          IntPtr window );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwShowWindow" )] internal static extern unsafe void glfwShowWindow(
+                                                                      IntPtr window );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwHideWindow" )] internal static extern unsafe void glfwHideWindow(
+                                                                      IntPtr window );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwFocusWindow" )] internal static extern unsafe void glfwFocusWindow(
+                                                                       IntPtr window );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwRequestWindowAttention" )] internal static extern unsafe void glfwRequestWindowAttention(
+                                                                                  IntPtr window );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetWindowMonitor" )] internal static extern unsafe IntPtr glfwGetWindowMonitor(
+                                                                            IntPtr window );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetWindowMonitor" )] internal static extern unsafe void glfwSetWindowMonitor(
+                                                                            IntPtr window,
+                                                                            IntPtr monitor,
+                                                                            int xpos,
+                                                                            int ypos,
+                                                                            int width,
+                                                                            int height,
+                                                                            int refreshRate );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetWindowAttrib" )] internal static extern unsafe int glfwGetWindowAttrib(
+                                                                           IntPtr window,
+                                                                           int attrib );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetWindowAttrib" )] internal static extern unsafe void glfwSetWindowAttrib(
+                                                                           IntPtr window,
+                                                                           int attrib,
+                                                                           int value );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetWindowUserPointer" )] internal static extern unsafe void glfwSetWindowUserPointer(
+                                                                                IntPtr window,
+                                                                                void* pointer );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetWindowUserPointer" )] internal static extern unsafe void* glfwGetWindowUserPointer(
+                                                                                IntPtr window );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetWindowPosCallback" )] internal static extern unsafe GLFWwindowposfun glfwSetWindowPosCallback(
+                                                                                IntPtr window,
+                                                                                IntPtr callback );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetWindowSizeCallback" )] internal static extern unsafe GLFWwindowsizefun glfwSetWindowSizeCallback(
+                                                                                 IntPtr window,
+                                                                                 GLFWwindowsizefun callback );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetWindowCloseCallback" )] internal static extern unsafe GLFWwindowclosefun glfwSetWindowCloseCallback(
+                                                                                  IntPtr window,
+                                                                                  GLFWwindowclosefun callback );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetWindowRefreshCallback" )] internal static extern unsafe GLFWwindowrefreshfun glfwSetWindowRefreshCallback(
+                                                                                    IntPtr window,
+                                                                                    GLFWwindowrefreshfun callback );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetWindowFocusCallback" )] internal static extern unsafe GLFWwindowfocusfun glfwSetWindowFocusCallback(
+                                                                                  IntPtr window,
+                                                                                  GLFWwindowfocusfun callback );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetWindowIconifyCallback" )] internal static extern unsafe GLFWwindowiconifyfun glfwSetWindowIconifyCallback(
+                                                                                    IntPtr window,
+                                                                                    GLFWwindowiconifyfun callback );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetWindowMaximizeCallback" )] internal static extern unsafe GLFWwindowmaximizefun glfwSetWindowMaximizeCallback(
+                                                                                     IntPtr window,
+                                                                                     GLFWwindowmaximizefun callback );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetFramebufferSizeCallback" )] internal static extern unsafe FrameBufferSizeHandler glfwSetFramebufferSizeCallback(
+                                                                                      IntPtr window,
+                                                                                      IntPtr callback );
+
+        [DllImport(
+            SSC_libName,
+            EntryPoint = "glfwSetWindowContentScaleCallback" )] internal static extern unsafe GLFWwindowcontentscalefun glfwSetWindowContentScaleCallback(
+                                                                    IntPtr window,
+                                                                    GLFWwindowcontentscalefun callback );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwPollEvents" )] internal static extern unsafe void glfwPollEvents(
+                                                                      );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwWaitEvents" )] internal static extern unsafe void glfwWaitEvents(
+                                                                      );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwWaitEventsTimeout" )] internal static extern unsafe void glfwWaitEventsTimeout(
+                                                                             double timeout );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwPostEmptyEvent" )] internal static extern unsafe void glfwPostEmptyEvent(
+                                                                          );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetInputMode" )] internal static extern unsafe int glfwGetInputMode(
+                                                                        IntPtr window,
+                                                                        int mode );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetInputMode" )] internal static extern unsafe void glfwSetInputMode(
+                                                                        IntPtr window,
+                                                                        int mode,
+                                                                        int value );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwRawMouseMotionSupported" )] internal static extern unsafe int glfwRawMouseMotionSupported(
+                                                                                   );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetKeyName" )] internal static extern unsafe byte* glfwGetKeyName(
+                                                                      int key,
+                                                                      int scancode );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetKeyScancode" )] internal static extern unsafe int glfwGetKeyScancode(
+                                                                          int key );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetKey" )] internal static extern unsafe KeyStatus glfwGetKey(
+                                                                  IntPtr window,
+                                                                  int key );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetMouseButton" )] internal static extern unsafe int glfwGetMouseButton(
+                                                                          IntPtr window,
+                                                                          int button );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetCursorPos" )] internal static extern unsafe void glfwGetCursorPos(
+                                                                        IntPtr window,
+                                                                        double* xpos,
+                                                                        double* ypos );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetCursorPos" )] internal static extern unsafe void glfwSetCursorPos(
+                                                                        IntPtr window,
+                                                                        double xpos,
+                                                                        double ypos );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwCreateCursor" )] internal static extern unsafe GLFWcursor* glfwCreateCursor(
+                                                                        GLFWimage* image,
+                                                                        int xhot,
+                                                                        int yhot );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwCreateStandardCursor" )] internal static extern unsafe GLFWcursor* glfwCreateStandardCursor(
+                                                                                int shape );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwDestroyCursor" )] internal static extern unsafe void glfwDestroyCursor(
+                                                                         GLFWcursor* cursor );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetCursor" )] internal static extern unsafe void glfwSetCursor(
+                                                                     IntPtr window,
+                                                                     GLFWcursor* cursor );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetKeyCallback" )] internal static extern unsafe GLFWkeyfun glfwSetKeyCallback(
+                                                                          IntPtr window,
+                                                                          GLFWkeyfun callback );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetCharCallback" )] internal static extern unsafe GLFWcharfun glfwSetCharCallback(
+                                                                           IntPtr window,
+                                                                           GLFWcharfun callback );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetCharModsCallback" )] internal static extern unsafe GLFWcharmodsfun glfwSetCharModsCallback(
+                                                                               IntPtr window,
+                                                                               GLFWcharmodsfun callback );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetMouseButtonCallback" )] internal static extern unsafe GLFWmousebuttonfun glfwSetMouseButtonCallback(
+                                                                                  IntPtr window,
+                                                                                  GLFWmousebuttonfun callback );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetCursorPosCallback" )] internal static extern unsafe GLFWcursorposfun glfwSetCursorPosCallback(
+                                                                                IntPtr window,
+                                                                                GLFWcursorposfun callback );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetCursorEnterCallback" )] internal static extern unsafe GLFWcursorenterfun glfwSetCursorEnterCallback(
+                                                                                  IntPtr window,
+                                                                                  GLFWcursorenterfun callback );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetScrollCallback" )] internal static extern unsafe GLFWscrollfun glfwSetScrollCallback(
+                                                                             IntPtr window,
+                                                                             GLFWscrollfun callback );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetDropCallback" )] internal static extern unsafe GLFWdropfun glfwSetDropCallback(
+                                                                           IntPtr window,
+                                                                           GLFWdropfun callback );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwJoystickPresent" )] internal static extern unsafe int glfwJoystickPresent(
+                                                                           int jid );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetJoystickAxes" )] internal static extern unsafe float* glfwGetJoystickAxes(
+                                                                           int jid,
+                                                                           int* count );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetJoystickButtons" )] internal static extern unsafe byte* glfwGetJoystickButtons(
+                                                                              int jid,
+                                                                              int* count );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetJoystickHats" )] internal static extern unsafe byte* glfwGetJoystickHats(
+                                                                           int jid,
+                                                                           int* count );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetJoystickName" )] internal static extern unsafe byte* glfwGetJoystickName(
+                                                                           int jid );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetJoystickGUID" )] internal static extern unsafe byte* glfwGetJoystickGUID(
+                                                                           int jid );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetJoystickUserPointer" )] internal static extern unsafe void glfwSetJoystickUserPointer(
+                                                                                  int jid,
+                                                                                  void* pointer );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetJoystickUserPointer" )] internal static extern unsafe void* glfwGetJoystickUserPointer(
+                                                                                  int jid );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwJoystickIsGamepad" )] internal static extern unsafe int glfwJoystickIsGamepad(
+                                                                             int jid );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetJoystickCallback" )] internal static extern unsafe GLFWjoystickfun glfwSetJoystickCallback(
+                                                                               GLFWjoystickfun callback );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwUpdateGamepadMappings" )] internal static extern unsafe int glfwUpdateGamepadMappings(
+                                                                                 byte* str );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetGamepadName" )] internal static extern unsafe byte* glfwGetGamepadName(
+                                                                          int jid );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetGamepadState" )] internal static extern unsafe int glfwGetGamepadState(
+                                                                           int jid,
+                                                                           GLFWgamepadstate* state );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetClipboardString" )] internal static extern unsafe void glfwSetClipboardString(
+                                                                              IntPtr window,
+                                                                              byte* str );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetClipboardString" )] internal static extern unsafe byte* glfwGetClipboardString(
+                                                                              IntPtr window );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetTime" )] internal static extern unsafe double glfwGetTime(
+                                                                   );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSetTime" )] internal static extern unsafe void glfwSetTime(
+                                                                   double time );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetTimerValue" )] internal static extern unsafe ulong* glfwGetTimerValue(
+                                                                         );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetTimerFrequency" )] internal static extern unsafe ulong* glfwGetTimerFrequency(
+                                                                             );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwMakeContextCurrent" )] internal static extern unsafe void glfwMakeContextCurrent(
+                                                                              IntPtr window );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwGetCurrentContext" )] internal static extern unsafe IntPtr glfwGetCurrentContext(
+                                                                             );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSwapBuffers" )] internal static extern unsafe void glfwSwapBuffers(
+                                                                       IntPtr window );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwSwapInterval" )] internal static extern unsafe void glfwSwapInterval(
+                                                                        int interval );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwExtensionSupported" )] internal static extern unsafe int glfwExtensionSupported(
+                                                                              byte* extension );
+
+        [DllImport(
+            SSC_libName,
+            EntryPoint = "glfwGetProcAddress",
+            CharSet = CharSet.Ansi )] internal static extern unsafe IntPtr glfwGetProcAddress(
+                                          string procname );
+
+        [DllImport( SSC_libName, EntryPoint = "glfwVulkanSupported" )] internal static extern unsafe int glfwVulkanSupported(
+                                                                           );
+
+        [DllImport(
+            SSC_libName,
+            EntryPoint = "glfwGetRequiredInstanceExtensions" )] internal static extern unsafe byte** glfwGetRequiredInstanceExtensions(
+                                                                    uint* count );
+
+        //[DllImport(InternalIO.SSC_libname, EntryPoint = "glfwGetInstanceProcAddress")] internal extern unsafe static GLFWvkproc glfwGetInstanceProcAddress(VkInstance instance, byte* procname);
+        //[DllImport(InternalIO.SSC_libname, EntryPoint = "glfwGetPhysicalDevicePresentationSupport")] internal extern unsafe static int glfwGetPhysicalDevicePresentationSupport(VkInstance instance, VkPhysicalDevice device, uint* queuefamily);
+        //[DllImport(InternalIO.SSC_libname, EntryPoint = "glfwCreateWindowSurface")] internal extern unsafe static VkResult glfwCreateWindowSurface(VkInstance instance, glfwWindow* window, VkAllocationCallbacks* allocator, VkSurfaceKHR* surface);
+
+        #endregion api call
+    }
+}

内核源代码/StgSharp/Graphics/frameworkSyncContext.cs

@@ -0,0 +1,78 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="frameworkSyncContext.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. 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.Concurrent;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace StgSharp.Threading
+{
+    public class FrameworkSyncContext : SynchronizationContext
+    {
+
+        private static readonly FrameworkSyncContext _mainThreadContext = new FrameworkSyncContext(
+            );
+
+        private readonly BlockingCollection<SendOrPostCallback> _syncContexts = new BlockingCollection<SendOrPostCallback>(
+            );
+        private readonly Thread _mainThread = Thread.CurrentThread;
+
+        public FrameworkSyncContext()
+        {
+            _syncContexts = new BlockingCollection<SendOrPostCallback>();
+            _mainThread = Thread.CurrentThread;
+        }
+
+        public static FrameworkSyncContext MainThreadContext
+        {
+            get => _mainThreadContext;
+        }
+
+        public override void Post( SendOrPostCallback d, object state )
+        {
+            _syncContexts.Add( d );
+        }
+
+        public override void Send( SendOrPostCallback d, object state )
+        {
+            if( Thread.CurrentThread == _mainThread ) {
+                d( state );
+            } else {
+                Post( d, state );
+            }
+        }
+
+    }
+}